排序总结

排序大法总结

这里的排序都是一些函数调用,默认为int类型,从小到大,第一个参数为头指针,第二个为数组长度.

直接选择排序

时间复杂度为 \(\Theta(n^{2})\)
是不稳定排序.

思路:

每次选出待排区间的最值,放在第一个.

void selection_sort(int num[],int len){
	int minpos;
	for(register int i=0;i<len;i++){
		minpos=i;
		for(register int j=i;j<len;j++){
			if(num[minpos]>num[j]) minpos=j;
		}
		swap(num[minpos],num[i]);
	}
	return ;
}

冒泡排序

时间复杂度在最坏以及平均情况下下为\(\Theta(n^{2})\)，最好情况下为\(\Theta(n)\)，是稳定排序.

思路:

不断冒泡

void bubble_sort(int num[],int len){
	for(register int i=0;i<len;i++){
		for(register int j=0;j<len-i-1;j++){
			if(num[j]>num[j+1]) swap(num[j],num[j+1]);
		}
	}
	return ;
}

直接插入排序

平均时间复杂度为\(\Theta(n^2)\)

void insert_sort(int num[],int len) {
	int v,j;
	for(register int i=1;i<len;i++) {
		v=num[i];
		j=i-1;
		while(j>=0&&v<num[j]) {
			num[j+1]=num[j];
			j=j-1;
		}
		num[j+1]=v;
	}
}

希尔排序

时间复杂度在平均情况下为\(\Theta(n^{1.3})\)，在最好情况下为\(\Theta(n)\)，在最坏情况下为\(\Theta(n^{2})\)，是不稳定排序

void shell_sort(int num[],int len) {
	int gap=len;
	while(gap>1) {
		gap=gap/3+1;
		for(register int i=gap; i<len; i++) {
			int temp=num[i];
			int pos=i-gap;
			while(pos>=0) {
				if(temp<num[pos]) swap(num[pos],num[pos+gap]);
				pos-=gap;
			}
		}
	}
	return ;
}

快速排序

时间平均复杂度为\(\Theta(nlogn)\)，但是在极端情况下会退化\(\Theta(n^{2})\)，是不稳定排序。

void quick_sort(int num[],int len) {
	int i=0,j=len-1;
	int k=num[0];
	if(i>=j) return;
	while(i<j) {
		while((i<j)&&num[j]>=k) j--;
		swap(num[i],num[j]);
		while((i<j)&&(num[i]<k)) i++;
		swap(num[i],num[j]);
	}
	quick_sort(num,i-1);
	quick_sort(num+i+1,len-i-1);
	return;
}

归并排序

时间复杂度为\(\Theta(nlogn)\)，是稳定排序。

void merge_sort(int num[],int len){
	if(len==1) return ;
	merge_sort(num,len>>1);
	merge_sort(num+(len>>1),len-(len>>1));
	int i=0,j=len>>1,pos=0,fuzhu[len];
	while(i<(len>>1)&&j<len) fuzhu[pos++]=(num[i]<num[j])? num[i++]:num[j++];
	while(i<(len>>1)) fuzhu[pos++]=num[i++];
	while(j<len) fuzhu[pos++]=num[j++];
	for(register int p=0;p<len;p++) num[p]=fuzhu[p];
	return ;
}

堆排序

时间复杂度为\(\Theta(nlogn)\)，是不稳定排序。

void heap_sort(int num[],int len) {
	int mid[len+1];
	for(register int i=1,pos; i<=len; i++) {
		mid[i]=num[i-1];
		pos=i;
		while(pos!=1) {
			if(mid[pos]<mid[pos>>1]) swap(mid[pos],mid[pos>>1]);
			else break;
			pos>>=1;
		}
	}
	for(register int i=1,pos,nex; i<=len; i++) {
		num[i-1]=mid[1];
		mid[1]=mid[len-i+1];
		pos=1;
		while(pos<<1<=len-i) {
			nex=pos<<1;
			if((mid[nex]>mid[nex|1]&&nex<len-i)) nex++;
			if(mid[pos]<=mid[nex]) break;
			swap(mid[pos],mid[nex]);
			pos=nex;
		}
	}
}