數據結構算法 - 冒泡、選擇和插入排序

排序算法我們一般可以從以下幾個方面入手：

1. 手寫排序算法；
2. 時間複雜度，空間複雜度，排序的穩定性；
3. 能夠了解各大排序算法的優劣，能根據具體的場景選擇合適的算法；
4. 能夠優化排序算法。

一.冒泡排序

冒泡排序的思想：重複地遍歷要排序的列表，比較每一對相鄰項，如果它們的順序不對，就交換它們。重複遍歷列表，直到不需要交換。

template<typename T>
void bubbleSort(T arr[], int len) {
    for (int i = 0; i < len - 1; ++i) {
        for (int j = 0; j < len - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);
            }
        }
    }
}

時間複雜度：兩個 for 循環嵌套，執行的次數是 n-1+n-2+n-3+…+1 。轉換一下是 1+2+3+4+…+n-1, 這便是初中數學的等差數列求和即 n²/2-n/2 。因此冒泡排序的時間複雜度是O(n²)級別的。

二.選擇排序

選擇排序的思想：重複地遍歷要排序的列表，比較每一對相鄰項，記錄最小位置的角標，每循環一次後與最小位置進行交換。重複遍歷列表，直到不需要交換。

void selectSort(int arr[], int len) {
    for (int i = 0; i < len - 1; ++i) {
        int min = i;
        for (int j = i + 1; j < len; ++j) {
            if (arr[min] > arr[j]) {
                min = j;
            }
        }
        std::swap(arr[i], arr[min]);
    }
}

時間複雜度與冒泡排序的求法一致都是 O(n²) 級別的，但我們不妨來測試一下執行時間，假設對 20000 數據進行排序，我們分別來看下冒泡和選擇所花費時間。

    // 隨機創建一個數組
    int *create_array(int len, int low, int high) {
        int *arr = new int[len];

        for (int i = 0; i < len; ++i) {
            arr[i] = rand() % (high-low) + low;
        }

        return arr;
    }

    // copy 一份數組
    int *copy_array(int *arr, int len) {
        int *copy_arr = (int *) malloc(sizeof(int) * len);
        memcpy(copy_arr, arr, sizeof(int) * len);
        return copy_arr;
    }

    // 創建接一組近有序的數組
    int *create_nearly_ordered_array(int len, int swapNums) {
        int *arr = new int[len];

        for (int i = 0; i < len; ++i) {
            arr[i] = i;
        }

        for (int i = 0; i < swapNums; ++i) {
            int randomX = rand() % (len - 1);
            int randomY = rand() % (len - 1);
            std::swap(arr[randomX], arr[randomY]);
        }

        return arr;
    }

    // 利用函數指針來對數組排序，並打印排序時間
    void sort_array(char *sortName, void(*sort)(int *, int), int *arr, int len) {
        clock_t start = clock();
        sort(arr, len);
        clock_t end = clock();
        LOGE("%s執行時間：%lf", sortName, static_cast<double>(end - start) / CLOCKS_PER_SEC * 1000);

        for (int i = 1; i < len; ++i) {
            assert(arr[i] >= arr[i - 1]);
    }
                

對 20000 條隨機數據進行排序，檢測結果冒泡排序消耗 4.434036s 選擇排序消耗 2.381274s ，對 20000 條接近有序的數據進行排序，檢測結果冒泡排序消耗 2.282863s 選擇排序消耗 2.379822s 。爲什麼會這樣我相信我們心裏都有了答案，因此基於這個測試，我們便可以去優化我們的排序算法了，從兩個方面入手，減少我們循環次數或者減少交換次數。這篇文章主要是分析排序算法，所以這裏先不介紹優化，後面的文章我會陸續公佈答案。

二.插入排序

插入排序的思想：插入排序是在一個已經有序的小序列的基礎上，一次插入一個元素。比較是從有序序列的末尾開始，也就是想要插入的元素和已經有序的最大者開始比起，如果比它大則直接插入在其後面，否則一直往前找直到找到它該插入的位置。

void insertSort(int arr[], int len) {
    int j;
    for (int i = 1; i < len; ++i) {
        int temp = arr[i];
        for (j = i; j > 0 && temp < arr[j - 1]; --j) {
            arr[j] = arr[j - 1];
        }
        arr[j] = temp;
    }
}

對 20000 條隨機數據進行排序，檢測結果冒泡排序消耗 4.434036s ，選擇排序消耗 2.381274s ，插入排序消耗 2.054081s 。對 20000 條接近有序的數據進行排序，檢測結果冒泡排序消耗 2.282863s ，選擇排序消耗 2.379822s ，插入排序消耗 0.006815s 。我們可以看到對於一個接近有序的序列，插入排序所消耗的時間遠遠要低於其他排序算法，那是因爲對於一個接近有序的數據，插入排序的時間複雜度最優可達 O(n) 級別。

視頻鏈接:https://pan.baidu.com/s/1vi2Ub11_lWnWKhR-MdJ-yg
視頻密碼:bl6b