小白学六大排序算法（C语言版）

今天在csdn刷blink的时候，刷到一个冒泡排序的吐槽，看了看评论区，发现不少人分不清选择排序和冒泡排序，笔者想了一下，发现这两个排序确实相似度蛮高的，所以总结了c语言里涉及到六个排序算法，笔者才疏学浅，没有写到什么时间复杂度，空间复杂度之类的比较，只是在代码的角度进行区分，希望各位师傅不吝赐教。

冒泡排序

一次比较两个元素，不管是从大到小，还是从小到大，亦或是首字母从A到Z，按照规定的顺序进行比较，不符合便执行操作。对于冒泡排序，我们最起码应该有个数组，用来储存我们的数据，然后根据要求进行排序。
比如我们从小到大的排几个数，首先先输入这几个数：

int shuzu[] = { 20, 34, 1, 31, 30 };//我们输入了5个数

然后我们想，从小到大排序，我们就把第一个数跟第二个数比较，然后具体操作看下图：

我们上面写了，起码有个数组，那么这时有了数组，就要考虑数组的范围，也就是临界在哪里，所以我们去求数组的边界：

 int len = (int) sizeof(shuzu) / sizeof(*shuzu);/*这里我们定义边界的值为len，也就是求出元素的个数，然后sizeof（）是预定义的函数，编译器知道是统计字节的个数，然后（*shuzu）就是这个数组的元素的所占的地址。*//*数组元素总的字节数除以int型字节数就等于元素个数，然后前面的（int）是对我们的结果进行强制整型转换，这样我们就求出了数组里元素的个数。*/

然后我们把排序算法整入到一个函数里：

Bubble_sort(shuzu, len);//定义冒泡排序的函数，我们需要传入数组和我们上面求出的数组边界。

冒泡排序的函数：

void Bubble_sort(int shuzu[], int len)
{int i, j, temp;for (i = 0; i < len - 1; i++)for (j = 0; j < len - 1 - i; j++)if (shuzu[j] > shuzu[j + 1])//如果前面的数大于后面的数，就交换两者的位置。{temp = shuzu[j];shuzu[j] = shuzu[j + 1];shuzu[j + 1] = temp;}
}

上面的代码里，可能大家对这两行代码有疑惑：

for (i = 0; i < len - 1; i++)for (j = 0; j < len - 1 - i; j++)

首先我们想一个排序中，我们从第一个元素开始，一个个比较，然后比较完一轮又比较一轮，那么一共比较多少轮呢？也就是len -1轮，就好比本题有5个元素，我们每比较完一次，一定可以找出本轮排序里最大的那个数，那么我们4轮比较后，也就是等于找出来4个排好的数，剩下的第5个数是最小的元素，所以是len -1。
然后，我们发现在每一轮的比较时，比如第一轮比较，我们的5个数毫无顺序，那么我们两两比较，经过4轮，我们就找到了本轮比较最大的那个数，下一轮，由于知道了上一轮最大的数，我们只需要对4个数两两比较，也就是比较3次，所以可得len -1 -i。
最后整合到一起：

#include <stdio.h>
void Bubble_sort(int shuzu[], int len)
{int i, j, temp;for (i = 0; i < len - 1; i++)for (j = 0; j < len - 1 - i; j++)if (shuzu[j] > shuzu[j + 1]) {temp = shuzu[j];shuzu[j] = shuzu[j + 1];shuzu[j + 1] = temp;}
}
int main()
{int shuzu[] = { 20, 34, 1, 31, 30  };int len = (int) sizeof(shuzu) / sizeof(*shuzu);Bubble_sort(shuzu, len);int i;for (i = 0; i < len; i++)printf("%d ", shuzu[i]);return 0;
}

选择排序

