快速排序，插入排序，归并排序，计数排序，基数排序，堆排序

快速排序

vector quickSort(vector &t,int a,int b)
	{
		if(a>=b) return t;
		int i=a,j=b;
		int tmp,tmp2;
		tmp=t[a];
		while (ia&&t[j-1]>tmp) j--;
			if(i

插入排序

void insertSort(int A[],int n)
	{
		int i;
		for (int j=1;j=0&&A[i]>key)
			{
				A[i+1]=A[i];
				i--;
			}
			A[i+1]=key;
		}
	}

归并排序

void merge(int A[],int p,int q,int r)
	{
		int n1,n2;
		n1=q-p+1;
		n2=r-q;
		int *L=(int *)malloc((n1+1)*sizeof(int));
		int *R=(int *)malloc((n2+1)*sizeof(int));
		int i,j;
		for (i=0;i

计数排序

void counting_sort(int A[],int B[],int k)
	{
		int i,j;
		int *C=(int *)malloc((k+1)*sizeof(int));
		for(i=0;i<=k;i++)
			C[i]=0;
		for (j=1;j<11;j++)
		{
			C[A[j]]++;
		}
		for(i=1;i<=k;i++)
			C[i]+=C[i-1];
		for (j=10;j>=1;j--)
		{
			B[C[A[j]]-1]=A[j];
			C[A[j]]--;
		}
	}

基数排序

#include 
#include 
#include 
#include 
using namespace std;


int B[10]={};//store the result
int D[3][10]={};//store the splitted result of A[]
int t;
int A[]={-1,123,234,432,532,656,723,212,312,458,687};

void counting_sort(int k)
{
	
	int i,j;
	int *C=(int *)malloc((k+1)*sizeof(int));
	for(i=0;i<=k;i++)
		C[i]=0;
	for (j=0;j<10;j++)
	{
		C[D[t][j]]++;
	}
	for(i=1;i<=k;i++)
		C[i]+=C[i-1];
	for (j=9;j>=0;j--)
	{
		B[C[D[t][j]]-1]=A[j+1];
		C[D[t][j]]--;
	}
	for (int k=0;k<10;k++)
	{
		A[k+1]=B[k];
	}
}


void radixsort(int A[],int d)
{
	int scale=1;
	for(int i=0;i

堆排序

#include 
#include 
#include 
#include 
using namespace std;


int heap_size;

int exchange(int &a,int &b)
{
	int tmp;
	tmp=a;a=b;b=tmp;
	return 0;
}
int max_heapify(int A[],int i)
{
	int l,r,largest;
	l=2*i;
	r=l+1;
	if (l<=heap_size&&A[l]>A[i])
	{ largest=l;
	}
	else
		largest=i;
	if (r<=heap_size&&A[r]>A[largest])
	{ largest=r;
	}
	if (largest!=i)
	{
		exchange(A[i],A[largest]);
		max_heapify(A,largest);
	}
	return 0;
}

int build_heap(int A[])
{
	for (int i=heap_size/2;i>0;i--)
	{
		max_heapify(A,i);
	}
	return 0;
}

int main()
{
	int A[]={-1,4,13,23,2,16,8,9,5,5,11,21};
	heap_size=11;
	build_heap(A);
	for (int i=heap_size;i>1;i--)
	{
		exchange(A[i],A[1]);
		heap_size--;
		max_heapify(A,1);
	}
	for (int j=1;j<=11;j++)
	{
		cout<