希尔排序， 插入排序， 冒泡排序， 选择排序【C++】

测试代码

#include <iostream>
using namespace std;

int main() {

    int arr[6] = { 0 };
    int len = sizeof(arr) / sizeof(int);
    
    for (int i = 0; i < len; i++) {
        cin >> arr[i];
    }
    
    int n = 6;
    // write your code here......





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

希尔排序

  希尔排序的实现分为两部分：

1. 预排序， 使得整个数组接近有序。
2. 插入排序

首先使用将数组分组gap组，元素之间间隔gap为一组

假设gap = 3;则：

上图中不同颜色的线将数组分成了gap组,，也就是3组。

然后每组之间进行排序：

int gap = 3;
        for(int i = 0; i < arr.size()-gap; i += gap)
        {
            int j = i;
            int t = arr[j+gap];
            while(j >= 0 && arr[j] > t)
            {
                arr[j+gap] = arr[j];
                j -= gap;
            }
            arr[j+gap] = t;
        }

上面这段代码可以将红色线的组进行排序；

结果如上；

现在将所有组分别进行排序：

int gap = 3;
for (int j = 0; j < gap; j ++) {
    for (int i = j; i < arr.size() - gap; i += gap) {
        int j = i;
        int t = arr[j + gap];
        while (j >= 0 && arr[j] > t) {
            arr[j + gap] = arr[j];
            j -= gap;
        }
        arr[j + gap] = t;
    }
}

自此，第一步与排序完成，得到的结果如下：

不过这段代码可以进行优化：

int gap = 3;
for (int i = 0; i < arr.size() - gap; i ++) {
    int j = i;
    int t = arr[j + gap];
    while (j >= 0 && arr[j] > t) {
        arr[j + gap] = arr[j];
        j -= gap;
    }
    arr[j + gap] = t;
}

对于gap，gap越小，预排序出来的数组越有序， 当gap = 1时， 就是插入排序。

越有序，插入的时候移动的次数就越少，效率就越高。

如果 gap 过小，排序过程可能会退化为类似于插入排序的方式，此时性能优势可能不再明显。

较大的 gap 可以让元素跨越较长的距离进行移动，从而更快地使数组逐渐趋向有序，减少最终的移动次数。

因此选择的是gap慢慢减小，通常使用Knuth提出的gap = [gap / 3] + 1；得到下面的代码：

int gap = arr.size();
while (gap > 1) {
    gap = gap / 3 + 1;
    for (int i = 0; i < arr.size() - gap; i++) {
        int j = i;
        int t = arr[j + gap];
        while (arr[j] > t && j >= 0) {
            arr[j + gap] = arr[j];
            j -= gap;
        }
        arr[j + gap] = t;
    }
}

选择排序

for(int i = 0; i < n; i++)
   {
    int t = i;
    for(int j = i+1; j < n; j++)
    {
        if(arr[j] < arr[t])
        {
            t = j;
        }
    }
    swap(arr[i], arr[t]);
   }

冒泡排序

bool flag = true;
   while(flag)
   {
    flag = false;
    for(int i = 1; i < n; i++)
    {
        if(arr[i-1] > arr[i])
        {
            swap(arr[i-1], arr[i]);
            flag = true;
        }
    }
   }

插入排序

for(int i = 1; i < n; i++)
   {
    int j = i-1;
    int key = arr[i];
    while(j >= 0 && arr[j] > key)
    {
        arr[j+1] = arr[j];
        j--;
    }
    arr[j+1] = key;
   }