其他分享
首页 > 其他分享> > 交换排序之快速排序

交换排序之快速排序

作者:互联网

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