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

快速排序

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

插入排序

void insertSort(int A[],int n)
	{
		int i;
		for (int j=1;j<n;j++)
		{
			int key=A[j];
			i=j-1;
			while (i>=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<n1;i++)
			L[i]=A[p+i];
		for (i=0;i<n2;i++)
			R[i]=A[q+i+1];
		L[n1]=32767;
		R[n2]=32767;
		i=0;j=0;
		for (int k=p;k<=r;k++)
		{
			if (L[i]<=R[j])
			{
				A[k]=L[i];
				i++;
			}
			else 
			{
				A[k]=R[j];
				j++;
			}
		}
		return;
	}
	void  mergesort(int A[],int p,int r)
	{
		if(p<r)
		{	int q=(p+r)/2;
		mergesort(A,p,q);
		mergesort(A,q+1,r);
		merge(A,p,q,r);
		}
	}

计数排序

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 <stdio.h>
#include <iostream>
#include <conio.h>
#include <malloc.h>
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<d;i++)
		scale*=10;
	
	for (int j=0;j<10;j++)
	{
		int tmp;
		tmp=A[j+1];
		tmp/=scale;
		D[d][j]=tmp%10;		
	}
 //0代表低位
	counting_sort(9);	
}

void main()
{
	for (t=0;t<3;t++)
	{
		radixsort(A,t);
	}
	 
	_getche();
}

堆排序

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <conio.h>
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<<A[j]<<" ";
	}
	_getche();
}