排序算法大总结
算法一:直接插入排序
1、算法描述
插入排序是一种最简单直观的排序算法,它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
2、算法步骤
1)将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。
2)从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)
3、算法代码
//直接插入排序:将第一个数据看做一个顺序表,将后面的数据一次插入表中
void InsertSort(int a[], int n)
{
for(int i= 1; i<n; i++){
if(a[i] < a[i-1]){ //若第i个元素大于i-1元素,直接插入。小于的话,移动有序表后插入
int j= i-1; //表中最后一个数据
int x = a[i]; //复制为哨兵,即存储待排序元素
a[i] = a[i-1]; //先后移一个元素 (因为a[i]就是X,所以不怕丢失)
while(j>=0 && x < a[j]){ //查找在有序表的插入位置 (遍历表)
a[j+1] = a[j];
j--; //元素后移
}
a[j+1] = x; //插入到正确位置
}
}
}
int main()
{
int n;
cin>>n;
int *a=new int[n];
for(int j=0;j<n;j++)
cin>>a[j];
InsertSort(a,n);
for(int i=0;i<n;i++)
cout<<a[i];
delete []a;
}
算法二:折半插入排序
1、算法描述
将排序的记录放入数组original[1-n]中,original[1]是有序的,再循环n-1次,将后面的n-1个记录一次插入有序数组的正确位置形成一个有序的数组,而折半插入的做法是将待插入的记录和排好的有序数列的中间记录做比较,选择插入有序数列的左子表或右子表,直到找到正确的插入位置。
2、算法步骤
1)计算 0 ~ i-1 的中间点,用 i 索引处的元素与中间值进行比较,如果 i 索引处的元素大,说明要插入的这个元素应该在中间值和刚加入i索引之间,反之,就是在刚开始的位置 到中间值的位置,这样很简单的完成了折半;
2)在相应的半个范围里面找插入的位置时,不断的用(1)步骤缩小范围,不停的折半,范围依次缩小为 1/2 1/4 1/8 .......快速的确定出第 i 个元素要插在什么地方;
3)确定位置之后,将整个序列后移,并将元素插入到相应位置。
3、算法代码
void BinaryInsertionSort(int a[],int left,int right);
//对数组a[left]到a[right]段数据从小到大排序
void BinaryInsertionSort(int a[],int left,int right)
{
int low,middle,high;
int temp;
int i,j;
//待排元素left+1 ---> right 共right - left个,a[left]默认有序
for (i=left+1;i<=right;i++){
temp = a[i];
low = left;
high = i - 1; //i-1为已排好序列的右边界
while(low<=high){
middle = (low + high) / 2;
if (a[i]<a[middle]) //应当将a[i]插入左半区
high = middle - 1;
else //应当将a[i]插入右半区
low = middle + 1;
}
//插入位置为low,low位置及其后的元素后移一位(i-1为已排好序列的右边界)
for (j=i-1;j>=low;j--)
a[j+1] = a[j];
a[low] = temp;
}
}
/*算法分析:
time-complexity: 折半插入排序在查找插入位置时花费的时间很少,但移动次数与直接插入排序次数一样,
最差情况下时间复杂度为O(n2),最好情况下为O(nlog2n);
平均情况下为O(n2);
space-complexity: O(1);
算法不稳定.
*/
算法三:希尔排序
1、算法描述
希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。希尔排序的基本思想是:先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的记录“基本有序”时,再对全体记录进行依次直接插入排序。
2、算法步骤
1)选择一个增量序列t1,t2,…,tk,其中ti>tj,tk=1;
2)按增量序列个数k,对序列进行k 趟排序;
3)每趟排序,根据对应的增量ti,将待排序列分割成若干长度为m 的子序列,分别对各子表进行直接插入排序。仅增量因子为1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。
希尔排序示意图
3、算法实现
//希尔排序:去增量为d1的分为一组,共分成d1组分别进行插入排序,然后每组对应元素放在一起,然后取d2...知道d=1
void ShellSort(int a[],int n)
{
int dk;
int tmp;
for(dk=n/2;dk>0;dk/=2)
for(int i=dk;i<n;i++)
{
tmp=a[i];
for(int j=i;j>=dk;j-=dk)
if(tmp<a[j-dk])
a[j]=a[j-dk];
else break;
a[j]=tmp;
}
}
int main()
{
int n;
cin>>n;
int *a=new int[n];
for(int j=0;j<n;j++)
cin>>a[j];
ShellSort(a,n);
for(int i=0;i<n;i++)
cout<<a[i];
delete []a;
}
算法四:简单选择排序
1、算法描述
选择排序(Selection sort)也是一种简单直观的排序算法。
2、算法步骤:
1)首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置
2)再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
3)重复第二步,直到所有元素均排序完毕。
3、算法实现
//简单选择排序:遍历一次找到最小与第一个元素呼唤位置,再从第二个元素开始遍历找到最小与第二个元素呼唤位置...
void SelectSort(int a[],int n)
{
for(int i=0;i<n-1;i++)
{
int k=i;//记录最小的那个下标的
for(int j=i+1;j<n;j++)
if(a[j]<a[k])
k=j;
if(k!=i)
{
int t=a[i];
a[i]=a[k];
a[k]=t;
}
}
}
int main()
{
int n;
cin>>n;
int *a=new int[n];
for(int j=0;j<n;j++)
cin>>a[j];
SelectSort(a,n);
for(int i=0;i<n;i++)
cout<<a[i];
delete []a;
}
算法五:堆排序
1、算法描述
堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。
2、算法步骤:
1)创建一个堆H[0..n-1]
2)把堆首(最大值)和堆尾互换
3)把堆的尺寸缩小1,并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置
4) 重复步骤2,直到堆的尺寸为1
堆排序示意图
3、算法实现
//堆排序:树形选择排序,将带排序记录看成完整的二叉树,第一步:建立初堆,第二步:调整堆
//第二步:调整堆
void HeapAdjust(int a[],int s,int n)
{
//调整为小根堆,从小到大
int rc=a[s];
for(int j=2*s;j<=n;j*=2)
{
if(j<n && a[j]>a[j+1])//判断左右子数大小
j++;
if(rc<=a[j])
break;
a[s]=a[j];
s=j;
}
a[s]=rc;
}
//第一步:建初堆
void CreatHeap(int a[],int n)
{
//小根堆
for(int i=n/2;i>0;i--)
HeapAdjust(a,i,n);
}
//整合
void HeapSort(int a[],int n)
{
CreatHeap(a,n);//第一步,建立初堆
for(int i=n;i>1;i--)
{
int x=a[1];//堆顶与最后一个元素互换
a[1]=a[i];
a[i]=x;
HeapAdjust(a,1,i-1);
}
}
int main()
{
int n;
cin>>n;
int *a=new int[n+1];
for(int j=1;j<n;j++)//注意:这里是从1开始的
cin>>a[j];
HeapSort(a,n);
for(int i=1;i<n;i++)
cout<<a[i];
delete []a;
}
算法六:冒泡排序
1、算法描述
冒泡排序(Bubble Sort)也是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
2、算法步骤:
1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。
2)对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
3)针对所有的元素重复以上的步骤,除了最后一个。
4)持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
冒泡排序示意图
3、算法实现
//传统冒泡排序
void maopao(int a[],int n)
{
for(int i=0;i<n-1;i++)
for(int j=0;j<n-i-1;j++)
if(a[j]>a[j+1])
{
int t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
int main()
{
int n;
cin>>n;
int *a=new int[n];
for(int j=0;j<n;j++)
cin>>a[j];
maopao(a,n);
for(int i=0;i<n;i++)
cout<<a[i];
delete []a;
}
法六:快速排序
1、算法描述
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下,排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见。事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来。
快速排序使用分治法(Divide and conquer)策略来把一个串行(list)分为两个子串行(sub-lists)。
2、算法步骤:
1.从数列中挑出一个元素,称为 “基准”(pivot),
2.重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
3.递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递归下去,但是这个算法总会退出,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。
快速排序示意图
3、算法实现
//快速排序
//第一个参数要排的数组,第二个参数第一个数,第三个参数数组成员个数
void kuaipai(int array[],int low,int hight)
{
int i,j,t,m;
if(low<hight)
{
i=low;
j=hight;
t=array[low];//第一个数为轴
while(i<j)
{
while(i<j && array[j]>t)//从右边找出小于轴的数
j--;
if(i<j)//将小于轴的数array[j]放到左边array[i]的位置
{
m=array[i];
array[i]=array[j];
array[j]=m;
i++;
}
while(i<j && array[i]<=t)//从左边找出大于轴的数
i++;
if(i<j)//将大于轴的数array[i]放在右边array[j]的位置
{
m=array[j];
array[j]=array[i];
array[i]=m;
j--;
}
}
array[i]=t;//轴放在中间,现在就有两个区域了分别是[0 i-1]和[i+1 hight],分别快排
kuaipai(array,0,i-1);
kuaipai(array,i+1,hight);
}
}
void PX_kuaipai(int buf[],int size)
{
kuaipai(buf,0,size-1);
}
void main()
{
while(1)
{
int m,i;
cin>>m;
int *buf=new int[m];
for(i=0;i<m;i++)
cin>>buf[i];
PX_kuaipai(buf,m);
for(i=0;i<m;i++)
cout<<buf[i];
cout<<'\n';
delete []buf;
}
}
算法五:归并排序
1、算法描述
归并排序(Merge sort)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。
2、算法步骤:
1.申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
2、设定两个指针,最初位置分别为两个已经排序序列的起始位置
3.比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
4.重复步骤3直到某一指针达到序列尾
5.将另一序列剩下的所有元素直接复制到合并序列尾
归并排序示意图
3、算法实现
#include<stdio.h>
#include<stdlib.h>
#define INFINITE 1000
//对两个序列进行合并,数组从mid分开
//对a[start...mid]和a[start+1...end]进行合并
void merge(int *a,int start,int mid,int end)
{
int i,j,k;
//申请辅助数组
int *array1=(int *)malloc(sizeof(int)*(mid-start+2));
int *array2=(int *)malloc(sizeof(int)*(end-mid+1));
//把a从mid分开分别赋值给数组
for(i=0;i<mid-start+1;i++)
*(array1+i)=a[start+i];
*(array1+i)=INFINITE;//作为哨兵
for(i=0;i<end-mid;i++)
*(array2+i)=a[i+mid+1];
*(array2+i)=INFINITE;
//有序的归并到数组a中
i=j=0;
for(k=start;k<=end;k++){
if(*(array1+i) > *(array2+j)){
a[k]=*(array2+j);
j++;
}
else{
a[k]=*(array1+i);
i++;
}
}
free(array1);
free(array2);
}
//归并排序
void mergeSort(int *a,int start,int end)
{
int mid=(start+end)/2;
if(start<end){
//分解
mergeSort(a,start,mid);
mergeSort(a,mid+1,end);
//合并
merge(a,start,mid,end);
}
}
void main()
{
int i;
int a[7]={0,3,5,8,9,1,2};//不考虑a[0]
mergeSort(a,1,6);
for(i=1;i<=6;i++)
printf("%-4d",a[i]);
printf("\n");
}
算法八:基数排序
1、算法描述
基数排序是一种非比较型整数排序算法,其原理是将整数按位数切割成不同的数字,然后按每个位数分别比较。由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数,所以基数排序也不是只能使用于整数。
说基数排序之前,我们简单介绍桶排序:
算法思想:是将阵列分到有限数量的桶子里。每个桶子再个别排序(有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序)。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候,桶排序使用线性时间(Θ(n))。但桶排序并不是 比较排序,他不受到 O(n log n) 下限的影响。
简单来说,就是把数据分组,放在一个个的桶中,然后对每个桶里面的在进行排序。
例如要对大小为[1..1000]范围内的n个整数A[1..n]排序
首先,可以把桶设为大小为10的范围,具体而言,设集合B[1]存储[1..10]的整数,集合B[2]存储 (10..20]的整数,……集合B[i]存储( (i-1)*10, i*10]的整数,i = 1,2,..100。总共有 100个桶。
然后,对A[1..n]从头到尾扫描一遍,把每个A[i]放入对应的桶B[j]中。 再对这100个桶中每个桶里的数字排序,这时可用冒泡,选择,乃至快排,一般来说任 何排序法都可以。
最后,依次输出每个桶里面的数字,且每个桶中的数字从小到大输出,这 样就得到所有数字排好序的一个序列了。
假设有n个数字,有m个桶,如果数字是平均分布的,则每个桶里面平均有n/m个数字。如果
对每个桶中的数字采用快速排序,那么整个算法的复杂度是
O(n + m * n/m*log(n/m)) = O(n + nlogn –nlogm)
从上式看出,当m接近n的时候,桶排序复杂度接近O(n)
当然,以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的 ,实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中,那就退化成一般的排序了。
前面说的几大排序算法 ,大部分时间复杂度都是O(n2),也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O(n)的时间复杂度。但桶排序的缺点是:
1)首先是空间复杂度比较高,需要的额外开销大。排序有两个数组的空间开销,一个存放待排序数组,一个就是所谓的桶,比如待排序值是从0到m-1,那就需要m个桶,这个桶数组就要至少m个空间。
2)其次待排序的元素都要在一定的范围内等等。
总结
各种排序的稳定性,时间复杂度、空间复杂度、稳定性总结如下图:
稳定的排序算法:冒泡排序、插入排序、归并排序和基数排序
不是稳定的排序算法:选择排序、快速排序、希尔排序、堆排序
参考:https://mp.weixin.qq.com/s/NM76J8Mua9xWaUR4o-5f5Q
https://blog.csdn.net/zhangjikuan/article/details/49095533