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

比较排序：冒泡排序、插入排序、选择排序、快速排序、希尔排序、堆排序、归并排序

非比较排序：计数排序、基数排序、桶排序

1，冒泡排序 Bubble Sort

#include
#include
#include
#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         array[i]=rand()%100;
    }
    bubble_sort(array,SIZE);
    for(i=0;i         printf("%d\t",array[i]);
    }
    return 0;
}
void bubble_sort(int a[],int len){
    int i,j,temp;
    for(i=0;i         for(j=0;j             if(a[j+1]                 temp=a[j+1];
                a[j+1]=a[j];
                a[j]=temp;
            }
        }
    }
}

2，插入排序 insertion sort

（1）直接插入排序 insertion sort

#include
#include
#include
#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         array[i]=rand()%100;
    }
    insert_sort(array,SIZE);
    for(i=0;i         printf("%d\t",array[i]);
    }
    return 0;
}
void insert_sort(int a[],int len){
    int i,j,temp;
    for(i=1;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
#include
#include
#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         array[i]=rand()%100;
    }
    insert_sort(array,SIZE);
    for(i=0;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         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]                 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
#include
#include
#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         array[i]=rand()%100;
    }
    selection_sort(array,SIZE);
    for(i=0;i         printf("%d\t",array[i]);
    }
    return 0;
}
void selection_sort(int a[],int len){
    int i,j,temp,min;
    for(i=0;i         min=i;
        for(j=i;j             if(a[j]                 min=j;
            }
        }
        if(min!=i){
            temp=a[i];
            a[i]=a[min];
            a[min]=temp;
        }
    }
}


4，快速排序 Quicksort



#include
#include
#include
#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         array[i]=rand()%100;
    }
    quick_sort(array,0,SIZE-1);
    for(i=0;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         while(i=key){
            j--;
        }
        a[i]=a[j];
        while(i             i++;
        }
        a[j]=a[i];
    }
    a[i]=key;
    quick_sort(a,left,i-1);
    quick_sort(a,i+1,right);
}

5，,归并排序

（1）  非递归

#include
 #include
 #include
 #include
 #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          array[i]=rand()%100;
     }
     merge_sort(array,arraycopy);
     for(i=0;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             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
#include
#include
#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         array[i]=rand()%100;
    }
    merge_sort(array,arraycopy,0,SIZE-1);
    for(i=0;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         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
 #include
 #include
 #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          array[i]=rand()%100;
     }
     heap_sort(array);
     for(i=0;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]         temp=a[index];
        a[index]=a[maxindex];
        a[maxindex]=temp;
        if(maxindex<=(end-1)/2){
            findmax(a,maxindex,end);
        }
    }
}

7，希尔排序 ShellSort

#include
 #include
 #include
 #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          array[i]=rand()%100;
     }
     shell_sort(array);
     for(i=0;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             inserSort(a,j,i);
         }
     }

 }
void inserSort(int a[],int start,int d){
     int i,j,temp;
     for(i=start+d;i          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
 #include
 #include
 #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          array[i]=rand()%100;
     }
     counting_sort(array,arraycopy);
     for(i=0;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         if(a[i]>max){
            max=a[i];
        }
        if(a[i]             min=a[i];
        }
     }
     k=max-min+1;
     int c[k];
     for(i=0;i         c[i]=0;
     }
     for(i=0;i         c[a[i]-min]++;
     }
     for(i=1;i         c[i]+=c[i-1];
     }
     for(i=0;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
 #include
 #include
 #include
 #define SIZE 10
 void radix_sort(int a[]);
 int main(){
     int i;
     int array[SIZE];
     srand((int)time(NULL));
     for(i=0;i          array[i]=rand()%100;
     }
     radix_sort(array);
     for(i=0;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         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             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                 a[k++]=b[i][j];
            }
         }
         p++;
    }

 }



（2）MSD

 #include
 #include
 #include
 #include
 #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          array[i]=rand()%100;
     }
     radix_sort(array);
     for(i=0;i         printf("%d\t",array[i]);
     }
     return 0;
 }
 void radix_sort(int a[]){
     int i,d;
     int max=a[0];
     for(i=0;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][n];
    int count[10]={0};
    for(i=0;i<10;i++){
        count[i]=0;
    }
     for(i=0;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             a[k++]=b[i][j];
        }
     }
}




10，桶排序 BucketSort

 #include
 #include
 #include
 #include
 #include
 #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          array[i]=rand()%100;
     }
     bucket_sort(array);
     for(i=0;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         if(a[i]>max){
            max=a[i];
        }
        if(a[i]             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         k=(a[i]-min)/10;
        (pBarrel + k)->node[(pBarrel + k)->count] = a[i];
        (pBarrel + k)->count++;
     }
     for(i=0;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          temp=a[i];
         for(j=i-1;j>=0&&a[j]>temp;j--){
               a[j+1]=a[j];
         }
         a[j+1]=temp;
     }
 }