交换排序之快速排序

1.  快速排序（Quicksort）是对冒泡排序的一种改进。

      快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

2.  时间复杂度：

最优情况下的空间复杂度O(logn)---每次平分数组的情况

最差情况下的空间复杂度O(n)------退化为冒泡排序情况

最优情况下的时间复杂度O(nlogn)---- 每次平分数组的情况

最差情况下的时间复杂度O(n^2)---退化为冒泡排序

平均时间复杂度O(nlogn)

3.  算法原理：

1. 判断参数条件，递归的出口；
2. 以数组的第一个元素为基准元素，让数组的其他元素与其比较大小；
3. 从数组尾开始循环比较，直到遇到数组元素A小于基准元素时，将元素A放到第一个元素的位置；
4. 开始从头部开始往后循环数组，将指针指向下一个元素，直到找到一个元素B大于基准元素，将元素B放到数组尾部指针所指的元素的位置；
5. 依次循环3，4，直到两个指针相遇，将数组分成以基准元素为分割点的左右两部分，左侧全部比基准元素小，右侧全部比基准元素大。
6. 针对于5依次执行3，4，直到最后一个元素位置位置。

 4.  图表演示

       5.  总结：

 1. 取数组一端的元素作为基准元素，从另一侧开始循环比较（基准元素可以选择左侧第一个，从右侧开始循环比较；亦可以选择右侧最后一个为基准元素，从左侧开始循环比较）  ；

 2. 基准参数也可以选择数组的中间数值，即三数取中法。

      6.  C#代码实现

 class Program
    {
        static void Main(string[] args)
        {
            // 待排序数组
            int[] sortArray = { 5, 8, 3, 2, 9, 10, 1, 4, 7, 6 };
            Stopwatch sw = new Stopwatch();
            // 开始计时
            sw.Start();
            // 监控快速排序函数运行时间
            QuickSort(sortArray, 0, sortArray.Length - 1);
            // 计时结束
            sw.Stop();
            Console.WriteLine("快速排序方法耗时(毫秒)="+sw.ElapsedMilliseconds);
        }
        /// <summary>
        ///快速排序
        /// </summary>
        /// <param name="sortArray">待排序数组</param>
        /// <param name="low">下界指针</param>
        /// <param name="high">上界指针</param>
        private static void QuickSort(int[] sortArray, int low, int high)
        {
            // 数组长度大于1，才进行快排
            if (low < high - 1)
            {
                // 基准元素位置
                int pivotLocal = SortPartitionGet(sortArray, low, high);
                // 对低子表递归排序
                QuickSort(sortArray, low, pivotLocal - 1);
                // 对高子表递归排序
                QuickSort(sortArray, pivotLocal + 1, high);
            }
        }
        /// <summary>
        /// 返回每次排序后分割点
        /// </summary>
        /// <param name="sortArray">待排序数组</param>
        /// <param name="low">下界指针</param>
        /// <param name="high">上界指针</param>
        /// <returns></returns>
        private static int SortPartitionGet(int[] sortArray, int low, int high)
        {
            // 基准元素
            int pivot = sortArray[low];

            while (low < high)
            {
                // 基准元素与上指针指向的值比较，直到查找到上指针所指向值比基元素小的值（且指针没有相遇），将上指针指向的值赋值给低指针指向的值
                while (sortArray[high] >= pivot && low < high)
                {
                    --high;
                }
                sortArray[low] = sortArray[high];

                // 下指针指向的值与基准元素比较，直到找到下指针所指向的值大于基准元素的值（且指针没有相遇），将下指针指向的值赋值给上指针指向的值
                while (sortArray[low] <= pivot && low < high)
                {
                    ++low;
                }
                sortArray[high] = sortArray[low];
            }
            // 将基准元素赋值给指针相遇时，所指向的值
            sortArray[low] = pivot;
            SortShow(sortArray, low);
            return low;
        }
        private static void SortShow(int[] sortArray, int low)
        {
            for (int i = 0; i < sortArray.Length; i++)
            {
                Console.Write(sortArray[i] + " ");
            }
            Console.WriteLine();
        }
    }

7.  运行结果：

标签：sortArray,int,元素,交换,数组,排序,快速,指针
来源： https://www.cnblogs.com/suxiuyan/p/12620433.html