排序算法深度解析 C/C++

1.选择排序

时间复杂：平均O(n²) 最好O(n²) 最坏 O(n²)
空间复杂度：O(1)
稳定性：不稳定
选择排序是最简单的排序算法之一，本小节主要介绍排序算法中最常用的简单选择排序。要说的全都在图片里了。简单选择排序是指，对一个序列A中的元素A[1]~A[n]，令i从1开始遍历到n，每趟从待排序的部分[i,n]中选择最小元素，令他与待排序的第一个元素交换，这样待排序的区间又少了1了，依次递归n次之后排序完成。

实现代码(对int数组)：

#include <stdio.h>
using namespace std;
void selectSort(int A[],int n){		 //n为A里面的元素个数
	for(int i = 0; i < n; i++){	 //进行n趟
		printf("第%d步",i+1);
		for(int q=0;q<n;q++)
			printf("%d",A[q]);
			printf("\n");
		int k = i;
		for(int j = i; j < n; j++){ //找出每趟最小的元素
			if(A[j] < A[k]){
				k=j;
			}
		}
		int temp = A[i];			 //以下三句是交换A[i]与A[k]
		A[i] = A[k];
		A[k] = temp; 
	}
}
int main()
{
	int n = 6;
   	int A[6]={5,2,4,6,3,1};
	printf("befor: ");
	for(int i = 0 ; i < n ;i++)
		printf("%d|",A[i]);
	printf("\n");
	selectSort(A,n);
	printf("after: ");
	for(int i = 0 ; i < n ;i++)
		printf("%d|",A[i]);
}
	//befor: 5|2|4|6|3|1|
	//第1步524631
	//第2步124635
	//第3步124635
	//第4步123645
	//第5步123465
	//第6步123456
	//after: 1|2|3|4|5|6|

2.插入排序

时间复杂：平均O(n²) 最好O(n) 最坏 O(n²)
空间复杂度：O(1)
稳定性：稳定
插入排序也是最简单的一类排序方法，本小节主要介绍众多排序方法中最直观的直接插入排序。如图

直接插入排序是指，对序列A的n个元素A[1]~A[n],令i从2到n遍历，进行n-1趟操作。假设某一趟时，序列A的前i-1个元素A[1] ~A[i-1]已经有序而范围[i,n]还未有序，那么该趟从范围[1,i-1]中寻找某个位置j,使得将A[i]插入j后（此时A[j] ~ A[i-1]会后移一位至A[j+1] ~ A[i]),范围[i,j]有序。
实现代码：

#include <stdio.h>
void insertSort(int A[],int n){		  //n个元素，数组下标为0~n-1
	for(int i = 1; i < n ; i++){	  //进行n-1趟排序
		int temp = A[i],j=i;		  //temp临时存放A[i],j从i开始往前遍历
		while(j>0 && temp < A[j-1]){  //只要temp小于前一个元素
			A[j] = A[j-1];			  //把A[j-1]后移一位至A[j]
			j--;
		}
		A[j] = temp;				  //插入位置为j
		printf("第%d步",i);
		for(int q=0;q<n;q++)
			printf("%d",A[q]);
		printf("\n");
	}
}

int main()
{
	int n = 6;
   	int A[6]={5,2,4,6,3,1};
	printf("befor: ");
	for(int i = 0 ; i < n ;i++)
		printf("%d|",A[i]);
	printf("\n");
	insertSort(A,n);
	printf("after: ");
	for(int i = 0 ; i < n ;i++)
		printf("%d|",A[i]);
	//befor: 5|2|4|6|3|1|
	//第1步254631
	//第2步245631
	//第3步245631
	//第4步234561
	//第5步123456
	//after: 1|2|3|4|5|6|
}

3.归并排序

时间复杂：平均O(nlog₂n) 最好O(nlog₂n) 最坏 O(nlog₂n)
空间复杂度：O(n)
稳定性：稳定
归并排序是基于“归并”的思想的排序算法，这里主要介绍的是最基本的2-路归并排序。
直接看例子：排序：{66,12,33,57,64,27,18}

