排序算法总结

总结了常用的排序算法，提供的是C++代码。
目录

冒泡排序

是一种交换排序，通过两两比较相邻的数，将大的数往后移，再与之后的数比较，这样在当前序列中最大的数就移到了队列的最末尾，然后对数组中除了最后一个数的剩余数组进行相同的操作。具体的代码实现如下：

void BolSort(int a[], int N) {
    for (int i = N - 1;i > 0;i--)
    {
        int temp;
        for (int j = 0;j < i;j++)
        {
            if (a[j] > a[j + 1])
            {
                /*temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;*/
                swap(a[j], a[j + 1]);  //添加头文件 #include <algorithm>
            }
        }
    }
}

无额外空间消耗，时间复杂度为$O(N^2)$。

选择排序

每次将数组中$N-i$个值中最小的放在第$i$个位置。

void SelSort(int a[], int N) {
    for (int i = 0;i < N;i++)
    {
        int min = i;
        int temp;
        for (int j = i;j < N - 1;j++) //如果后面有小于a[i]的值，将其下标赋值给min
        {
            if (a[min] > a[j])
                min = j;
        }
        if (min != i)
            swap(a[i], a[min]); //交换a[i]和a[min]
    }
}

无额外空间消耗，时间复杂度为$O(N^2)$。性能略优于冒泡排序。

插入排序

将一个数插入到已经排列好的有序数组中，最初这个数组的长度为0。

void InsertSort(int a[], int N) {
    for (int i = 1;i < N;i++)   //只有一个数时一定是有序的
    {
        int temp = a[i];
        int j;
        for (j = i;j > 0 && a[j - 1] > temp;j--)
        {
            a[j] = a[j - 1];
        }
        a[j] = temp;
    }
}

无额外空间消耗，时间复杂度为$O(N^2)$。虽然同样是$O(N^2)$的复杂度，但插入排序比冒泡排序和选择排序性能要好一些。

希尔排序

希尔排序是改良的插入排序，是时间复杂度突破$O(N^2)$的第一批算法。