刚看的几个排序算法，一下午写了下。。

/*  1.           
****************************************
堆排序算法,复杂度O(nlgn)   渐近最优算法


#define PARENT(i) i/2-1
#define LEFT(i) 2*i+1
#define RIGHT(i) 2*i+2
int largest;
int heap_size;
void max_heapify(int A[],int i){           //维持最大堆的性质
	int l,r;
	int temp,largest;
	l=LEFT(i);
	r=RIGHT(i);
	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){
		temp=A[i];
		A[i]=A[largest];
		A[largest]=temp;
		max_heapify(A,largest);
	}
}
void build_max_heap(int A[]){      //开始建堆
	int i;
	for(i=(heap_size-2)/2;i>=0;i--)
		max_heapify(A,i);                   //从倒数第二层开始建堆
}
void heap_sort(int A[]){          //进行堆排
	int temp;
	int i;
	build_max_heap(A);
	for(i=heap_size-1;i>=1;i--){
		temp=A[0];
		A[0]=A[i];
		A[i]=temp;
		heap_size--;             //减少一个
		max_heapify(A,0);
	}
}
**************************
*/
/*  2.
**************************
插入排序 复杂度O(n2)
void insertion_sort(int a[],int n){         //插入排序算法
	int j,key;
	int k;
	for(j=1;j<n;j++){
		key=a[j];
		for(k=j-1;k>=0&&a[k]>key;k--){
			a[k+1]=a[k];
		}
		a[k+1]=key;
	}
}
********************
*/
/*   3.
合并排序   时间复杂度为O(nlgn)
********************
#include<stdlib.h>
#define NIF 1000000              //哨兵
void merge(int a[],int p,int q,int r){      //合并排序算法
	int n1=q-p+1;
	int n2=r-q;
	int i,j,k;
	int *L,*R;
	L=(int *)malloc((n1+1)*sizeof(int));
	R=(int *)malloc((n2+1)*sizeof(int));
	for(i=0;i<n1;i++)
		L[i]=a[p+i];
	for(j=0;j<n2;j++)
		R[j]=a[q+j+1];
	L[n1]=NIF;
	R[n2]=NIF;
	i=0;j=0;
	for(k=p;k<=r;k++){
		if(L[i]<R[j]){
			a[k]=L[i];
			i++;
		}
		else{
			a[k]=R[j];
			j++;
		}
	}
}
void merge_sort(int a[],int p,int r){          //将a从p到r排序
	int j;
	if(p<r){
    	j=(r+p)/2;
    	merge_sort(a,p,j);
    	merge_sort(a,j+1,r);                        //分治排序
    	merge(a,p,j,r);                          //合并起来
	}
}
*****************************
*/
/*  4.
*****************************
冒泡排序   时间复杂度为O(n2)
void buddle_sort(int a[],int n){           //冒泡排序
	int i,j;
	int temp;
	for(i=0;i<n;i++){
		for(j=n-1;j>i;j--){
			if(a[j]<a[j-1]){
				temp=a[j-1];
				a[j-1]=a[j];
				a[j]=temp;
			}
		}
	}
}
***************************
*/
/*   5.
***************************
快速排序算法     采用随机算法时 时间复杂度O(nlgn)   
int partition(int a[],int p,int r){            //快排关键算法
	int key=a[r];
	int i,j,temp;
	i=p-1;
	for(j=p;j<=r-1;j++){
		if(a[j]<key){
			i++;
			temp=a[i];
			a[i]=a[j];
			a[j]=temp;
		}
	}
	temp=a[i+1];
	a[i+1]=key;
	a[r]=temp;
	return i+1;
}
void quick_sort(int a[],int p,int r){          //快排
	int q;
	if(p<r){
		q=partition(a,p,r);
		quick_sort(a,p,q-1);
		quick_sort(a,q+1,r);
	}
}
**********************

*/
/*   6.
**********************
位于0到k之间的数，当k不太时采用计数排序
线性复杂时间度O(n)
#include<stdlib.h>
void counting_sort(int a[],int b[],int k,int n){       //a是要排数组，b是排好的数组,k是最大数,待排个数
	int *c;
	int i,j;
	c=(int *)malloc(sizeof(int)*k);
	for(i=0;i<k;i++)
		c[i]=0;                           //初始化数组c...记录a中等于i等元素个数
	for(j=0;j<n;j++)
		c[a[j]]++;
	for(j=1;j<=k;j++)
		c[j]=c[j]+c[j-1];
	for(j=n-1;j>=0;j--){
		b[c[a[j]]-1]=a[j];
		c[a[j]]--;
	}
}
***********************
*/
/*选择第i小的元素
***********************
int partition(int a[],int p,int r){            //快排关键算法
	int key=a[r];
	int i,j,temp;
	i=p-1;
	for(j=p;j<=r-1;j++){
		if(a[j]<key){
			i++;
			temp=a[i];
			a[i]=a[j];
			a[j]=temp;
		}
	}
	temp=a[i+1];
	a[i+1]=key;
	a[r]=temp;
	return i+1;
}
int select(int a[],int p,int r,int i){
	int q,k;
	if(p==r)
		return a[p];
	q=partition(a,p,r);          //采用部分快排算法
	k=q-p+1;
	if(k==i)
		return a[q];
	else{
		if(i<k)
			select(a,p,q-1,i);
		else
			select(a,q+1,r,i-k);
	}
}
*********************
*/
/*#include <stdio.h>
#include <stdlib.h>
int main(){

    int data[10]={73,22,93,43,55,14,28,65,39,81};
    int temp[10][10]={0};  
	int order[10]={0};
    int i,j,k,n,lsd;
    k=0;n=1;
    printf("\n排序前: ");
    for (i=0;i<10;i++) printf("%d ",data[i]);
    putchar('\n');
    while (n<=10){
    for (i=0;i<10;i++){
       lsd=((data[i]/n)%10);
       temp[lsd][order[lsd]]=data[i];
       order[lsd]++;
	}

    printf("\n重新排列: ");
    for (i=0;i<10;i++){
      if(order[i]!=0)
         for (j=0;j<order[i];j++){
           data[k]=temp[i][j];
         printf("%d ",data[k]);
             k++;
		 }
         order[i]=0;
	}
            n*=10;
            k=0;
	}
putchar('\n');
printf("\n排序后: ");
for (i=0;i<10;i++) printf("%d ",data[i]);
system("pause");
return 0;
}*/
/*以lsd排序   以左边最低位排序
*******************************
void radix_sort_low(int a[],int keysize,int array_size){
	int n,k,i,j,l,lsd;             //lsd记录基数
	int temp[10][10000];              //行记录基数是多少，列记录此基数有多少个
	int order[10]={0};
	n=1;
	for(l=1;l<=keysize;l++,n*=10){
		k=0;
		for(i=0;i<array_size;i++){
			lsd=(a[i]/n)%10;
			temp[lsd][order[lsd]]=a[i];
			order[lsd]++;
		}       
		printf("重新排列:  ");
		for(i=0;i<10;i++){
			if(order[i]!=0){
				for(j=0;j<order[i];j++){
					a[k]=temp[i][j];
					printf("%d ",a[k]);
					k++;
				}
			}
			order[i]=0;     //重新置为0
		}
		printf("\n");
	}
}
******************************
*/
/*
希尔排序，迅速减少大量无序情况
******************************
void shell_sort(int a[],int n){
	int i,j,gap;
	int temp;
	for(gap=n/2;gap>0;gap/=2)
		for(i=gap;i<n;i++)
			for(j=i-gap;j>=0&&a[j]>a[j+gap];j=j-gap){
				temp=a[j];
				a[j]=a[j+gap];
				a[j+gap]=temp;
			}
}
*****************************
*/
/*
插入排序算法
*********************
void select(int a[],int n){
	int i,k,j,temp;
	int key;
	for(i=0;i<n;i++){
		key=a[i];
		temp=i;
		for(j=i+1;j<n;j++){
			if(a[j]<key){
				key=a[j];
				temp=j;
			}
		}
		k=a[i];
		a[i]=a[temp];
		a[temp]=k;
	}
}
***************************
*/