排序算法----冒泡排序+插入排序+选择排序+快速排序+希尔排序+堆排序+归并排序+计数排序+基数排序+桶排序（c语言）

比较排序：冒泡排序、插入排序、选择排序、快速排序、希尔排序、堆排序、归并排序
非比较排序：计数排序、基数排序、桶排序
1，冒泡排序 Bubble Sort

#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#define SIZE 10

void bubble_sort(int a[],int len);

int main(){

int i;

int array[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

bubble_sort(array,SIZE);

for(i=0;i<SIZE;i++){

printf("%d\t",array[i]);

}

return 0;

}

void bubble_sort(int a[],int len){

int i,j,temp;

for(i=0;i<len-1;i++){

for(j=0;j<len-i-1;j++){

if(a[j+1]<a[j]){

temp=a[j+1];

a[j+1]=a[j];

a[j]=temp;

}

}

}

}

2，插入排序 insertion sort

（1）直接插入排序 insertion sort

#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#define SIZE 10

void insert_sort(int a[],int len);

int main(){

int i;

int array[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

insert_sort(array,SIZE);

for(i=0;i<SIZE;i++){

printf("%d\t",array[i]);

}

return 0;

}

void insert_sort(int a[],int len){

int i,j,temp;

for(i=1;i<len;i++){

temp=a[i];

for(j=i-1;j>=0&&a[j]>temp;j--){

a[j+1]=a[j];

}

a[j+1]=temp;

}

}

（2）折半插入排序 binary insertion sort

折半插入排序算法是一种稳定的排序算法，比直接插入算法明显减少了关键字之间比较的次数，因此速度比直接插入排序算法快，但记录移动的次数没有变，所以折半插入排序算法的时间复杂度仍然为O(n^2)，与直接插入排序算法相同。附加空间O(1)。
#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#define SIZE 10

void insert_sort(int a[],int len);

int main(){

int i;

int array[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

insert_sort(array,SIZE);

for(i=0;i<SIZE;i++){

printf("%d\t",array[i]);

}

return 0;

}

void insert_sort(int a[],int len){

int i,j,temp,low,high,mid;

for(i=1;i<len;i++){

temp=a[i];

low=0;high=i;

while(low<=high){

mid=(low+high)/2;

if(a[i]>a[mid]){

low=mid+1;

}

else if(a[i]<a[mid]){

high=mid-1;

}

else{

low=mid;

high=low-1;

}

}

for(j=i-1;j>=low;j--){

a[j+1]=a[j];

}

a[low]=temp;

}

}


3，选择排序 Selection sort
（1） 基本选择排序
#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#define SIZE 10

void selection_sort(int a[],int len);

int main(){

int i;

int array[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

selection_sort(array,SIZE);

for(i=0;i<SIZE;i++){

printf("%d\t",array[i]);

}

return 0;

}

void selection_sort(int a[],int len){

int i,j,temp,min;

for(i=0;i<len-1;i++){

min=i;

for(j=i;j<len;j++){

if(a[j]<a[min]){

min=j;

}

}

if(min!=i){

temp=a[i];

a[i]=a[min];

a[min]=temp;

}

}

}


4，快速排序 Quicksort

#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#define SIZE 10

void quick_sort(int a[],int left,int right);

void swap(int *p,int *q);

int main(){

int i;

int array[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

quick_sort(array,0,SIZE-1);

for(i=0;i<SIZE;i++){

printf("%d\t",array[i]);

}

return 0;

}

void quick_sort(int a[],int left,int right){

int i,j,key;

if(left>=right){

return;

}

key=a[left];

i=left;

j=right;

while(i<j){

while(i<j&&a[j]>=key){

j--;

}

a[i]=a[j];

while(i<j&&a[i]<=key){

i++;

}

a[j]=a[i];

}

a[i]=key;

quick_sort(a,left,i-1);

quick_sort(a,i+1,right);

}

5，,归并排序
（1） 非递归
#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#include <math.h>

#define SIZE 10

void merge_sort(int a[],int b[]);

void merge(int a[],int b[],int start,int mid,int end);

int main(){

int i;

int array[SIZE];

int arraycopy[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

merge_sort(array,arraycopy);

for(i=0;i<SIZE;i++){

printf("%d\t",arraycopy[i]);

}

return 0;

}

void merge_sort(int a[],int b[]){

int i,j,len,start,mid,end;

len=(int)(log(SIZE+1)/log(2)+1);

for(i=1;i<=len;i++){

for(j=0;j<SIZE;j+=(int)pow(2,i)){

start=j;

mid=j+(int)(pow(2,i-1))-1;

end=j+(int)(pow(2,i))-1;

if(end>SIZE-1){

end=SIZE-1;

}

if(mid>SIZE-1){

mid=SIZE-1;

}

merge(a,b,start,mid,end);

}

}

}

void merge(int a[],int b[],int start,int mid,int end){

int i=start,j=mid+1,k=start;

while(i<=mid&&j<=end){

if(a[i]<=a[j]){

b[k++]=a[i++];

}

else{

b[k++]=a[j++];

}

}

while(i<=mid){

b[k++]=a[i++];

}

while(j<=end){

b[k++]=a[j++];

}

for(i=start;i<=end;i++){

a[i]=b[i];

}

}


（2）递归
#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#define SIZE 10

void merge_sort(int a[],int b[],int startindex,int endindex);

void merge(int a[],int b[],int start,int mid,int end);

int main(){

int i;

int array[SIZE];

int arraycopy[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

merge_sort(array,arraycopy,0,SIZE-1);

for(i=0;i<SIZE;i++){

printf("%d\t",arraycopy[i]);

}

return 0;

}

void merge_sort(int a[],int b[],int startindex,int endindex){

int midindex=(startindex+endindex)/2;

if(startindex<endindex){

merge_sort(a,b,startindex,midindex);

merge_sort(a,b,midindex+1,endindex);

merge(a,b,startindex,midindex,endindex);

}

}

void merge(int a[],int b[],int start,int mid,int end){

int i=start,j=mid+1,k=start;

while(i<=mid&&j<=end){

if(a[i]<=a[j]){

b[k++]=a[i++];

}

else{

b[k++]=a[j++];

}

}

while(i<=mid){

b[k++]=a[i++];

}

while(j<=end){

b[k++]=a[j++];

}

for(i=start;i<=end;i++){

a[i]=b[i];

}

}




6，堆排序 HeapSort
#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#define SIZE 10

void heap_sort(int a[]);

void findmax(int a[],int index,int end);

int main(){

int i;

int array[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

heap_sort(array);

for(i=0;i<SIZE;i++){

printf("%d\t",array[i]);

}

return 0;

}

void heap_sort(int a[]){

int i,j,temp,k;

int end=SIZE-1;

for(i=SIZE/2-1;i>=0;i--){

findmax(a,i,end);

}

for(i=SIZE-2;i>0;i--){

temp=a[0];

a[0]=a[i+1];

a[i+1]=temp;

findmax(a,0,i);

}

temp=a[0];

a[0]=a[i+1];

a[i+1]=temp;

}

void findmax(int a[],int index,int end){

int left=(index+1)*2-1;

int right=left+1;

int max=a[left],maxindex=left;

int temp;

if(right<=end&&a[right]>a[left]){

max=a[right];

maxindex=right;

}

if(a[index]<max){

temp=a[index];

a[index]=a[maxindex];

a[maxindex]=temp;

if(maxindex<=(end-1)/2){

findmax(a,maxindex,end);

}

}

}

7，希尔排序 ShellSort
#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#define SIZE 10

void shell_sort(int a[]);

void inserSort(int a[],int start,int d);

int main(){

int i;

int array[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

shell_sort(array);

for(i=0;i<SIZE;i++){

printf("%d\t",array[i]);

}

return 0;

}

void shell_sort(int a[]){

int i,j;

for(i=SIZE/2;i>0;i/=2){

for(j=0;j<i;j++){

inserSort(a,j,i);

}

}
}

void inserSort(int a[],int start,int d){

int i,j,temp;

for(i=start+d;i<SIZE;i+=d){

temp=a[i];

for(j=i-d;j>=0&&a[j]>temp;j-=d){

a[j+d]=a[j];

}

a[j+d]=temp;

}

}

8，计数排序 CountingSort
#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#define SIZE 10

void counting_sort(int a[],int b[]);

int main(){

int i;

int array[SIZE];

int arraycopy[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

counting_sort(array,arraycopy);

for(i=0;i<SIZE;i++){

printf("%d\t",arraycopy[i]);

}

return 0;

}

void counting_sort(int a[],int b[]){

int i,k;

int max=a[0],min=a[0];

for(i=0;i<SIZE;i++){

if(a[i]>max){

max=a[i];

}

if(a[i]<min){

min=a[i];

}

}

k=max-min+1;

int c[k];

for(i=0;i<k;i++){

c[i]=0;

}

for(i=0;i<SIZE;i++){

c[a[i]-min]++;

}

for(i=1;i<k;i++){

c[i]+=c[i-1];

}

for(i=0;i<SIZE;i++){

b[--c[a[i]-min]]=a[i];

}

}


9，基数排序 RadixSort
时间效率 ：设待排序列为n个记录，d个关键码，关键码的取值范围为radix，则进行链式基数排序的时间复杂度为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。 空间效率：需要2*radix个指向队列的辅助空间，以及用于静态链表的n个指针。
最高位优先(Most Significant Digit first)法，简称MSD法：先按k1排序分组，同一组中记录，关键码k1相等，再对各组按k2排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd对各子组排序后。再将各组连接起来，便得到一个有序序列。
最低位优先(Least Significant Digit first)法，简称LSD法：先从kd开始排序，再对kd-1进行排序，依次重复，直到对k1排序后便得到一个有序序列。

（1）LSD
#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#include <math.h>

#define SIZE 10

void radix_sort(int a[]);

int main(){

int i;

int array[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

radix_sort(array);

for(i=0;i<SIZE;i++){

printf("%d\t",array[i]);

}

return 0;

}

void radix_sort(int a[]){

int i,d,j,k,p;

int max=a[0];

for(i=0;i<SIZE;i++){

if(a[i]>max){

max=a[i];

}

}

i=max;

d=0;

while(i!=0){

i=i/10;

d++;

}

int b[10][SIZE]={};

int count[10]={0};

p=0;

while(p!=d){

for(i=0;i<10;i++){

count[i]=0;

}

for(i=0;i<SIZE;i++){

j=a[i]/(int)pow(10,p)%10;

b[j][count[j]++]=a[i];

}

k=0;

for(i=0;i<10;i++){

j=0;

for(j=0;j<count[i];j++){

a[k++]=b[i][j];

}

}

p++;

}
}


（2）MSD
#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#include <math.h>

#define SIZE 10

void radix_sort(int a[]);

void sort(int a[],int d,int n);

int main(){

int i;

int array[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

radix_sort(array);

for(i=0;i<SIZE;i++){

printf("%d\t",array[i]);

}

return 0;

}

void radix_sort(int a[]){

int i,d;

int max=a[0];

for(i=0;i<SIZE;i++){

if(a[i]>max){

max=a[i];

}

}

i=max;

d=0;

while(i!=0){

i=i/10;

d++;

}

sort(a,d,SIZE);

}

void sort(int a[],int d,int n){

int i,j,k;

int b[10]
;

int count[10]={0};

for(i=0;i<10;i++){

count[i]=0;

}

for(i=0;i<n;i++){

j=a[i]/(int)pow(10,d-1)%10;

b[j][count[j]++]=a[i];

}

if(d>1){

for(i=0;i<10;i++){

if(count[i]>1){

sort(b[i],d-1,count[i]);

}

}

}

k=0;

for(i=0;i<10;i++){

j=0;

for(j=0;j<count[i];j++){

a[k++]=b[i][j];

}

}

}



10，桶排序 BucketSort
#include <stdio.h>

#include <time.h>

#include <stdlib.h>

#include <math.h>

#include <string.h>

#define SIZE 10

void bucket_sort(int a[]);

void insert_sort(int a[],int len);

struct barrel{

int node[SIZE];

int count;

};

int main(){

int i;

int array[SIZE];

srand((int)time(NULL));

for(i=0;i<SIZE;i++){

array[i]=rand()%100;

}

bucket_sort(array);

for(i=0;i<SIZE;i++){

printf("%d\t",array[i]);

}

return 0;

}

void bucket_sort(int a[]){

struct barrel *pBarrel;

int i,d,k,j,index=0;

int max=a[0],min=a[0];

for(i=0;i<SIZE;i++){

if(a[i]>max){

max=a[i];

}

if(a[i]<min){

min=a[i];

}

}

d=(max-min)/10+1;

pBarrel=(struct barrel*)malloc(sizeof(struct barrel)*d);

memset(pBarrel, 0, sizeof(struct barrel) * d);

for(i=0;i<SIZE;i++){

k=(a[i]-min)/10;

(pBarrel + k)->node[(pBarrel + k)->count] = a[i];

(pBarrel + k)->count++;

}

for(i=0;i<d;i++){

insert_sort((pBarrel+i)->node,(pBarrel+i)->count);

for(j=0;j<(pBarrel+i)->count;j++){

a[index++]=(pBarrel+i)->node[j];

}

}

}

void insert_sort(int a[],int len){

int i,j,temp;

for(i=1;i<len;i++){

temp=a[i];

for(j=i-1;j>=0&&a[j]>temp;j--){

a[j+1]=a[j];

}

a[j+1]=temp;

}

}