内部排序算法小结

排序算法大体上可分为内部排序和外部排序。所谓外部排序，就是指计算机的内存有限，不能将庞大的序列全部加载到内存中进行排序，就需要访问外部存储设备来进行排序。内部排序，当数据量不是非常大时，可以一次性加载到内存中进行排序的统称。

按照排序依据的不同原则，可将内部排序算法分为插入排序、交换排序、选择排序、归并排序和基数排序。下面我主要讲各种排序算法的原理，实现由小到大的排序，具体的实现方式可以参见我的github：https://github.com/clarkzhang56/the-method-of-sort 。

插入排序（insert sort）

                插入排序是比较常见的排序方式，主要有直接插入排序和希尔排序。

               直接插入排序比较简单，实现代码也很短。其原理就是依次遍历整个序列，当该值小于其前一位的值时，就将前一位的值给予该值，并循环比较与更前一位的大小，直到条件不能满足。当序列遍历完时，序列就按照由小到大依次排列了。

               希尔排序相对直接插入排序来讲，就比较麻烦了。设定序列为a[]，长度为n，将步长step定为n/2，遍历序列，比较a[i]与a[i+step]的大小，后者小的话就交换位置，并循环比较a[i-step]与a[i]，这样进行了第一遍的遍历。接下来将step再减半，循环进行上述操作，直到最后step为0，循环结束，此排序方法的核心就是循环比较值与其相隔step步长值进行比较，代码如下：

for(int i=step; i<n; i++){
       int j= i-step;
       int base= a[i];
       while(j>=0 && a[j]>base){
         a[j+step]= a[j];
         j-= step;
       }
       a[j+step] = base;
}

交换排序（exchange sort）

               交换排序主要有大家比较常见的冒泡排序和效率比较高的快速排序了。

              冒泡排序，顾名思义，就是依次遍历，将比较“冒泡”的比较大的值排到后面去，所以遍历一次排序后最大的值就被排到了最后。再遍历依次，剩余最大的就被拍到了此时序列的最后，循环遍历直到最后一个值就OK了。

               快排是运行时间复杂度比较小的排序方法。快排的思想就是将序列分成两部分，第一部分是值全部比序列第一个值a[0]小的，第二部分是值全部不比a[0]小的。之后递归上述两部分，最后的时候，就可将序列拍好序了。有一个比较巧的方法，其核心如下所示：

int base=a[low];
while(low<high){
	while( low<high && base<a[high]) high--;
	a[low] = a[hight];
	while( low<high && base>=a[low]) low++;
	a[high] = a[low];
}
a[low] = base;

选择排序 （select sort）

                选择排序有直接选择排序和堆排序。

直接选择排序，顾名思义，就是选择序列中a[0]后面最小的值，和a[0]交换，然后循环选择序列中a[1]后面最小的值，和a[1]交换，直到最后循环完毕，序列也就排好了。

堆排序稍微复杂点。堆，这里指的是大根堆的完全二叉树。所谓大根堆，是指完全二叉树中所有的子节点都不能大于父节点。堆排序主要分为两个部分：part1，将序列调整成大根堆；part2，将大根堆的根节点和最后一个叶子节点交换，如此一来，序列中最大的值就被拍到了最后，然后循环part1和part2，直到最后剩一个根节点，就将序列排列好了。核心代码如下：

void heap_adjust(int *a, int n){
	int i;
	for(i=0; i<=(n-1)/2; i++){
		int j = i;
		int flag = 0;
		while(j>=0 && 2*j+1<n && flag<2){ //用flag是为了避免j=0时跳入无限循环，但flag存在为1时的可能性
			int k;
			if(2*j+2<n && a[2*j+2]>a[2*j+1]) k = 2*j+2; //选择大的那个子节点和父节点进行比较
			else k = 2*j+1;
			if(a[k]>a[j]){
				int tmp = a[j];
				a[j] = a[k];
				a[k] = tmp;
			}
			j = (j-1)/2;
			if(j==0) flag++;
		}
	}
}
void heap_sort(int *a, int n){
	for(; n>1; n--){
		heap_adjust(a, n);
		int tmp = a[0];
		a[0] = a[n-1];
		a[n-1] = tmp;
	}
}

归并排序（merge sort）

归并排序是指将两个或多个已经排好的序列合并成一个序列。该算法的原理也比较简单，在外部排序的时候必须要用到。依次比较两个序列的最小值，将更小的赋值给新序列直到两个序列的末端。

基数排序（分布式排序）

基数排序，又称桶排序，不同于上述所有的排序方法，基数排序不需要进行序列中数的比较，实现排序主要是通过关键字的比较和移动记录这两种操作。比较数值时是将序列中的值分别放入0~9的十个桶中。放置的原理就是首先比较个分位，将该值放入相应的桶中，然后依次比较上述桶中值的十分位，再放入对应的0~9桶中，直到比较完序列中的最高位为止（这里采用最低位优先的方法，即LSD）。当有的数没有高位时，就置为0，比如数字“9”，其十分位就为0。基数排序其实不太适合比较序列为数值时的情况，其比较适合比较序列为时间、字符串时候的情况，比较字符串时将不足长度的字符串末尾置0。比较数值时，其核心代码如下：

void radix_sort(int *a, int n, int max){//a为数组，n为数组长度，max为数组最高位数
	int num = 0;
	for(; num<max; num++){
		int b[10][MAXSIZE] = {};   //MAXSIZE为自定义的一个数字，大于n就行
		int i,j,k = 0;
		for(i=0; i<n; i++){
			j = ((int)(a[i]/(pow(10,num))))%10;
			for(k=0; k<n; k++){
				if(b[j][k] == NULL) b[j][k] = a[i];
				break;
			}
		}
		int m = 0;
		for(i=0; i<10; i++){<span style="white-space:pre">		</span>//放入桶中后，再把数组重新串起来，方便再放入桶中
			for(j=0; j<n; j++){
				if(b[i][j]!=NULL){
					a[m] = b[i][j];
					m++;
				}
			}
		}
	}
}

各方法比较讨论：

从平均时间性能而言，快速排序最佳，其所需时间 最短。但是快速排序最坏情况下的时间性能不如堆排序和归并排序。直接插入排序适合记录“基本有序”或n较小时，因此其可以和快排、归并排序结合在一起使用。 基数排序适用于n值很大而关键字较小的序列。 排序算法的稳定性，假定待排序的序列中，存在多个具有相同关键字的记录，经过排序后，这些记录相对次序保存不变，则称这中排序算法是稳定的，否则不稳定。上述排序算法中，基数排序是稳定的，时间复杂度为O(n2)的直接插入排序、冒泡、直接选择排序也是稳定的，而时间性能较好的快排、堆排序和希尔排序都是不稳定的。

总的来说，没有哪一个排序算法是绝对的最好或性能最佳，它们的适用场景也不同，有的适合n较小，有的适合n较大，在实际使用时可根据情况选择，必要时可以结合使用。内部排序中，用“比较”进行排序的算法在最坏情况下能达到的最好的时间复杂度为O(nlogn)。