引言
十大排序算法分别为：
冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序，基数排序、桶排序
十种排序算法一共可分为两类。分别是比较排序和非比较排序。
- 比较排序：通过比较各个数的大小来交换各个数顺序，达到排序的效果。
- 非比较排序：不用通过比较，就可以达到排序的效果，平均时间复杂度比比较排序低。
十种排序算法的复杂度
稳定性：比如对期末数学成绩进行排序，假如小明和小红都是95分，在排序前小明在小红的前面，如果排序后，小明仍然在小红的前面，那就说明这个排序算法是稳定的，否则这种排序就是不稳定的。
时间复杂度：排序时，对数据操作的总次数。
空间复杂度：排序时，需要花费的内存空间。
下面就会对十种排序算法汇总，但是不会展开说，如果对某个算法不太清楚，可以点击下面的链接，在链接里面有详细的讲解
上面的每篇文章都对各种算法有详细得讲解过程，可以 哪里不会点哪里！！！
一、冒泡排序
冒泡排序是一种简单的排序算法，它的实现过程就是每遍历一遍，把最大的数放到最后面，直到排序完成为止
算法描述：
- 从头到尾遍历要排序的数，每次比较相邻的两个数，如果第一个比第二个大，就交换位置。
- 直到遍历结束，这时候最大的数就会被移动到最后，那这个数 就处理完毕了。
- 除了已经处理好的数，其他的数重复1-2的操作，直到排序完成
动画演示：
代码实现：
#include<iostream> using namespace std; //冒泡排序函数 稳定 void BubbleSort(int arr[],int len) { int temp; for(int i=0;i<len-1;i++) { for(int j=0;j<len-i-1;j++) { if(arr[j]>arr[j+1]) { temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } } //输出数组的值 void printf(int arr[],int len) { for(int i=0;i<len;i++) cout<<arr[i]<<" "; cout<<endl; } int main() { //要排序的数组 int arr[]={5,8,6,2,7,1,9,3,4}; int len=9;//要排序的数组长度 //排序 BubbleSort(arr,len); //输出 printf(arr,len); return 0; }
二、选择排序
选择排序的原理：从未排序的数组中选择出一个最大的放到数组的第一个位置，重复前面的操作，继续从未排序的数中选择最大的，放到第二个位置，直到排序完成。
算法描述：
- 遍历所未排序的数，找出一个一个最小的数，记录它的数组下标。
- 拿最小的数和未排序数组的第一个数交换位置。
- 重复1-2操作，直到排序完成。
动画演示：
代码实现：
#include<iostream> using namespace std; //选择排序函数 不稳定 void SelectionSort(int arr[],int len) { int temp; for(int i=0;i<len-1;i++) { int minx=i; for(int j=i+1;j<len;j++) { if(arr[j]<arr[minx]) //寻找最小的数 minx=j; //记录对应的下标 } temp=arr[i]; arr[i]=arr[minx]; arr[minx]=temp; } } //输出数组的值 void printf(int arr[],int len) { for(int i=0;i<len;i++) cout<<arr[i]<<" "; cout<<endl; } int main() { //要排序的数组 int arr[]={5,8,6,2,7,1,9,3,4}; int len=9;//要排序的数组长度 //排序 SelectionSort(arr,len); //输出 printf(arr,len); return 0; }
三、插入排序
插入排序的原理：首先默认要排序的数组第一个元素为有序序列，然后扫描未排序的每个数，把每个数都插入到有序序列中，插入的方法就是从后向前扫描有序序列，找到一个合适的位置，使插入后的序列仍然是有序序列。
算法描述：
- 默认第一个数为有序序列，开始遍历未排序的每一个数。
- 当遍历到某个数时，首先拿一个变量把这个数存取来，再拿这个数和有序序列从后向前比较，如果有这个数比有序序列小，且没有有序序列还有数未比较，那就把有序序列的数后移（为插入数准备位置）。
- 重复比较操作，直到找到合适的位置，把要插入的数放进去即可。
- 遍历未排序的每个数，直到所有的数都插入到有序序列中之后，数组就排序好了。
动画演示：
代码实现：
#include<iostream> using namespace std; //插入排序函数 稳定 void InsertionSort(int arr[],int len) { int temp; for(int i=1;i<len;i++) { int index=i-1;//前i-1个数已经排序好了 int current=arr[i]; while(index>=0&&arr[index]>current) { arr[index+1]=arr[index]; index--; } arr[index+1]=current; } } //输出数组的值 void printf(int arr[],int len) { for(int i=0;i<len;i++) cout<<arr[i]<<" "; cout<<endl; } int main() { //要排序的数组 int arr[]={5,8,6,2,7,1,9,3,4}; int len=9;//要排序的数组长度 //排序 InsertionSort(arr,len); //输出 printf(arr,len); return 0; }
四、希尔排序
希尔排序就是插入排序的改进版，在希尔排序中引入一个 “增量”，实现了分组插入排序的过程，首先把各自分组用插入排序实现有序，再实现数组的整体有序。
算法描述：
- 定义增量，确定增量的变化过程（最后增量一定要变成1）。
- 对于每个增量，都用一边插入排序，实现各自分组的有序。
- 最后一增量为1时，再用一遍插入排序，就是实现了整理有序。
代码实现：
#include<iostream> using namespace std; //希尔排序函数 不稳定 void ShellSort(int arr[],int len) { //increment是增量 int increment=len; do{ increment=increment/3+1; for(int i=increment;i<len;i++) { int current=arr[i]; int index=i-increment; while(index>=0&&arr[index]>current) { arr[index+increment]=arr[index]; index-=increment; } arr[index+increment]=current; } } while(increment>1); } //输出数组的值 void printf(int arr[],int len) { for(int i=0;i<len;i++) cout<<arr[i]<<" "; cout<<endl; } int main() { //要排序的数组 int arr[]={5,8,6,2,7,1,9,3,4}; int len=9;//要排序的数组长度 //排序 ShellSort(arr,len); //输出 printf(arr,len); return 0; }
五、归并排序
归并排序的过程一共分两大步，第一步：分，把一个大数组分成一个个小数组；第二步：合，从一个个的小数组，合成大数组，在合的过程中，按照大小顺序进行合成，合成的大数组就是有序的，这样就达到了排序的效果。
算法描述：
- 利用分治法，把数组实现分的操作。
- 再写一个实现数组合并的函数，合成之后，数组实现了有序。
动画演示：
代码实现：
#include<iostream> using namespace std; //将两个有序数列arr[first...mid]和arr[mid...last]合并 void MergeArray(int arr[],int first,int mid,int last,int temp[]) { int i=first, j=mid+1; int m=mid , n=last; int k=0; while(i<=m&&j<=n) { if(arr[i]<=arr[j]) temp[k++]=arr[i++]; else temp[k++]=arr[j++]; } while(i<=m) temp[k++]=arr[i++]; while(j<=n) temp[k++]=arr[j++]; for(i=0;i<k;i++) arr[first+i]=temp[i]; } //归并排序函数 稳定 void MergeSort(int arr[],int first,int last,int temp[]) { if(first<last) { int mid=(first+last)/2; MergeSort(arr,first,mid,temp); MergeSort(arr,mid+1,last,temp); MergeArray(arr,first,mid,last,temp); } } //输出数组的值 void printf(int arr[],int len) { for(int i=0;i<len;i++) cout<<arr[i]<<" "; cout<<endl; } int main() { //要排序的数组 int arr[]={5,8,6,2,7,1,9,3,4}; int len=9;//要排序的数组长度 int temp[9]; //排序 MergeSort(arr,0,len-1,temp); //输出 printf(arr,len); return 0; }
六、快速排序
快速排序的原理就是首先定一个 “基准数”，再把基准数移动到合适的位置，这个位置要满足他前面位置的数都比基准数小，它后面位置的数，都比基准数大。
算法描述：
- 首先定一个基准数，在设置两个哨兵，这两个哨兵分别从后面往前走、从前面往后走。
- 如果后面的哨兵找到了比基准数小的数，那就停下。
- 如果前面的哨兵找到了比基准数大的数，那就停下。
- 交换这两个哨兵位置的数。然后这两个哨兵再按照自己先前的方向继续走。
- 通过上面几步，就把基准数移动到了合适的位置，然后在利用分治的思想，以基准数为分界线，把数组分为两部分，这两部分都执行上面的操作。直到数组有序位置。
动画演示：
代码实现：
#include<iostream> using namespace std; //快速排序函数 不稳定 void QuickSort(int arr[],int first,int last) { if(first>last)//控制递归结束 return ; int i=first,j=last; int temp=arr[first];//基准数 while(i!=j)//i和j不碰头 { //顺序很重要，要先从右往左找 while(arr[j]>=temp&&i<j) j--; //上面循环结束的条件有两种， //一是查到了比基准数小的， //二是 i与j碰头了 while(arr[i]<=temp && i<j) i++; //循环结束条件同上 //下面交换两个数在数组中的位置 if(i!=j) //两个循环结束的条件都不是i和j碰头 { int t=arr[i]; arr[i]=arr[j]; arr[j]=t; } } //最终一定会碰头，交换基准数和碰头那个位置的数 arr[first]=arr[i]; arr[i]=temp; QuickSort(arr,first,i-1);//分的前一部分 QuickSort(arr,i+1,last); //分的后一部分 } //输出数组的值 void printf(int arr[],int len) { for(int i=0;i<len;i++) cout<<arr[i]<<" "; cout<<endl; } int main() { //要排序的数组 int arr[]={5,8,6,2,7,1,9,3,4}; int len=9;//要排序的数组长度 //排序 QuickSort(arr,0,len-1); //输出 printf(arr,len); return 0; }
七、堆排序
堆排序的算法实现过程就是利用了大顶堆或者小顶堆，比如要从小到大排序，那就先把未排序的数组转换成大顶堆，然后把最大的数放到调到数组尾部，重复前面的操作即可。
算法描述：
- 首先堆化数组，把要排序的数转换成大顶堆。
- 把大顶堆中堆顶数据移动到数组尾部，然后在堆化数组。
- 重复第二步的操作，知道所有的数据都排序完成。
代码实现：
#include<iostream> using namespace std; //堆排序函数 稳定 void HeapAdjust(int arr[],int first,int last) { int temp=arr[first];//暂存“根”结点 int j;//子结点 for(j=2*first;j<=last;j=j*2) { //下面if语句的作用是找出子结点中比较大的那个 //j是左节点，j+1是右节点， //如果右节点大，那j+1就可以了，如果左节点大那就不用+1 //执行完下面的语句，j下标是较大的那个子结点的下标 if(j<last &&arr[j]<arr[j+1]) j++; //下面if语句的作用是如果“根”结点大于子结点， //结束查找即可 if(temp>arr[j]) break; //理解下面两条语句可以类比插入排序， //还记得插入排序中的元素后移吗？ 这里是“下移” arr[first]=arr[j]; first=j; //如果下移，记录对应的下标，方便下次下移 } //同样类比插入排序，把要插入的元素，放到合适的位置 arr[first]=temp; } void HeapSort(int arr[],int len) { for(int i=len/2;i>0;i--) { HeapAdjust(arr,i,len); } for(int i=len;i>0;i--)//需要交换几次位置的次数 { //下面三行的代码是把堆顶最大的元素和堆尾最后一个元素换位置 //这样一来，最大元素就在数组尾部了， //因此大顶堆 是用来从小 到大排序的 int temp=arr[1]; arr[1]=arr[i]; arr[i]=temp; //对堆剩下的元素继续排序。 HeapAdjust(arr,1,i-1); } } //输出数组的值 void printf(int arr[],int len) { for(int i=1;i<len;i++) cout<<arr[i]<<" "; cout<<endl; } int main() { //要排序的数组 ,为了方便理解，数组下标从1开始 int arr[]={0,5,8,6,2,7,1,9,3,4}; int len=10;//要排序的数组长度 //排序 HeapSort(arr,len-1); //输出 printf(arr,len); return 0; }
八、计数排序
计数排序的思想就是统计每个数的出现的次数，然后再根据统计的次数，输出每个数。
算法思想：
- 首先找出要排序数组的最大值和最小值。
- 根据最大值和最小值确定统计数组的长度。
- 遍历一遍，统计出来每个数出现的次数。
- 按照统计数组，输出每个数。
动画演示：
代码实现：
#include<iostream> using namespace std; //计数排序函数 稳定 void CountingSort(int arr[],int len) { int minx=99999,maxn=-99999; //下面for循环是求出来要排序数组的最大值和最小值 for(int i=0;i<len;i++) { if(arr[i]>maxn) maxn=arr[i]; if(arr[i]<=minx) minx=arr[i]; } //cout<<maxn<<" "<<minx<<endl; int l=maxn-minx+1;//变量 l 是要开辟数组的长度 int count[l]={0}; //下面的代码是统计作用，不过统计时要减去数组最小值，方便存储 for(int i=0;i<len;i++) count[arr[i]-minx]++; //累加 for(int i=0;i<l;i++) { count[i]+=count[i-1]; } int temp[len]={0};//用来排序好的数组 for(int i=len-1;i>=0;i--)//逆序遍历。 { int ans=arr[i]-minx; temp[--count[ans]]=arr[i];//先减减的原因是数组下标从0开始的 } //经过上面的逆序遍历，现在temp数组就是排序好的成绩数组 //把排序好的数组放到arr数组中 ，方便后面的打印 for(int i=0;i<len;i++) arr[i]=temp[i]; } //输出数组的值 void printf(int arr[],int len) { for(int i=0;i<len;i++) cout<<arr[i]<<" "; cout<<endl; } int main() { //要排序的数组 int arr[]={1,5,4,2,2,3,1,1,3,1,5}; int len=11;//要排序的数组长度 //排序 CountingSort(arr,len); //输出 printf(arr,len); return 0; }
九、基数排序
基数排序的原理就是按位进行排序，比如从低位到高位，首先先个位，再十位百位，直到达到最高位。每一次的排序都是按计数排序来实现的
算法描述：
- 首先求出要排序数的最大值一共有几位，根据这个决定排序的次数。
- 每位排序是都是用计数排序实现的
动画描述：
代码实现：
#include<iostream> using namespace std; //统计数组中 最大数的位数 int max(int arr[],int len) { int maxn=0; for(int i=0;i<len;i++) { int count=0,data=arr[i]; while(data) { count++; data/=10; } if(count>maxn) maxn=count; } return maxn; } //基数排序函数 稳定 void RadixSort(int arr[],int len) { int maxn=max(arr,len);//首先求出最大位数 int num=1;//求位数用 for(int k=0;k<maxn;k++)//根据位数，判断遍历几次 { int count[10]={0}; for(int i=0;i<len;i++)//把数据放入桶内 { int ans=arr[i]/num%10; count[ans]++; } //下面的过程都是计数排序的过程。 //根据计数排序，把桶内数据排序即可 for(int i=1;i<10;i++)//累加 { count[i]=count[i]+count[i-1]; } int temp[len]={0};//用来存放排序后的结果 for(int i=len-1;i>=0;i--)//逆序遍历，保证稳定性 { int ans=arr[i]/num%10; temp[count[ans]-1]=arr[i]; count[ans]--; } for(int i=0;i<len;i++) arr[i]=temp[i]; num*=10;//求更高位 } } //输出数组的值 void printf(int arr[],int len) { for(int i=0;i<len;i++) cout<<arr[i]<<" "; cout<<endl; } int main() { //要排序的数组 int arr[]={321,563,454,219,541,632,225,678,59,356}; int len=10;//要排序的数组长度 //排序 RadixSort(arr,len); //输出 printf(arr,len); return 0; }
十、桶排序
桶排序的思想就是首先定义几个桶，再把数据放到桶内，然后再把每个桶都排序，最后按照顺序输出。桶排序不太常用
算法描述：
- 设计好有几个桶，每个桶的范围都为多少
- 对每个桶进行排序
- 按照顺序，把每个桶的数据都取出来
桶排序不常用的原因：
- 每个桶如果用数组存数据，那如果数组不够用怎么办？，因为一组数可能有的很集中，有的很分散，如果数组开大了，那分散的数，就会造成空间浪费。
- 如果每个桶用链表存，那就不用提前开辟空间了，但是又存在了时间问题，因为如果对链表进行排序，只能进行一遍一遍的遍历（访问链表的数据不能随机访问），那时间复杂度就特别大了。
- 如果一个要排序的数据特别集中，比如有1000个数据，结果超过了800个数据在一个桶内，那桶排序的优势更体现不出来了。
本文的参考和引用：https://www.cnblogs.com/onepixel/articles/7674659.html
这篇文章到这就结束了，当然算法排序永远不会结束，各种算法还有各种优化的版本，这里就不写了。
创作不易（尤其是动画的制作），如果本文对你起到了一些帮助，何不点个赞再走呢！！！