O(n^2)級別的算法主要包括：選擇排序，插入排序，冒泡法排序，希爾排序等

選擇排序：選擇排序，將後面未排序數組中最小的與前面的元素交換

 1 template <typename T>
 2 void selectionSort(T arr[], int n) {
 3     for (int i = 0; i < n; i++) {
 4         int minIndex = i;
 5         for (int j = i + 1; j < n; j++) {
 6             if (arr[j] < arr[minIndex])
 
 7                 minIndex = j;
 8         }
 9 
10         swap(arr[i], arr[minIndex]);
11     }
12 }

插入排序,選擇前面數組已經排好序的部分合適的插入位置

 1 template <typename T>
 2 void insertionSort1(T arr[], int n) {
 3     for (int i = 1; i < n; i++) {
 4         T e = arr[i];
 5         int j;
 6         for
 
 (j = i; j > 0 && arr[j - 1]>e; j--) {//從後往前找合適位置插入
 7             arr[j] = arr[j - 1];
 8         }
 9         arr[j] = e;
10     }
11 }
12 // 對arr[l...r]範圍的數組進行插入排序
13 template<typename T>
14 void insertionSort(T arr[], int l, int r) {
15 
16     for (int i = l + 1; i <= r; i++) {
 
17 
18         T e = arr[i];
19         int j;
20         for (j = i; j > l && arr[j - 1] > e; j--)
21             arr[j] = arr[j - 1];
22         arr[j] = e;
23     }
24 
25     return;
26 }

冒泡法：每次循環將最大的放到擠出到後面位置

 1 template <typename T>
 2 void bubbleSort(T arr[], int n) {
 3     for (int i = 0; i < n - 1; i++) {
 4         for (int j = 0; j < n - i - 1; j++) {
 5             if (arr[j + 1] < arr[j]) {
 6                 swap(arr[j + 1], arr[j]);//非常耗時
 7             }
 8         }
 9     }
10 }

//希爾排序
template<typename T>
void shellSort(T arr[], int n) {

    // 計算 increment sequence: 1, 4, 13, 40, 121, 364, 1093...
    int h = 1;
    while (h < n / 3)
        h = 3 * h + 1;

    while (h >= 1) {

        // h-sort the array
        for (int i = h; i < n; i++) {

            // 對 arr[i], arr[i-h], arr[i-2*h], arr[i-3*h]... 使用插入排序
            T e = arr[i];
            int j;
            for (j = i; j >= h && e < arr[j - h]; j -= h)
                arr[j] = arr[j - h];
            arr[j] = e;
        }

        h /= 3;
    }
}

基礎排序總結