排序算法-归并、快速排序

排序算法-归并、快速排序

归并排序

归并排序思想：

1. 将要排序的一个数组分为大小大致相等的两部分
2. 对两个部分进行排序
3. 对排好序的两个部分进行合并，合并为一个有序的数组
   
   递推公式：
   mergesort(array,int p,int r]) = merge(mergesort(array,int p,int q),mergesort(array,int q+1,int r))
   终止条件：
   p>=r

		// 归并排序
        static void Main(string[] args)
        {
            int[] margesort = new int[]{ 4,5,6,3,2,1};
            MergeSort(margesort, 0, margesort .Length - 1);
            Console.WriteLine("Hello World!");
        }
        public static void MergeSort(int[] a,int p,int r)
        {
            if (p >= r) return;
            int q = (p + r) / 2;
            MergeSort(a, p, q);
            MergeSort(a, q + 1, r);
            Merge(a, p, q, r);
        }
        public static void Merge(int[] A, int p, int q, int r)
        {
            var temp = new int[r-p+1]; // 临时数组
            int i = p;int j = q + 1;
            int k = 0;
            while (i <= q && j <= r)
            {
                if (A[i] <= A[j])
                {
                    temp[k++] = A[i++];
                }
                else
                {
                    temp[k++] = A[j++];
                }
            }
            while(i <= q)
            {
                temp[k++] = A[i++];
            }
            while (j <= r)
            {
                temp[k++] = A[j++];
            }
            for(int v = 0; v < temp.Length; v++)
            {
                A[p + v] = temp[v];
            }
            Console.Write($"归并排序："); 
            foreach (var item in temp)
            {
                Console.Write($"{item}  ");
            }
            Console.Write("\n");
        }

归并排序性能分析：

1. 归并排序是稳定的排序算法；
2. 归并排序不是原地排序算法；每次递归都要辅助数组temp,temp的大小小于等于n。O(n)
3. 归并排序的时间复制度：（递归）问题A分为问题B和问题C两部分，T(A) = T(B) + T( C ) + K 其中K 代表将问题B和问题C合并为问题A的时间。当n个元素进行排序所需时间为T(n),分为数据规模大致相等的两部分，即T(n/2)。T(n) = T(n/2) + T(n/2) +n(merge函数中将两个数组合并的时间复杂度为O(n))。
   T(n) = 2T(n/2) + n = 4T(n/4) + 2n = 8T(n/8) + 3n … = 2 ^ k T(n/ 2^k) + kn 其中 T(1) = C 代入得到 当n/ 2 ^k == 1时，k = log N，T(n) = nlog n + Cn。
   所以归并排序最好情况、最坏情况、平均情况时间复杂度都是O(nlog n)。

快速排序

快速排序思想：在将要排序的数据中选择任一数据，将小于该数据的放左边，大于该数据的放右边，将该数据放中间，再分别对左右两边的数据进行上面操作直到区间缩小为1。

递推公式：
quicksort(A[p…r])=quicksort(A[p…q-1])+quicksort(A[q+1…r])
终止条件：
p>=r

		// 快速排序
        static void Main(string[] args)
        {
            int[] quicksort = new int[]{ 4,5,6,3,2,1};
            QuickSort(quicksort, 0, quicksort.Length - 1);
            Console.WriteLine("Hello World!");
        }
        public static void QuickSort(int[] a,int p,int r)
        {
            if (p >= r) return;
            int q = Partition(a,p,r); // 将数组分为左中右三部分，并返回中间结点位置
            QuickSort(a, p, q - 1);
            QuickSort(a, q + 1, r);
        }
        public static int Partition(int[] a,int p,int r)
        {
            var pivot = a[r];
            int i = p;
            for(int j = p; j <= r - 1; j++)
            {
                if (a[j] < pivot)
                {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                    i++;
                }
            }
            a[r] = a[i];
            a[i] = pivot;
            Console.Write("快速排序：");
            foreach(var item in a)
            {
                Console.Write(item + " ");
            }
            Console.Write("\n");
            return i;
        }

巧妙的分区函数Partition空间复杂度为O(1)：


快速排序性能分析：

1. 快速排序不是稳定的排序算法。
2. 快速排序是原地排序算法。
3. 快速排序时间复杂度：
   最好情况时间复杂度：分区均衡O(nlogn)
   最坏情况时间复杂度：分区及其不均衡 ，类似1，2，3，4，5，6，每次都需要原地交换，时间复杂度为O(n*n)
   平均情况时间复杂度：用递归树求解(还没看)