算法排序---復雜度o(nlogn)的排序方式

   上次寫的算法排序的文章都是O(logn^2)的，這次寫兩個比較常用的經典的排序算法：歸並排序和快速排序。

   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)。