归并排序、快速排序---时间复杂度为O（nlog n）的排序方式

1.归并排序

    也就是合并排序，将两个或两个以上的有序数据序列合并成一个新的有序数据序列，它的基本思想是假设数组A有N个元素，那么可以看成数组A有N个有序的子序列组成，每个子序列的长度为1，然后在将两两合并，得到一个N/2个长度为2或1的有序子序列，再两两合并，如此重复，直到得到一个长度为N的有序序列为止。

例如：数组A有7个数据，分别是 23,5,69,85,26,32,15 采用归并排序算法的操作过程如下：

   初始值【23】【5】【69】【85】【26】【32】【15】

   第一次 会被分成两组【23】【5】 【69】，【85】【26】【32】【15】

   第二次  将第一组分成【23】，【5】 【69】两组

   第三次  将第二次分的第二组进行拆分【5】，【69】两组

   第四次  对第三次拆分数组进行合并排序【5 69】

   第五次  第四次排序好的数组和第二次拆分的数组合并为【5 23 69】

   接下来 对第一次拆分的第二数组做同样的过程操作，合并为【15 26 32 85】

   最后将两个有序的数组做最后的合并【5 15 23 26 32 69 85】

 

   该算法的核心思想是采用了分治思想，即将一个数组分成若干个小数组排序，排序后再两两合并的过程。

   首先看合并的过程实现，上代码：

//将两个排序好的序列合并
        void Merge(int[] left, int[] right, int[] mergeArr)
        {
            int i = 0, j = 0, k = 0;

            while (i < left.Length && j < right.Length)
            {
                if (left[i] < right[j]) //将元素小的放在合并的序列内
                {
                    mergeArr[k] = left[i];
                    i++;
                }
                else
                {
                    mergeArr[k] = right[j];
                    j++;
                }
                k++;
            }

           //有左元素 没有右元素的情况
            while (i < left.Length)
            {
                mergeArr[k] = left[i];
                i++;
                k++;
            }

           //有右元素 没有左元素的情况
            while (j < right.Length) 
            {
                mergeArr[k] = right[j];
                j++;
                k++;
            }
        }

   下面看看如何将一个数组分成若干个小组的过程：

public int[] MergeSort(int[] arr)
        {
            if (arr == null || arr.Length == 0)
                return arr;

            int middle = arr.Length >> 1;

            //左数组
            int[] left = new int[middle];

            //右数组
            int[] right = new int[arr.Length - middle];

            for (int i = 0; i < arr.Length; i++)
            {
                if (i < middle)
                    left[i] = arr[i];
                else
                    right[i - middle] = arr[i];
            }

            if (arr.Length > 1)
            {
                //递归左序列
                left = MergeSort(left);

                //递归右序列
                right = MergeSort(right);

                Merge(left, right, arr);
            }

            Console.WriteLine("归并排序过程：{0}", String.Join(",", arr.ToArray()));

            return arr;
        }

2.快速排序

    在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n²)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环可以在大部分的架构上很有效率地被实现出来，且在大部分真实世界的数据，可以决定设计的选择，减少所需时间的二次方项之可能性。

快速排序使用分治法策略来把一个串行分为两个子串行。

步骤为：

1. 从数列中挑出一个元素，称为 "基准"，
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区操作。
3. 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代中，它至少会把一个元素摆到它最后的位置去。

    看图：

//快速排序2
        public List<int> QuickSort(List<int> arr)
        {
            if (arr.Count <= 1) return arr;

            int pivotIndex = arr.Count >> 1;
            int pivot = arr[pivotIndex];
            arr.Remove(pivot);

            List<int> left = new List<int>();
            List<int> right = new List<int>();

            for (int i = 0; i < arr.Count; i++)
            {
                if (arr[i] < pivot)
                    left.Add(arr[i]);
                else
                    right.Add(arr[i]);
            }

            var newArr = QuickSort(left);
            newArr.Add(pivot);
            newArr.AddRange(QuickSort(right));
            Console.WriteLine("已排序的序列*********{0}",(String.Join(",",newArr.ToArray())));
            return newArr;
        }

快速排序是二叉查找树的一个空间优化版本。不以循序地把项目插入到一个明确的树中，而是由快速排序组织这些项目到一个由递归调用所意含的树中。这两个算法完全地产生相同的比较次数，但是顺序不同。

快速排序的最直接竞争者是堆排序（Heapsort）。堆排序通常比快速排序稍微慢，但是最坏情况的运行时间总是O(n log n)。