1.第一趟。两两分组，得到四组：{66,12}、{33,57}、{64,27}、{18}组内单独排序，得到新序列{{12,66}、{33,57}、{27,64}、{18}}。
2.第二趟。将四个组继续两两分组，得到两组:{12,66,33,57}、{27,64,18}，组内单独排序，得到新序列{{12,33,57,66}、{18,27,64}}。
3.第三趟。将两个组继续两两分组，得到一组：{12,33,57,66,18,27,64},组内单独排序，得到新序列{12,18,27,33,57,64,66}。算法结束

用图来表示就是：

实现：

const int maxn =100;
//将数组A的[L1,R1]与[L2,R2]区间合并为有序区间（此处L2即 R1+1）
void merge(int A[],int L1,int R1,int L2,int R2){
	int i = L1,j = L2;
	int temp[maxn],index = 0;//存放合并后的数组，index为其下标
	while(i <= R1 && j<=R2){
		if(A[i]<=A[j])
			temp[index++] = A[i++];//将A[i]加入序列temp
		else
			temp[index++] = A[j++];
	}
	while(i <= R1) temp[index++] = A[i++];//将[L1,R1]的剩余元素加入序列temp中
	while(j <= R2) temp[index++] = A[j++];
	for(i = 0;i < index; i++)
		A[L1 + i] = temp[i];
}
//因为递归代价太大了，此处直接给非递归版本的mergesort
void mergeSort(int A[]){
	//step为组内元素个数，step/2为子区间元素个数，注意等号可以不取
	for(int step = 2; step / 2 <= n; step *=2){
		//每step个元素一组，组内前step/2和后step/2个元素进行合并
		for(int i = 0; i < n; i += step){
			int mid = i + step / 2 -1;
			if(mid + 1 <= n)
				merge(A,i,mid+1,min(i + step - 1,n));
		}
	}

好了，以上是正经代码，正正经经的非递归归并排序。但是如果题目只要求给出归并排序的每一趟序列(时间复杂度允许)，可以直接用algorithm里面的sort来代替merge函数，减少代码编写时间：

void mergeSort(int A[])
{
	for(int step = 2; step / 2 <= n; step *=2){
	//每step个元素一组，组内[i,min(i+step,n+1)]进行排序
		for(int i = 0; i < n; i += step){
			sort(A + i, A + min(i + step,n + 1));
		}
		//此处可以输出归并排序的某一趟结束序列
}

（深度理解merge方法代码）：

#include<cstdio>
void printn(int n[],int m)
{
	for(int i =0 ; i <m;i++)
		printf("%d ",n[i]);
	printf("\n");
}
void merge(int A[],int L1,int R1,int L2,int R2){
	int i = L1,j = L2;
	int temp[100],index = 0;//存放合并后的数组，index为其下标
	while(i <= R1 && j<=R2){
		if(A[i]<=A[j]){
			printf("-%d index:%d i:%d\n",A[i],index,i);
			temp[index++] = A[i++];//将A[i]加入序列temp
		}
		else{
			printf("--%d index:%d j:%d\n",A[j],index,j);
			temp[index++] = A[j++];
		}
		printn(temp,11);
	}
	while(i <= R1) {temp[index++] = A[i++];//将[L1,R1]的剩余元素加入序列temp中
	printf("---%d index:%d i:%d\n",A[i],index,i);
				   printn(temp,11);}
	while(j <= R2) {temp[index++] = A[j++];
	printf("-----%d index:%d j:%d\n",A[j],index,j);
				   printn(temp,11);}
	for(i = 0;i < index; i++)
		A[L1 + i] = temp[i];
}
int main()
{
	int a[11]={1,2,4,3,5,6,7,8,9,10,11};
	merge(a,0,2,3,10);
}

(深度理解sort偷塔)

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100100;
int a[maxn];
void mergesort(int a[],int n)
{
	for(int step = 2;step / 2 <= n;step*=2){
		for(int i = 0 ; i <n;i+=step){
			sort(a+i,a+min(i+step,n));
			printf("i:%d i+step:%d n:%d\n",i,i+step,n);
		}
		for(int i =0;i<n;i++)
			printf("%d ",a[i]);
		printf("\n");
	}
}
int main()
{
	int n,m;
	while(scanf("%d",&n)!=EOF)
	{
		for(int i = 0 ; i<n;i++)
		{
			scanf("%d",&m);
			for(int j = 0 ;j < m; j++)
				scanf("%d\n",&a[j]);
			mergesort(a,m);
		}
	}
}