相对快速的排序代码

//heapsort(堆排序) 
//时间复杂度(最好): O(nlogn)
//时间复杂度(最坏): O(nlogn)
//时间复杂度(平均): O(nlogn)
//空间复杂度: O(1) 
//稳定性：不稳定 
#include<bits/stdc++.h>
using namespace std;
int a[100001],n; 
void heapify(int i,int n)
{
	while(i<=n){
		int c1=2*i,c2=2*i+1,max=i;
		if(c1<=n&&a[c1]>a[max])max=c1;
		if(c2<=n&&a[c2]>a[max])max=c2;
		if(max!=i){
			swap(a[i],a[max]);
			i=max;
		}
		else break;
	}
}
void heap_sort(int x,int y)
{
	for(int i=y/2;i>=x;i--)heapify(i,y);
	for(int i=y;i>x;i--){
		swap(a[i],a[x]);
		heapify(x,i-1);
	}
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)scanf("%d",&a[i]);
	heap_sort(1,n);
	for(int i=1;i<=n;i++)printf("%d ",a[i]); 
	return 0;
}





//mergesort(归并排序) 
//时间复杂度(最好): O(nlogn)
//时间复杂度(最坏): O(nlogn)
//时间复杂度(平均): O(nlogn)
//空间复杂度: O(n) 
//稳定性：稳定 
#include<bits/stdc++.h>
using namespace std;
int n,a[100001],arr[100001];
void msort(int x,int y)
{
	if(x>=y)return; 
	int m=(x+y)/2;
	msort(x,m);
	msort(m+1,y);
	int p=x,q=m+1,r=x;
	while(r<=y){
		if(p>m&&q<=y)arr[r++]=a[q++];
		else if(p<=m&&q>y)arr[r++]=a[p++];
		else{
			if(a[p]<a[q])arr[r++]=a[p++];
			else arr[r++]=a[q++];
		}
	}
	for(int i=x;i<=y;i++)a[i]=arr[i];
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)scanf("%d",&a[i]);
	msort(1,n);
	for(int i=1;i<=n;i++)printf("%d ",a[i]);
	return 0;
}







//quicksort(快速排序) 
//时间复杂度(最好): O(nlogn)
//时间复杂度(最坏): O(n^2)
//时间复杂度(平均): O(nlogn)
//空间复杂度: O(logn) 
//稳定性：不稳定 
//速度与基数排序相当：优点：空间复杂度O(logn) 缺点：最坏情况时间复杂度高 
#include<bits/stdc++.h>
using namespace std;
int a[100001],n;
void qsort(int x,int y)
{
	if(x>=y)return;
	int p=x,q=y;
	int mid=(p+q)/2; 
	int pivot=a[mid];
	a[mid]=a[p];
	while(p<q)
	{	while(p<q&&a[q]>=pivot) q--;
		if(p<q) a[p++]=a[q];
		while(p<q&&a[p]<=pivot) p++;
		if(p<q) a[q--]=a[p];}
	a[p]=pivot;
	qsort(x,p-1);
	qsort(p+1,y);	
	

}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	qsort(1,n);
	for(int i=1;i<=n;i++)
		printf("%d ",a[i]);
 	return 0;
}











//radixsort(基数排序) 
//时间复杂度(最好): O(dn)
//时间复杂度(最坏): O(dn)
//时间复杂度(平均): O(dn)
//空间复杂度: O(n)
//稳定性：稳定 
//速度与快速排序相当：优点：最坏情况时间复杂度低 缺点：需要额外的辅助空间 
#include<bits/stdc++.h>
using namespace std;
int a[100001],arr[100001],n;
void radixsort(int x,int y)
{
	int max=a[x],base=1;
	for(int i=x+1;i<=y;i++) 
		if(a[i]>max)
			max=a[i];
	while(max/base>0){
		int bucket[10]={0};
		for(int i=x;i<=y;i++)bucket[a[i]/base%10]++;
		for(int i=1;i<10;i++)bucket[i]+=bucket[i-1];
		for(int i=y;i>=x;i--)arr[bucket[a[i]/base%10]--]=a[i];
		for(int i=x;i<=y;i++)a[i]=arr[i];
		base*=10;
	}
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)scanf("%d",&a[i]);
	radixsort(1,n);
	for(int i=1;i<=n;i++)printf("%d ",a[i]);
	return 0;
}













//shellsort(希尔排序) 
//时间复杂度(最好): O(n^1.3)
//时间复杂度(最坏): O(n^2)
//时间复杂度(平均): O(步长决定)
//空间复杂度: O(1) 
//稳定性：不稳定 
#include<bits/stdc++.h>
using namespace std;
int n,a[100001];
void ssort(int n)
{
	int key;
	for(int h=n/2;h>0;h/=2)
	{
		for(int i=h;i<n;i++)
		{
			key=a[i];
			int j;
			for(j=i-h;j>=0;j-=h)
			{
				if(key<a[j])a[j+h]=a[j];
				else break;
			}
			a[j+h]=key;
			
		}
	}
}
int main()
{
	scanf("%d",&n);
	for(int i=0;i<n;i++)scanf("%d",&a[i]);
	ssort(n);
	for(int i=0;i<n;i++)printf("%d ",a[i]);
	return 0;
}

就先这几个