常用排序算法总结（插入、冒泡、快速，堆、选择、希尔、归并）

对科研中常见的几种排序方法做个总结，方便日后查看与回顾。（对本人认为比较简单易懂的排序方法过程比较简略，对比较复杂的排序方法过程就比较详细）

编程语言：C++（经过本人验证，可以正常运行）。

一、直接插入排序（稳定）：

思想：“一趟一个“地将待排序记录插入到已经排好序的部分记录的适当位置中，使其成为一个新的有序序列，直到所有待排序记录全部插入完毕。

分析：

空间：仅需使用一个辅助单元。故空间复杂度为O(1)；

最好情况：待排序序列已经有序，每趟操作只需比较1次和移动0次，此时，总的比较次数为n-1，总移动次数为0，故最好情况算法复杂度为O(n)；

最坏情况：待排序序列按逆序排序，这时在第j趟操作中，为插入元素需要同前面的j个元素比较，移动元素的次数为j+1.此时有：总的比较次数=1+2+...+(n-1)=n(n-1)/2;总移动次数=2+3+4+...+n=(n+2)(n-1)/2，故最坏情况算法复杂度为O(n^2)；

平均情况：在第j趟操作中，插入记录大约需要同前面j/2个元素比较，移动记录的次数为j/2+1次，此时总的比较次数约为n^2/4；总移动次数为n^2/4；故时间复杂度为O(n^2)；

代码：

void insertSort(int *a,int low,int high)//插入排序 
{
	for(int i=low+1;i<high;i++)
	{
		if(a[i]<a[i-1])
		{
			int tmp=a[i];
			a[i]=a[i-1];
			int j=i-2;
			for(;j>=low&&tmp<a[j];j--)
				a[j+1]=a[j];
			a[j+1]=tmp;
		}
	}
}

二、二分插入排序（稳定）：

思想：与直接插入类似，在找寻插入位置时采用二分查找方式；

分析：与直接插入相同，仅仅减少了元素的比较次数，并没减少元素的移动次数，因此仍为O(n^2)；

代码：

void binaryInsertSort(int *a,int low,int high)//二分插入排序 
{
	for(int i=low+1;i<high;i++)
	{
		int tmp=a[i];
		int hi=i-1;
		int lo=low;
		while(lo<=hi)
		{
			int mid=(lo+hi)/2;
			if(a[mid]>tmp) hi=mid-1;
			else lo=mid+1;
		}
		for(int j=i-1;j>hi;j--)
		{
			a[j+1]=a[j];
		}
		a[hi+1]=tmp;
	}
}

三、希尔排序（不稳定）：

思想：”基本有序化“可以提升插入排序的效率，将记录序列分成若干子序列，每个子序列分别进行插入排序。需要注意的是，这种子序列是由间隔为某个增量的一组数据组成，即跳跃式选择数据组。（这个解释起来比较抽象，面试中也很少问，但编程贼简单）

分析：时间复杂度：开始时增量较大，分组较多，每组的记录数目较少，当排序规模n值较小时，n和n^2的差距也较小，但随着增量d逐渐缩小，分组逐渐减小，而各组的记录数目逐渐增多，但由于已经基本有序，所以新的一趟也较快。时间复杂度与增量的设置有关，约在O(n^1.25)和O(n^1.6)之间；

代码：

void shellInsert(int *a,int low,int high,int deltaK)//希尔排序 
{
	for(int i=low+deltaK;i<high;i++)
	{
		if(a[i]<a[i-deltaK])
		{
			int tmp=a[i];
			int j=i-deltaK;
			for(;j>=low&&tmp<a[j];j=j-deltaK)
				a[j+deltaK]=a[j];
			a[j+deltaK]=tmp;
		}
	}
} 
void shellSort(int *a,int low,int high,int *delta,int m)//希尔排序 
{
	for(int k=0;k<m;k++)
	{
		shellInsert(a,low,high,delta[k]);	
	}	
}

四、冒泡排序（稳定）：

思想：贼简单，对n个数进行n-1次扫描，每次扫描比较相邻两个数字，大的移到后面。这样每趟排序会把最大的数字扔到最后面；

分析：

空间：需要一个辅助单元，故空间复杂度为O(1)；

最好情况：数据全部排好序，这时循环n-1次，时间复杂度为O(n)，但是程序中可以设置flag，某一次未发生位置交换，程序退出；

最坏情况：数据全部逆序存放，这时循环n-1次，比较次数为n-1+n-2+...+1=n(n-1)/2；移动次数为3*（n-1+n-2+...+1）=3n(n-1)/2，时间复杂度为O(n^2)；

平均情况：与直接插入分析一样，时间复杂度为O(n^2)；

代码：

void bubbleSort(int *a,int low,int high)//冒泡排序普通实现 
{
	int n=high-low;
	for(int i=0;i<n-1;i++)
	{
		int flag=0;
		for(int j=0;j<n-i-1;j++)
		{
			if(a[j]>a[j+1])
			{
				flag=1;
				int tmp=a[j];
				a[j]=a[j+1];
				a[j+1]=tmp;
			}
		}
		if(flag==0)
			break;
	}
}

这里有个小插曲，有一次腾讯面试，让用递归实现冒泡，瞬间懵逼。

