1. 插入排序

步骤：

• 从第一个元素开始，该元素可以认为已经被排序
• 取下一个元素tem，从已排序的元素序列从后往前扫描
• 如果该元素大于tem，则将该元素移到下一位
• 重复步骤3，直到找到已排序元素中小于等于tem的元素
• tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置
• 重复步骤2~5

动图演示如下：

思路：

在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个元素有序。按照此法对所有元素进行插入，直到整个序列有序。

但我们并不能确定待排元素中究竟哪一部分是有序的，所以我们一开始只能认为第一个元素是有序的，依次将其后面的元素插入到这个有序序列中来，直到整个序列有序为止。

代码如下：

void InsertSort(int* arr, int n){
    for (int i = 0; i < n - 1; ++i) {
        //记录有序序列最后一个元素的下标
        int end = i;
        //待插入的元素
        int tem = arr[end + 1];
        //单趟排
        while (end >= 0) {
                //比插入的数大就向后移
                if (tem < arr[end]) {
                        arr[end + 1] = arr[end];
                        end--;
                }
                //比插入的数小，跳出循环
                else {
                        break;
                }
        }
        //tem放到比插入的数小的数的后面
        arr[end  + 1] = tem;
        //代码执行到此位置有两种情况:
        //1.待插入元素找到应插入位置（break跳出循环到此）
        //2.待插入元素比当前有序序列中的所有元素都小（while循环结束后到此）
    }
}

时间复杂度：最坏情况下为O(N*N)，此时待排序列为逆序，或者说接近逆序.最好情况下为O(N)，此时待排序列为升序，或者说接近升序。

空间复杂度：O(1)

2.希尔排序

步骤：

• 先选定一个小于N的整数gap作为第一增量，然后将所有距离为gap的元素分在同一组，并对每一组的元素进行直接插入排序。然后再取一个比第一增量小的整数作为第二增量，重复上述操作…
• 当增量的大小减到1时，就相当于整个序列被分到一组，进行一次直接插入排序，排序完成。

动图如下：

思路：

希尔排序，先将待排序列进行预排序，使待排序列接近有序，然后再对该序列进行一次插入排序，此时插入排序的时间复杂度为O(N)，

代码如下：

//希尔排序
void ShellSort(int* arr, int n) {
    int gap = n;
    while (gap>1) {
        //每次对gap折半操作
        gap = gap / 2;
        //单趟排序
        for (int i = 0; i < n - gap; ++i) {
            int end = i;
            int tem = arr[end + gap];
            while (end >= 0) {
                if (tem < arr[end]){
                    arr[end + gap] = arr[end];
                    end -= gap;
                } else {
                    break;
                }
            }
            arr[end + gap] = tem;
        }
    }
}

时间复杂度平均：O(N^1.3) 空间复杂度：O(1)

3.选择排序

思路：

每次从待排序列中选出一个最小值，然后放在序列的起始位置，直到全部待排数据排完即可。
实际上，我们可以一趟选出两个值，一个最大值一个最小值，然后将其放在序列开头和末尾，这样可以使选择排序的效率快一倍。

动图如下：

代码如下：

//选择排序
void swap(int* a, int* b){
    int tem = *a;
    *a = *b;
    *b = tem;
}
void SelectSort(int* arr, int n){
    //保存参与单趟排序的第一个数和最后一个数的下标
    int begin = 0, end = n - 1;
    while (begin < end) {
        //保存最大值的下标
        int maxi = begin;
        //保存最小值的下标
        int mini = begin;
        //找出最大值和最小值的下标
        for (int i = begin; i <= end; ++i){
            if (arr[i] < arr[mini]) {
                    mini = i;
            }
            if (arr[i] > arr[maxi]){
                    maxi = i;
            }
        }
        //最小值放在序列开头
        swap(&arr[mini], &arr[begin]);
        //防止最大的数在begin位置被换走
        if (begin == maxi){
            maxi = mini;
        }
        //最大值放在序列结尾
        swap(&arr[maxi], &arr[end]);
        ++begin;
        --end;
    }
}

时间复杂度：最坏情况：O(N^2)  最好情况：O(N^2) 空间复杂度：O(1)

4.冒泡排序

思路：

左边大于右边交换一趟排下来最大的在右边

动图如下：

代码如下：

//冒泡排序
void BubbleSort(int* arr, int n){
    int end = n;
    while (end) {
        int flag = 0;
        for (int i = 1; i < end; ++i) {
            if (arr[i - 1] > arr[i]) {
                int tem = arr[i];
                arr[i] = arr[i - 1];
                arr[i - 1] = tem;
                flag = 1;
            }
        }
        if (flag == 0){
            break;
        }
        --end;
    }
}

时间复杂度：最坏情况：O(N^2) 最好情况：O(N)

空间复杂度：O(1)