三种简单的排序方法

写在前面

       排序算法是IT行业一定会接触到的算法，在接触数据结构与算法课程时，排序算法也是我们的重中之重。排序的具体方法很多，也有不同的分法，一般可分为：插入排序法、交换排序法、选择排序法、归并排序法和基数排序法；也可以分为简单排序方法和改进排序方法等。具体分类可见下图。

       其中直接插入排序、选择排序、冒泡排序是最基础的也是最容易掌握的。我自己尝试实现这三种算法，并做深入理解。

直接插入排序

基本思想:

       将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

       要点：设立哨兵，作为临时存储和判断数组边界之用。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAXSIZE 100

int main()
{
    int data[MAXSIZE];
    time_t t;
    srand((unsigned)time(&t));
    // 随机生成20个数
    for(int i=1;i<=20;i++)
    {
        data[i] = rand() % 100;
    }
    for(int i=1;i<=20;i++)
    {
        printf("%d ", data[i]);
    }
    printf("\n");
    // 使用直接插入排序对这20个数进行排序
    int j = 0;
    for(int i=2;i<=20;i++)
    {
        // 我写的需要比较的次数比较多，而且看不出设置哨兵的好处
        // data[0] = data[i];
        // for(j=i-1;j>=1;j--)
        // {
        //     if(data[j] > data[0]) // 每个元素要和哨兵比较大小
        //     {
        //         data[j+1] = data[j];
        //     }
        //     else
        //         break;
        // }
        // data[j+1] = data[0];
        if(data[i-1] > data[i]) // 说明需要进行元素移动
        {
            data[0] = data[i];
            for(j=i-1;data[j]>data[0];j--)
            {
                data[j+1] = data[j]; // 元素后移给哨兵腾位置
            }
            data[j+1] = data[0];
        }
    }
    for(int i=1;i<=20;i++)
    {
        printf("%d ", data[i]);
    }
    printf("\n");
    return 0;
}

       如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。
       直接插入排序算法是由嵌套的两个循环组成。外层循环为n-1次，内层循环for的循环次数稍稍复杂些。算法的最佳情况出现在原序列中的记录已经按照关键码排好序是，每个记录刚进入内层循环就退出，没有记录需要移动，算法的时间复杂度只和外循环有关，为$O(n)$。算法的最差情况出现在每个记录进入for寻循环都必须比较到子序的最前端，子序中的每个记录都必须移动，待插记录方可插入，算法的时间复杂度为$O(n^2)$。算法的空间复杂度为$O(1)$。因此附加空间只需要一个监测点（即单元data[0]）。

冒泡排序

基本思想：

       在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAXSIZE 100

int main()
{
    int data[MAXSIZE];
    time_t t;
    srand((unsigned)time(&t));
    // 随机生成20个数
    for(int i=0;i<20;i++)
    {
        data[i] = rand() % 100;
    }
    for(int i=0;i<20;i++)
    {
        printf("%d ", data[i]);
    }
    printf("\n");
    for(int i=1;i<20;i++)
    {
        int flag = 1, t;
        for(int j=0;j<20-i;j++)
        {
            if(data[j] > data[j+1])
            {
                t = data[j];
                data[j] = data[j+1];
                data[j+1] = t;
                flag = 0;
            }
        }
        if(flag)
        {
            break;
        }
    }
    for(int i=0;i<20;i++)
    {
        printf("%d ", data[i]);
    }
    printf("\n");
    return 0;
}

       空间复杂度：仅用一个辅助单元，为$O(1)$。
       空间复杂度：总共要进行n-1趟冒泡排序，对 j 个记录的表进行一趟冒泡需要j-1次关键码比较。
       总比较次数为=${\sum }_{j=2}^m(j-1)=\frac{1}{2}n(n-1)$
       移动次数：1. 在最好的情况下，待排序已有序，不需要移动；在最坏的情况下，每次比较后均要进行三次移动，
       移动次数=${\sum }_{j=2}^{n}3(j-1)=\frac{3}{2}n(n-1)$
       所以算法的时间复杂度为$O(n^2)$

选择排序

基本思想：

       在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAXSIZE 100

int main()
{
    int data[MAXSIZE];
    time_t t;
    srand((unsigned)time(&t));
    // 随机生成20个数
    for(int i=0;i<20;i++)
    {
        data[i] = rand() % 100;
    }
    for(int i=0;i<20;i++)
    {
        printf("%d ", data[i]);
    }
    printf("\n");
    int k = 0, temp = 0;
    for(int i = 0;i < 19;i++)
    {
        k = i;
        for(int j=i+1;j<20;j++)
        {
            if(data[j] < data[k])
            {
                k = j;
            }
        }
        if(k != i)
        {
            temp = data[k];
            data[k] = data[i];
            data[i] = temp;
        }
    }
    for(int i=0;i<20;i++)
    {
        printf("%d ", data[i]);
    }
    printf("\n");
    return 0;
}

       从程序中可以看出，简单选择排序移动次数较少，但关键码的比较次数依然是n(n-1)/2，所以时间复杂度仍为$O(n^2)$

文中都是我个人的理解，如有错误的地方欢迎下方评论告诉我，我及时更正，大家共同进步