相比较于冒泡排序，选择排序就是我们在一堆杂乱的数据里，如果你是从小到大排序，我们先找出一个最小的数，放到最前面，然后继续找，再找出第二个小的数放在仅此于最小的数的后面，以此类推。我们上面的冒泡排序也是由小到大，但是你每次找到的是最大的数，然后从后往前走，而我们的选择排序是先找出最小的数，由前往后走。
我们的主函数和冒泡排序其实是一样的，差别不大：

    int shuzu[] = { 5, 20, 1, 3, 14 };//往数组里面存入数据int len = (int) sizeof(shuzu) / sizeof(*shuzu);//同冒泡排序

然后整个函数：

selection_sort(shuzu, len);

然后来看看这个函数怎么写：

代码也就是这样的：

void selection_sort(int shuzu[], int len)
{int i,j,temp;for (i = 0 ; i < len - 1 ; i++) //总的循环次数为 len -1 {int min = i; // 我们把本次循环的第一个元素设置为最小值 for (j = i + 1; j < len; j++) // 依次去访问没有排序的元素,直到最后一个数字 {if (shuzu[j] < shuzu[min])  // 找到本次循环的目前的最小值{min = j;    // 记录最小值}}if(min != i) //只有当最小值的位置发生变化后，我们再进行比较操作 {temp=shuzu[min];  // 交换两个变量shuzu[min]=shuzu[i];shuzu[i]=temp;}}
}

代码合并到一起：

#include<stdio.h>
void selection_sort(int shuzu[], int len)
{int i,j,temp;for (i = 0 ; i < len - 1 ; i++) //总的循环次数为 len -1 {int min = i; // 我们把本次循环的第一个元素设置为最小值 for (j = i + 1; j < len; j++) // 依次去访问没有排序的元素,直到最后一个数字 {if (shuzu[j] < shuzu[min])  // 找到本次循环的目前的最小值{min = j;    // 记录最小值}}if(min != i) //只有当最小值的位置发生变化后，我们再进行比较操作 {temp=shuzu[min];  // 交换两个变量shuzu[min]=shuzu[i];shuzu[i]=temp;}}
}
int main()
{int shuzu[] = { 5, 20, 1, 3, 14 };int len = (int) sizeof(shuzu) / sizeof(*shuzu);selection_sort(shuzu, len);int i;for (i = 0; i < len; i++)printf("%d ", shuzu[i]);return 0;
}

运行结果：

插入排序

采用插入的方式，对我们要排序的无序数列进行排序，将数据一个一个的插入到有序区的正确位置，直到整个数组都有序。
我们看一下图解（百度上找了张图，我自己的作图感太离谱了~），比如我们从小到大进行排序：

其实所谓的插入排序其实就好比分开一波一波的进行排序，我们看初始状态的时候，是4，2，6，5，3，1。然后啊，我们把4分为第一波，然后从后面进行比较，下一个数是2，2比4小，所以2移到4前面，我们这时把2和4看作是新的一组数据。
然后第二次，6比4大，我们就不动了，这时候把2，4，6看作一组新的数据。
第三次，5是不是比6小？所以我们把5移到6前面，然后5比4大，我们就不再移动数字5了，这时2，4，5，6是新的一波数据。
第四次，3是不是6小？然后我们往前面移动，3也比5小，继续移动，直到3比2大，我们就结束了本次比较。
第五次，数字1，依次一次次和前面的数比较，直到得出结果。
最后，本次插入排序也就到此结束了。

然后我们想一想代码怎么写？
主函数，和上面的冒泡排序还有选择排序一模一样：

    int shuzu[] = { 4, 2, 6, 5, 3 ,1 };int len = (int) sizeof(shuzu) / sizeof(*shuzu);

我们同理再定义一个我们的插入排序的函数：

 insertion_sort(shuzu, len);

所以主函数就很容易写出来了：

int main()
{int shuzu[] = { 4, 2, 6, 5, 3 ,1 };int len = (int) sizeof(shuzu) / sizeof(*shuzu);insertion_sort(shuzu, len);int i;for (i = 0; i < len; i++)printf("%d ", shuzu[i]);return 0;
}

