排序算法

前言

​ 排序算法是一种基础且常用的算法。本文将会介绍插入排序、选择排序、冒泡排序、快速排序、归并排序和桶排序。

正文

​ 本文全部排序目的为升序。

插入排序

​ 插入排序的思路类似我们打扑克牌时给手中扑克牌排好序，摸到一张新的扑克牌，我们是将它插入到手中已有序的扑克牌，可证明此操作从1张扑克牌到$n$张扑克牌完成了排序目的，如下图所示。

​

​ 代码实现：显然用数组存已有序的序列，新的一张牌可从序列末尾，将比他大的数移到后面。

void sort1(int a[], int n) //插入排序 n2
{
    for (int i = 2; i <= n; i++) // 类似给手中扑克牌排序 向已排好序列中插入
    {
        int x = a[i];
        for (int j = i - 1; j >= 1; j--) //[1,i-1]为已有序的序列，位置i处为新的一张牌。
        {
            if (a[j] > x)
                swap(a[j], a[j + 1]);
            else
                break;
        }
    }
}

​ 时间复杂度分析：最差情况下，原序列为降序，每次新的一张牌从尾移到头部，为$O(n^2)$。

选择排序

​ 选择排序的思路是将数列分为两部分，一部分为有序序列，另一部分为未排序序列，每次从未排序序列中选择最小值并加入到有序序列的尾端，可证明同样完成了排序目的，且十分稳定，如下图所示。

​

​ 代码实现：i位置放[i,n]中的最小项 [1,i-1]是已排好序列 选择[i,n]中最小值

void sort2(int a[], int n) //选择排序 n2
{
    for (int i = 1; i < n; i++) // i位置放[i,n]中的最小项 [1,i-1]是已排好序列 选择[i,n]中最小值
    {
        int m = i;
        for (int j = i + 1; j <= n; j++)
        {
            if (a[j] < a[m])
                m = j;
        }
        swap(a[i], a[m]);
    }
}

​ 时间复杂度分析：比较稳定，每次找最小值都要遍历一遍，为$O(n^2)$。

冒泡排序

​ 可知原序列存在形如[3,2]的一对(逆序对)是造成其不能升序的重要原因，冒泡排序思路是通过$n-1$次遍历数列，遇到逆序对进行交换，可证明$n-1$次遍历后序列一定有序且每次遍历完较大值将移到后面，如下图所示。

​

​ 代码实现：$n-1$次遍历，不停交换。

void sort3(int a[], int n) //冒泡排序 n2
{
    for (int i = 1; i < n; i++) // 假定最后一个为最小值 可知它经过n-1次到达位置1 如同气泡浮出水面
    {
        for (int j = 1; j < n; j++)
        {
            if (a[j] > a[j + 1])
                swap(a[j], a[j + 1]);
        }
    }
}

​ 时间复杂度分析：最坏情况下，原序列为降序，每次都要交换，为$O(n^2)$。

快速排序

​ 快速排序以及下面的归并排序采用了分治的思想，快速排序思路是，选取一个基准值，将其分为小于它和大于它的两部分，然后对这两部分进行递归操作，可证明完成了排序目的，如下图所示：

​

​ 看图理解难度较大，最好自己尝试根据思路代码用笔模拟一遍实现过程

​ 代码实现：

void sort4(int a[], int l, int r) // //快速排序 nlogn 根据基准值分成小于和大于的两部分 对这两部分递归进行同样操作
{
    if (l >= r)
        return;
    //swap(a[l], a[(l + r) / 2]);//随机基准值
    int j = l + 1;//j代表下一个存储小于基准值的位置
    for (int i = l + 1; i <= r; i++)
    {
        if(a[i] < a[l])//基准值为a[l]
        {
            swap(a[i], a[j]);
            j++;
        }
    }
    swap(a[l], a[j-1]);
    sort4(a, l, j - 2);
    sort4(a, j, r);
    return;
}

​ 时间复杂度分析：该算法不稳定，当降序时，该算法退化成$n^2$，显然关键在于基准值的选取，通过随机基准值可使得算法均摊时间复杂度为$nlogn$，相当优秀，随机基准值方法很多，代码中只是一种。

归并排序

​ 归并排序是作者最喜欢的排序算法，归并排序思路是通过对原问题进行分解成若干子问题，递归地求解子问题，通过合并两个已排序的子序列产生当前区间的已排序的答案，合并操作类似桌面上有两堆已排序好且牌面朝上的牌，每次比较两堆牌顶端大小，可合并成一堆有序的牌，如下图所示：

​ 代码实现由两个函数，一个函数负责合并两堆有序为一堆，另一个负责分解子问题并回升

void set(int a[], int l, int mid, int r) // 两堆扑克 比较顶部大小并合并
{
    int b[MAXN], l1 = l, l2 = mid + 1, tmp = 0;
    while (l1 <= mid && l2 <= r)
        b[++tmp] = a[l1] < a[l2] ? a[l1++] : a[l2++];
    while (l1 <= mid)
        b[++tmp] = a[l1++];
    while (l2 <= r)
        b[++tmp] = a[l2++];
    while (tmp > 0)
        a[r--] = b[tmp--];
}

void sort5(int a[], int l, int r) //归并排序 nlogn 子问题
{
    if (l == r)
        return;
    int mid = (l + r) / 2;
    sort5(a, l, mid);
    sort5(a, mid + 1, r);
    set(a, l, mid, r);
}

​ 时间复杂度分析：该算法十分稳定，每次合并最多为$n$次操作，可得时间复杂度为$nlogn$，缺点在于需要另外一个临时数组。

桶排序

​ 桶排序较简单且应用常见较少，对数值大小要求较高，时间复杂度为$O(n)$,如下图所示：

void sort6(int a[], int n) //桶排序 n
{
    int b[100010], k = 0;
    for (int i = 1; i < 100000; i++) // 原理简单 适合数据规模大于10^6的情景
        b[i] = 0;
    for (int i = 1; i <= n; i++)
        b[a[i]]++;
    for (int i = 1; i < 100000; i++)
    {
        if (b[i])
        {
            for (int j = 1; j <= b[i]; j++)
                a[++k] = i;
        }
    }
}

结论

​ 重在思想，竞赛中用sort。