本博文介紹兩個最常被提起的排序演算法：氣泡排序和快速排序。氣泡排序是入門排序演算法，思路比較常規，但確是最耗時的排序演算法，所以聽到氣泡排序笑一笑就好了，千萬不要拿來裝B。另一個是被譽為的面試必知演算法快速排序，以及針對陣列特徵進行優化的“隨機快排”和“平衡快排”。

氣泡排序

(一)概念及實現

氣泡排序的原理：重複的遍歷要排序的陣列，每次遍歷過程中從頭至尾比較兩個相鄰的元素，若順序錯誤則交換兩個元素。

具體如下（實現為升序）：

設陣列為a[0…n]。

1.從頭至尾比較相鄰的元素。如果第一個元素比第二個元素大，就交換。

2.重複步驟1，每次遍歷都將冒出一個最大數，直到排序完成。

實現程式碼：

        public static void Sort<T>(IList<T> arr) where T : IComparable<T>
        {
            if (arr == null)
                throw new ArgumentNullException("arr");

            int length = arr.Count();
            if (length > 1)
            {
                bool isSorted = false;

                // 迴圈n-2次，每迴圈完一次，冒泡的一個最大值
                for (int i = 0; i < length - 1; i++)
                {
                    // 如果一次迴圈沒有發生交換，則說明剩餘的元素是有序的。
                    isSorted = true;

                    for (int j = 1; j <= length - 1 - i; j++)
                    {
                        // 相鄰兩個元素比較，將較大的交換到右邊arr[j]中
                        if (arr[j - 1].CompareTo(arr[j]) > 0)
                        {
                            isSorted = false;

                            Swap(arr, j - 1, j);
                        }
                    }

                    if (isSorted)
                        break;
                }
            }
        }

        /// <summary>
        /// 陣列元素交換
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="arr">陣列</param>
        /// <param name="i">交換元素1</param>
        /// <param name="j">交換元素2</param>
        static void Swap<T>(IList<T> arr, int i, int j)
        {
            T temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

示例：

89,-7,999,-89,7,0,-888,7,-7

排序的過程：

-7 89 -89 7 0 -888 7 -7 [999]

-7 -897 0 -888 7 -7 [89] 999

……

……

-888 [-89] -7 -7 0 7 7 89 999

(二)演算法複雜度

1.時間複雜度：O(n^2)

氣泡排序耗時的操作有：比較 + 交換（每次交換兩次賦值）。時間複雜度如下：

1)最好情況：序列是升序排列，在這種情況下，需要進行的比較操作為（n-1）次。交換操作為0次。即O(n)

2)最壞情況：序列是降序排列，那麼此時需要進行的比較共有次。交換運算元和比較運算元一樣。即

O(n^2)

3)漸進時間複雜度（平均時間複雜度）：O(n^2)

2.空間複雜度：O(1)

從實現原理可知，氣泡排序是在原輸入陣列上進行比較交換的（稱“就地排序”），所需開闢的輔助空間跟輸入陣列規模無關，所以空間複雜度為：O(1)

(三)穩定性

氣泡排序是穩定的，不會改變相同元素的相對順序。

(四)優化改進

1.有序優化：在進行相鄰元素比較時，可以記錄下迴圈中沒有發生交換的多個連續索引對（起始索引和結束索引），在下次輪詢時直接對有序區間的最大值進行比較。

2.雙向冒泡：參考資料過程中看到了雙向冒泡，不同之處在於“從左至右與從右至左兩種冒泡方式交替執行”，個人認為不能提高演算法效率並且增加程式碼複雜度。

快速排序

(一)概念及實現

思想：分治策略。

快速排序的原理：通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序。

"保證列表的前半部分都小於後半部分"就使得前半部分的任何一個數從此以後都不再跟後半部分的數進行比較了，大大減少了數字間的比較次數。

具體如下（實現為升序）：

設陣列為a[0…n]。

1.陣列中找一個元素做為基準(pivot)，通常選陣列的第一個數。

2.對陣列進行分割槽操作。使基準元素左邊的值都小於pivot，基準元素右邊的值都大於等於pivot。

3.將pivot值調整到分割槽後的正確位置。

4.將基準兩邊的分割槽序列，分別進行步驟1~3。（遞迴）

5.重複步驟1~4，直到排序完成。

實現程式碼：

        /// <summary>
        /// 快速排序
        /// </summary>
        /// <param name="arr">待排序陣列</param>
        /// <param name="left">左邊界索引</param>
        /// <param name="right">右邊界索引</param>
        /// <param name="SelectPivot">選擇基準元素委託，並且將基元素與左邊界元素交換</param>
        private static void DoSort<T>(IList<T> arr, int left, int right
            , Action<IList<T>, int, int> SelectPivot) where T : IComparable<T>
        {
            count++;
            if (left < right)
            {
                // 選擇基準元素委託
                if (SelectPivot != null)
                    SelectPivot(arr, left, right);

                // 臨時儲存基準元素，以讓其他陣列元素來填充該位置
                T pivot = arr[left];
                int low = left;
                int high = right;

                while (low < high)
                {
                    // 從右向左找第一個小於 基數 的數  
                    while (low < high && arr[high].CompareTo(pivot) >= 0)
                        high--;
                    if (low < high)
                        arr[low++] = arr[high];

                    // 從左向右找第一個大於等於 基數 的數
                    while (low < high && arr[low].CompareTo(pivot) < 0)
                        low++;
                    if (low < high)
                        arr[high--] = arr[low];
                }
                arr[low] = pivot;   // 此時 low = high

                // 兩個分割槽遞迴。基準元素無需在參與下一次快速排序
                // 加入if判斷可以減少50%-55%的遞迴次數
                if (left < low - 1)
                    DoSort<T>(arr, left, low - 1, SelectPivot);
                if (low + 1 < right)
                    DoSort<T>(arr, low + 1, right, SelectPivot);
            }
        }

   特別注意在遞迴前的判斷語句，他減少了50%-55%的遞迴次數。

示例：

89,-7,999,-89,7,0,-888,7,-7

排序的過程：

（以陣列第一個元素做為基準值。藍色代表被分割槽出來的子陣列，綠色代表本次分割槽基準值）

(二)演算法複雜度

1.時間複雜度：O(nlog₂n)

快速排序耗時的操作有：比較 + 交換（每次交換兩次賦值）。時間複雜度如下：

1)最好情況：選擇的基準值剛好是中間值，分割槽後兩分割槽包含元素個數接近相等。因為，總共經過x次分割槽，根據2^x<=n得出x=log₂n，每次分割槽需用n-1個元素與基準比較。所以O(nlog₂n)

2)最壞情況：每次分割槽後，只有一個分割槽包含除基準元素之外的元素。這樣就和氣泡排序一樣慢，需O(n^2)

3)漸進時間複雜度（平均時間複雜度）：O(nlog₂n)

2.空間複雜度：O(1)

從實現原理可知，快速排序是在原輸入陣列上進行比較分割槽的（稱“就地排序”），所需開闢的輔助空間跟輸入陣列規模無關，所以空間複雜度為：O(1)

(三)穩定性

快速是不穩定的，會改變相同元素的相對順序。如示例，以第一個基準89排序時，首先將最後一個元素-7移到了第一個分割槽的第一個位置上。改變了與第二個-7的相對順序。

相關推薦