公共函式，用以測試陣列相等

namespace SortCommon {
    bool ArrEqual(int arr1[], int arr2[], int n) {
        for (int i = 0; i < n; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }
}

選擇排序

時間複雜度O(N*N), 不穩定排序

    // O(N * N), 不穩定排序
    void SelectSortTest(int arr[], int n) {
        for (int i = 0; i < n - 1; ++i) {
            int minIndex = i;
            for (int j = i + 1; j < n; ++j) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            std::swap(arr[i], arr[minIndex]);
        }
    }

 

測試

   void test() {
        int arr1[]{9, 3, 7, 6, 5, 1, 8, 2, 4};
        int arr1r[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
        SelectSortTest(arr1, 9);
        assert(SortCommon::ArrEqual(arr1, arr1r, 9) == true);

        int arr2[]{1};
        int arr2r[]{1};
        SelectSortTest(arr2, 1);
        assert(SortCommon::ArrEqual(arr2, arr2r, 1));

        int arr3[]{2, 1};
        int arr3r[]{1, 2};
        SelectSortTest(arr3, 2);
        assert(SortCommon::ArrEqual(arr3, arr3r, 2));

        return;
    }

插入排序

時間複雜度O(N*N)，穩定排序，如果待排序陣列基本有序，則插入排序有較高的效率，特別的，當陣列完全有序，則插入排序時間複雜度下降到O(N)

    // 第一版
    void InsertSortTest(int arr[], int n) {
        for (int i = 1; i < n; ++i) {
            for (int j = i; j > 0; --j) {
                if (arr[j] < arr[j - 1]) {
                    std::swap(arr[j], arr[j - 1]);
                }
            }
        }
    }

    // 第二版， 優化，提前終止內層迴圈，減少內層迴圈次數
    void InsertSortTest(int arr[], int n) {
        for (int i = 1; i < n; ++i) {
            for (int j = i; j > 0 && arr[j] < arr[j - 1]; --j) {
                std::swap(arr[j], arr[j - 1]);
            }
        }
    }

    // 第三版， 優化，將元素交換修改為賦值，較少元素賦值次數
    void InsertSortTest(int arr[], int n) {
        for (int i = 1; i < n; ++i) {
            int temp = arr[i];
            int j = i;
            for (; j > 0 && temp < arr[j - 1]; --j) {
                arr[j] = arr[j - 1];
            }
            arr[j] = temp;
        }
    }

測試

    void test() {
        int arr1[]{9, 3, 7, 6, 5, 1, 8, 2, 4};
        int arr1r[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
        InsertSortTest(arr1, 9);
        assert(SortCommon::ArrEqual(arr1, arr1r, 9) == true);

        int arr2[]{1};
        int arr2r[]{1};
        InsertSortTest(arr2, 1);
        assert(SortCommon::ArrEqual(arr2, arr2r, 1));

        int arr3[]{2, 1};
        int arr3r[]{1, 2};
        InsertSortTest(arr3, 2);
        assert(SortCommon::ArrEqual(arr3, arr3r, 2));

        return;
    }