氣泡排序

• 氣泡排序的視覺化圖：

  • 

• 氣泡排序的概念:氣泡排序是一種交換排序，它的基本思想是：兩兩比較相鄰記錄的關鍵字，如果反序則交換，直至沒有反序的記錄為止。因為按照該演算法，每次比較會將當前未排序的記錄序列中最小的關鍵字移至未排序的記錄序列最前（或者將當前未排序的記錄序列中最大的關鍵字移至未排序的記錄序列最後），就像冒泡一樣，故以此為名。

• 氣泡排序演算法的演算法描述如下：

  • 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
  • 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。
  • 針對所有的元素重複以上的步驟，除了最後一個。
  • 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

• 氣泡排序的程式碼實現：

static void BubbleSort(int[] arr)
{
    int temp = 0;
    bool isSwapped = false;
    for (int m = 0; m < arr.Length - 1; ++m)
    {
        for (int i = 0; i < arr.Length - 1 - m; ++i)
        {
            if (arr[i] > arr[i + 1])
            {
                temp = arr[i];
                arr[i] = arr[i + 1
 
];
                arr[i + 1] = temp;
                if (!isSwapped)
                    isSwapped = true;
            }
        }
        if (!isSwapped)
            return;
    }
}

• 氣泡排序的複雜度：
  
  • 時間複雜度 $O(n^{2})$
  • 最優時間複雜度 $O(n)$
  • 平均時間複雜度 $O(n^{2})$
  • 空間複雜度：總共 $O(n)$，輔助空間： $O(1)$

雞尾酒排序

• 雞尾酒排序的視覺化圖：

  • 

• 雞尾酒排序的概念:雞尾酒排序又叫定向氣泡排序，雞尾酒攪拌排序，攪拌排序（也可以視作選擇排序的一種變形），漣漪排序，來回排序或快樂小時排序，是氣泡排序的一種變形。此演算法與氣泡排序的不同處在於排序時是以雙向在序列中進行排序。

• 雞尾酒排序的演算法描述如下：

  • 先對陣列從左到右進行升序的氣泡排序；
  • 再對陣列進行從右到左的降序的氣泡排序；
  • 以此類推，持續的、依次的改變冒泡的方向，並不斷縮小沒有排序的陣列範圍；

• 雞尾酒排序程式碼實現：

static void CocktailSort(int[] arr) 
{
    int i, temp, left = 0, right = arr.Length - 1;
    while (left < right) {
        for (i = left; i < right; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        right--;
        for (i = right; i > left; i--)
        {
            if (arr[i - 1] > arr[i])
            {
                temp = arr[i];
                arr[i] = arr[i - 1];
                arr[i - 1] = temp;
            }
        }
        left++;
    }
}

• 雞尾酒排序複雜度：
  
  • 時間複雜度 $O(n^{2})$
  • 最優時間複雜度 $O(n)$
  • 平均時間複雜度 $O(n^{2})$

快速排序

• 快速排序的視覺化圖：

  • 

• 快速排序的概念：又稱劃分交換排序（partition-exchange sort），一種排序演算法，最早由東尼·霍爾提出。在平均狀況下，排序n個專案要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他Ο(n log n)演算法更快，因為它的內部迴圈（inner loop）可以在大部分的架構上很有效率地被實現出來。

• 快速排序演算法的演算法描述如下:

  • 從數列中挑出一個元素，稱為”基準”（pivot），
  • 重新排序數列，所有比基準值小的元素擺放在基準前面，所有比基準值大的元素擺在基準後面（相同的數可以到任一邊）。在這個分割槽結束之後，該基準就處於數列的中間位置。這個稱為分割槽（partition）操作。
  • 遞迴地（recursively）把小於基準值元素的子數列和大於基準值元素的子數列排序。

• 快速排序的程式碼實現：

public static void QuickSort(int[] arr)
{
    QuickSort(arr, 0, arr.Length - 1);
}

private static void QuickSort(int[] arr, int left, int right)
{
    if (left < right)
    {
        int middle = arr[(left + right) / 2];
        int i = left - 1;
        int j = right + 1;
        while (true)
        {
            while (arr[++i] < middle) ;

            while (arr[--j] > middle) ;

            if (i >= j)
                break;

            Swap(arr, i, j);
        }

        QuickSort(arr, left, i - 1);
        QuickSort(arr, j + 1, right);
    }
}

private static void Swap(int[] arr, int i, int j)
{
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

• 快速排序的複雜度:
  
  • 時間複雜度 $O(n^{2})$
  • 最優時間複雜度 $n\log n$
  • 平均時間複雜度 $n\log n$
  • 空間複雜度: 根據實現的方式不同而不同

如有錯誤，歡迎指出。

QQ:812123870,

郵件：dxmdxm1992#gmail.com