然后是我们定义的插入函数：

void insertion_sort(int shuzu[], int len)
{int i,j,temp;for (i=1;i<len;i++){temp = shuzu[i];//我们的数组第一个元素是shuzu[0],这里我们是把shuzu[1]作为比较的变量 for (j=i;j>0 && shuzu[j-1]>temp;j--)//我们是不是从后面往前移动？所以是j--，我们用这个temp之前的数和temp比较，如果比temp大，执行下面操作 shuzu[j] = shuzu[j-1];//我们让 shuzu[j] = shuzu[j-1]; 也就是前面的数如果大于后面的数，就交换两者的位置 shuzu[j] = temp;//我们上面有一个：temp = shuzu[i]; 所以也就是提前进行了备份数据，这样我们就可以将shuzu[j]的值赋回去（注意两个for循环的条件，就可以明白这里），进行下一次比较。 }
}

合并：

#include<stdio.h>
void insertion_sort(int shuzu[], int len)
{int i,j,temp;for (i=1;i<len;i++){temp = shuzu[i];for (j=i;j>0 && shuzu[j-1]>temp;j--)shuzu[j] = shuzu[j-1];shuzu[j] = temp;}
}
int main()
{int shuzu[] = { 4, 2, 6, 5, 3 ,1 };int len = (int) sizeof(shuzu) / sizeof(*shuzu);insertion_sort(shuzu, len);int i;for (i = 0; i < len; i++)printf("%d ", shuzu[i]);return 0;
}

运行结果：

希尔排序

学之前先看一个视频：https://www.bilibili.com/video/BV1xW411Y7gf，注意看，看完后你可能悟了，也可能已经懵了，其实当你学完后会发现这个视频是很形象的，下面我们来看一下希尔排序，希尔排序我们先记住一点：希尔排序的最后是插入排序，就是说最后要走一遍插入排序。
那么什么是希尔排序？
我们看下图便可知（作图不易，请多鼓励），其实就是对插入排序进行了升级改造，我不再傻乎乎的去一个一个的比较，我先一组组的分好，在组内比较完，再重新分组，再次排序，就这样一次次的进行下去，大大简化了我们的计算机运行时的步骤。

那么我们再把上面的图化作代码：
主函数还是和冒泡啊，选择排序它们是一样的：

int main()
{int shuzu[] = { 2, 5, 6, 7, 1 , 9 , 3, 8 , 4 };int len = (int) sizeof(shuzu) / sizeof(*shuzu);shell_sort(shuzu, len);int i;for (i = 0; i < len; i++)printf("%d ", shuzu[i]);return 0;
}

然后我们看定义的函数怎么写，我们这么想，每次循环使用的都是插入排序的方法，那么就简单了，我们的插入排序是不是间隔为1的时候？那我们先写一个插入排序

void shell_sort(int shuzu[],int len)
{int i,j,temp;for( i=1; i<len; i++){if(shuzu[i]<shuzu[i-1]){temp=shuzu[i];for(j=i-1; shuzu[j]>temp; j--){shuzu[j+1]=shuzu[j];}shuzu[j+1]=temp;}}
}

然后我们想，我们的希尔排序是每次的间隔都是不一样的，那么我们怎么修改这个已知的程序呢？

void shell_sort(int shuzu[],int len)
{int i,j,temp,gap;//temp作为临时插入时保存的变量，gap是间隔 //初始增量为 len/2,每一次除以 2for(gap = len / 2 ; gap > 0; gap /=2){for(i = gap; i < len; i++)//我们使用插入排序 {temp=shuzu[i];for(j = i; j>=gap && temp < shuzu[j-gap]; j-=gap)//temp比下一个元素小，我们才往前面插入 shuzu[j] = shuzu[j-gap];//把前面的元素往后面移动 shuzu[j] = temp;//我们的每次循环是处理了多组排序，就是笔者的演示图里，颜色相同的分组进行了各自排序 //我们不是一次性把一组都排序完 ，我们是对每一组都进行了插入排序 }}
}

所以可以得到：

#include<stdio.h>
void shell_sort(int shuzu[],int len)
{int i,j,temp,gap;for(gap = len / 2 ; gap > 0; gap /=2){for(i = gap; i < len; i++){temp=shuzu[i];for(j = i; j>=gap && temp < shuzu[j-gap]; j-=gap)shuzu[j] = shuzu[j-gap];shuzu[j] = temp;}}
}
int main()
{int shuzu[] = { 2, 5, 6, 7, 1 , 9 , 3, 8 , 4 };int len = (int) sizeof(shuzu) / sizeof(*shuzu);shell_sort(shuzu, len);int i;for (i = 0; i < len; i++)printf("%d ", shuzu[i]);return 0;
}

快速排序

我们的快速排序，就是通过一趟排序将要排序的数据分割成独立的两部分，
其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，那么我们怎么保证能分成这样的两部分呢？
我们可以定义一个分界值，大于这个值的数放到一起，小于这个值的数放到一起，然后我们可以在小于这个值的那堆数里面再找一个分界值，以此类推，我们左右两边都能通过类似于递归的传递进行排序，就这样达到排序的目的。

我知道你没看懂上面写的啥，所以我们引入图片的概念进行理解：

我们需要注意的是，b应该先走，a后走
我们转换为代码，首先跟上面几种排序一样，我们的主函数没有很大的区别，这里笔者的做法是把数组没有放到主函数里

int main()
{quick_sort(1,10);int i;for( i=1; i<=10; i++){printf("%d ",shuzu[i]);}return 0;
}

然后我们调用的函数：

void quick_sort(int l, int r)//l代表左边，r代表右边
{if(l>r) //当我们的左边大于右边时，结束递归调用 return;int i=l,j=r,temp=shuzu[l]; //temp存入第一个数int t; //中间变量 while(i!=j)//i=j的时候两者就相遇了 {while(shuzu[j]>=temp&&i<j)j--; //后面的数大于临界值 while(shuzu[i]<=temp&&i<j) i++; //前面的数小于临界值 if(i<j)//找到这两个位置后，让这两个位置交换 {t=shuzu[i];shuzu[i]=shuzu[j];shuzu[j]=t;}}//相遇后，指向同一个元素，让这个基准值进行交换，我们的分界值存到temp里面了shuzu[l]=shuzu[i];shuzu[i]=temp;//一开始的分界值给a[i]//左右两个部分分别进行排序 quick_sort(l,i-1);//递归调用 quick_sort(i+1,r);//递归调用
}

合并一下：

#include<stdio.h>
#define max 11
int shuzu[max]= {0,6,1,2,7,9,3,4,5,8};
void quick_sort(int l, int r)
{if(l>r) return;int i=l,j=r,temp=shuzu[l]; int t; while(i!=j){while(shuzu[j]>=temp&&i<j)j--; while(shuzu[i]<=temp&&i<j) i++; if(i<j){t=shuzu[i];shuzu[i]=shuzu[j];shuzu[j]=t;}}shuzu[l]=shuzu[i];shuzu[i]=temp;quick_sort(l,i-1);quick_sort(i+1,r);
}int main()
{quick_sort(1,10);int i;for( i=1; i<=10; i++){printf("%d ",shuzu[i]);}return 0;
}

运行结果

归并排序

先分开，再合并，用空间，换时间。
在菜鸟教程上找到了一张图，感觉解释的十分明白：

分开的时候好分，我们看一下合并的时候是怎么合的：

道理很简单，我们看一下代码怎么整：
先想主函数，这里主函数差别也不是很大，唯有在给我们定义的归并排序函数传参时有点差异，我们一会再说定义的部分：

int main()
{int shuzu[] = { 2, 5, 6, 7, 1 , 9 , 3, 8 , 4, 0};int len = (int) sizeof(shuzu) / sizeof(*shuzu);merge_sort(shuzu, 0, len);int i;for (i = 0; i < len; i++) {printf("%d ", shuzu[i]);}return 0;
}

然后是定义的函数部分，先看拆的部分，比较简单：

void merge_sort(int shuzu[], int begin, int over)
//我们的begin是待排序数组开始的下标
//over是待排序数组结束时的下标
{if(begin<over){int middle;middle=(begin + over)/2;// 万物归一，我先在中间劈开 //下面就是递归调用，继续劈下去，直到不满足if里的条件 merge_sort(shuzu, begin, middle);merge_sort(shuzu, middle +1, over);//然后上面的是分，下面的函数是合 merge(shuzu, begin, middle, over);}else{return;}
}

合的部分，笔者最开始是左右分别设置了一个数组去承接，然后整两个指针，双数组循环序列，后来写了半天没有写出来（emmm…我是小菜鸟），所以上网找了好多版本，个人感觉写的最好的是这位大佬的：https://blog.csdn.net/assiduous_me/article/details/89414914
这里笔者为这段代码做注释：

void merge(int shuzu[], int begin, int middle, int over)
{int temp[max];//临时存放数据 int a =0;int i=begin;int j=middle + 1;//左右分开 while(i<=middle && j<=over) //当i和j都在要合并的部分中成立的时候{if(shuzu[i]<shuzu[j])//那个小，那个就放到下面去 {temp[a++]=shuzu[i++];}else{temp[a++]=shuzu[j++];}}if(i==middle +1)//左边那个移动到头了 {while(j<=over)//没超出范围的话 ，把数据放下来 {temp[a++]=shuzu[j++];}}if(j==over +1)//右边那个移动到头的话 {while(i<=middle){temp[a++]=shuzu[i++];//同理可知 }}for(j=0,i=begin; j<a; i++,j++)//把排序好的数组存回去  {shuzu[i]=temp[j];}
}

合并到一起：

#include<stdio.h>
#define max 20
void merge_sort(int shuzu[], int begin, int over)
{if(begin<over){int middle;middle=(begin + over)/2; merge_sort(shuzu, begin, middle);merge_sort(shuzu, middle +1, over);merge(shuzu, begin, middle, over);}else{return;}
}
void merge(int shuzu[], int begin, int middle, int over)
{int temp[max];int a =0;int i=begin;int j=middle + 1;while(i<=middle && j<=over) {if(shuzu[i]<shuzu[j]){temp[a++]=shuzu[i++];}else{temp[a++]=shuzu[j++];}}if(i==middle +1){while(j<=over){temp[a++]=shuzu[j++];}}if(j==over +1){while(i<=middle){temp[a++]=shuzu[i++];}}for(j=0,i=begin; j<a; i++,j++){shuzu[i]=temp[j];}
} int main()
{int shuzu[] = { 2, 5, 6, 7, 1 , 9 , 3, 8 , 4, 0};int len = (int) sizeof(shuzu) / sizeof(*shuzu);merge_sort(shuzu, 0, len);int i;for (i = 0; i < len; i++) {printf("%d ", shuzu[i]);}return 0;
}

运行结果：

常见的排序算法有十个，剩下的堆排序，计数排序，桶排序，基数排序，笔者之后再补充哈~~~ 笔者也没得过什么蓝桥杯，ACM的奖，所以对于打比赛的大佬而言，这些算法可能太简单了，博主尽力写的详细一些，希望能让没学过这些东西的小白有所收获，当然笔者也是小白一个… …

如果代码有误或者文中哪里出现了不严谨的地方，请大家在评论区留言，方便笔者及时改正。

“ 谁知道那些ACM的大佬都是怎么学的啊，我还是当个凡人吧。。。”