代码（冒泡排序的递归实现）：

void bubbleSort2(int *a,int low,int high)//冒泡排序递归实现 
{
	if(high==1)
		return;
	for(int i=0;i<high-1;i++)
	{
		if(a[i]>a[i+1])
		{
			int tmp=a[i];
			a[i]=a[i+1];
			a[i+1]=tmp;
		}
	}
	bubbleSort2(a,low,--high);
} 

五、快速排序（不稳定）：

思想：每次选择一个元素放置到它应该在的位置，划分原来序列为前面的数都不大于它，后面的数都不小于它；

分析（消耗的时间空间主要在递归上）：

空间：最好情况，每次取到的元素刚好平分整个数组，此时空间复杂度为O(log n)；最坏情况，每次取到的就是数组的最大或最小的，这种情况就是冒泡排序，此时空间复杂度为O(n)，所以空间复杂度为O(log n)~O(n)；

最好情况：相当于一个完全二叉树结构，即每次标准元素都把当前数组分成两个大小相等的子数组，这是分解次数等于完全二叉树的深度lb n；每次快排过程无论把数组怎样划分，全部的比较次数都接近于n-1次，所以时间复杂度为O(n lb n)；

最坏情况：退化成冒泡排序，时间复杂度为O(n^2)；

平均情况：时间复杂度为O(n lb n)；

代码：

void quickSort(int *a,int low,int high)//快速排序 
{
	int i=low;
	int j=high-1;
	int tmp=a[low];
	while(i<j)
	{
		while(i<j&&tmp<=a[j]) j--;
		if(i<j)
		{
			a[i]=a[j];
			i++;
		}
		while(i<j&&tmp>=a[i]) i++;
		if(i<j)
		{
			a[j]=a[i];
			j--;
		}
	}
	a[i]=tmp;
	if(low<i) quickSort(a,low,i-1);
	if(i<high) quickSort(a,i+1,high);
}

六、直接选择排序（不稳定）：

思想：巨简单。在每趟过程中将待排序数组最小数放到最前面。不多解释了。

分析：

空间：需要一个辅助单元，故O(1)；

最好最坏情况：无论初始状态如何，都需要进行n-1+n-1+...+1=n(n-1)/2次比较，所以时间复杂度为O(n^2);

代码：

void selectSort(int *a,int low,int high)//直接选择排序 
{
	int n=high-low;
	for(int i=0;i<n-1;i++)
	{
		int min=i;
		for(int j=i+1;j<n;j++)
		{
			if(a[min]>a[j])
				min=j;	
		}	
		if(min!=i)
		{
			int tmp=a[min];
			a[min]=a[i];
			a[i]=tmp;
		}
	} 
}

七、堆排序（不稳定）：

思想：把待排序的数据元素构造成一个完全二叉树结构，则每次选择出一个最大的数据元素只需比较完全二叉树的高度次，即lb n次，则排序算法的最好最坏时间复杂度均为O(n lb n)；

空间：O(1)；

这个比较复杂，具体的讲解可以参考博文：http://www.cnblogs.com/skywang12345/p/3602162.html

代码：

void heapAdjust(int *a,int low,int high)//堆排序，调整堆 
{
	int tmp=a[low];
	for(int j=2*low+1;j<high;j=j*2+1)
	{
		if(j<high-1&&a[j]<a[j+1]) j++;
		if(tmp>=a[j]) break;
		a[low]=a[j];
		a[j]=tmp;
		low=j;
	}
	//a[low]=tmp;
}
void heapSort(int *a,int high)//堆排序 
{
	for(int i=(high)/2-1;i>=0;i--)
		heapAdjust(a,i,high);

	for(int i=high-1;i>0;i--)
	{		
		int tmp=a[0];
		a[0]=a[i];
		a[i]=tmp;
		heapAdjust(a,0,i);
	}		
} 

八、归并排序（稳定）：

思想：将若干个已经排好序的子序列合并成一个有序的序列。

分析：

时间：归并的次数约为lb n,任何一次的归并比较次数约为n-1，所以最好最坏时间复杂度均为O(n lb n);
空间：需要一个与原数组大小一样的辅助数组，故空间复杂度为O(n).

代码：

void merge(int *a,int p,int q,int r)//一次归并算法 
{
	int n1=q-p+1;
	int n2=r-q;
	int *L=new int[n1+1];
	int *R=new int[n2+1];
	for(int i=0;i<n1;i++)
	{
		L[i]=a[p+i];
	}
	for(int j=0;j<n2;j++)
	{
		R[j]=a[q+j+1];
	}
	L[n1]=1000000;
	R[n2]=1000000;
	for(int i=0,j=0,k=p;k<=r;k++)
	{
		if(L[i]<=R[j])
		{
			a[k]=L[i];
			i++;
		}
		else
		{
			a[k]=R[j];
			j++;
		}
	}
	delete []L;
	delete []R;
}
void mergepass(int *a,int p,int r)//二路归并 
{
	if(p<r)
	{
		int q=(p+r)/2;
		mergepass(a,p,q);
		mergepass(a,q+1,r);
		merge(a,p,q,r);	
	}	
} 

总结：具体的算法过程以后有时间会补上哒~但面试前看看这些还是挺有效果的呢！

最后补上一张各种排序算法的对比：