數據結構與算法 排序算法 快速排序【詳細步驟圖解】

快速排序

給定一個序列：22 33 49 47 33' 12 68 29

進行快速排序

主要思想

• 從序列中，任選一個記錄k做爲軸值 pivot

  選擇策略：

  • 第一個元素
  • 最後一個元素
  • 中間元素
  • 隨機選擇

• 將剩餘的元素，分割成 左子序列 L 和 右子序列 R

• L 中全部元素都 < k， R 中全部元素都 > k

• 對 L 和 R遞歸進行快排，直到子序列中有 0 個 或者 1 個元素，退出

圖解

初始數組：

選定47爲軸值pivot

pivot與最後一個值29進行交換（把pivot放到最後面）

接下來，以pivot=47爲界，分紅左子序列 L 和右子序列 R

比47大的都放在右邊，比47小的都放在左邊（用的交換）

遍歷數組

• 兩個指針left和right
• 當left != right的時候
  • 若arr[left]的，小於等於pivot，且left < right的時候，left右移
    • 若是left和right未相遇，把left的值賦給right對應的值
    • arr[right] = arr[left]
    • left指針中止移動，輪到right移動
  • 當arr[right]的值，大於等於pivot，且right > left的時候，right左移
    • 若是left和right未相遇。把right的值賦給left對應的值
    • arr[left] = arr[right]
    • right指針中止移動，輪到left移動
• 注意：軸值用pivot保存

第一輪分割序列

pivot=47和最後一個值互換

22 <= 47，left向右移動

33 <= 47，left向右移動

49 > 47，不知足arr[left] <= pivot

把left的值賦給right

arr[right] = arr[left]

賦值事後，left不動，right向左移動

68 >= 47，right向左移動

12 < 47，不知足arr[right] >= pivot

把right的值賦給left

arr[left] = arr[right]

賦值事後，right不動，left向右移動

29 < 47，left向右移動

33' < 47，left向右移動

向右移動後，left == right，退出循環

將pivot賦給arr[left]

至此，第一輪分割序列完成

第二輪分割序列 --- 左子序列

通過第一輪分割，47左邊的是左子序列，右邊是右子序列

第二輪對左子序列分割，選擇中間值做爲pivot

12和33'進行交換

22 > 12，不知足arr[left] <= pivot

把arr[left]賦給arr[right]

arr[right] = arr[left]

賦值事後，left不動，right向左移動

2九、33'、33都比12大，因此right一直移動到下圖位置

33 > 12,right繼續向左移動

此時right == left，終止循環

把pivot賦給arr[left]

至此，左子序列1也分割完成了

小結

快排就是一個遞歸的過程，分割獲得左子序列

再對左子序列進行快排分割，獲得左子序列的左子序列....

處理完左邊，再去處理右邊的右子序列

第三輪分割序列 --- 右子序列

右子序列只有4七、6八、49，選擇48做爲軸值 pivot

pivot和最後一個值交換

4七、49都比pivot=68小，left一直向右移動，直到left == right

分割以後，只剩下左子序列：4七、49

4七、49，選49做爲軸值，獲得左子序列47

子序列只剩下一個元素47，就沒必要排序了，右邊排序結束

結果：4七、4九、68

C++實現

選擇中間的值做爲軸值

#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <stack>
#include <cmath>
#include <map>

using namespace std;


/**
 *
 * @param arr   待分割的序列
 * @param left  左邊界
 * @param right 右邊界
 * @return      分割後軸值的位置
 */

template<class T>
int PartitionArr(vector<T>& arr, int left, int right) {
    T temp = arr[right];
    while (left != right) {
        while (arr[left] <= temp && left < right) {
            left++;
        }
        if (left < right) {
            arr[right] = arr[left];
            // 賦值後，left不動，right向左移
            right--;
        }
        while (arr[right] >= temp && right > left) {
            right--;
        }
        if (left < right) {
            arr[left] = arr[right];
            // 賦值後，right不動，left向右移
            left++;
        }
    }
    // 當left == right，把軸值放回left上
    arr[left] = temp;
    return left;
}

/**
 *
 * @param arr   待排序數組
 * @param left  左邊界
 * @param right 右邊界
 */
template<class T>
void quickSort(vector<T>& arr, int left, int right) {
    // 子序列剩下0或1個元素，排序結束
    if (right <= left) {
        return;
    }

    //  選擇數組中間做爲軸值
    int pivot = (left + right) / 2;
    // 把軸值放到數組最後面
    swap(arr[right], arr[pivot]);
    // 分割後軸值的位置
    // 分割後，左邊值 < 軸值 < 右邊值
    pivot = PartitionArr(arr, left, right);
    quickSort(arr, left, pivot - 1);
    quickSort(arr, pivot + 1, right);
}


int main() {
    vector<int> arr = { 22,33,49,47,33,12,68,29 };
    for (auto& i : arr) {
        cout << i << ' ';
    }

    cout << endl << endl;

    quickSort(arr, 0, arr.size() - 1);

    for (auto& i : arr) {
        cout << i << ' ';
    }

    cout << endl << endl;
    system("pause");
    return 0;
}

總結

• 快排是不穩定的排序算法

  • 33 33'排序後可能變成33' 33

• 時間複雜度：

  • 平均：\(O(Nlog_N)\)
  • 最差：\(O(N^2)\)，退化爲冒泡排序

• 空間複雜度：

  • 遞歸調用消耗棧空間
  • 最優：\(O(log_N)\)
  • 最差：\(O(N)\)，退化爲冒泡排序