八大经典排序算法

 

目前常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

根据平均时间复杂度可分为 O(n²）:          插入排序、选择排序、冒泡排序。 （冒泡和插入算法在序列正序的情况下可以进化为O(n) )

　　　　　　　　　　　　 O(nlog2(n)) :  归并排序、堆排序、快速排序。

　　　　　　　　　　　　 O(n^1.3):       希尔排序。

　　　　　　　　　　　　 O(n+k):          基数排序。

 

冒泡排序：

 1 void bubble_sort(long a[],int n)
 2 {
 3     for(int i=0;i1;i++)
 4     {
 5         for(int j=0;j1-i;j++)
 6         {
 7             if(a[j]>a[j+1])
 8             {
 9                 long temp = a[j];
10                 a[j] = a[j+1];
11                 a[j+1] = temp;
12             }
13         }
14     }
15 }

选择排序：

 1 void select_sort(long a[],int n)
 2 {
 3     for(int i=0;i1;i++)
 4     {
 5         int min = a[i];
 6         int k=i;
 7         for(int j=i+1;j){
 8             if(a[j]<min)
 9             {
10                 min = a[j];
11                 k=j;
12             }
13         }
14         if(k!=i)
15         {
16             int temp = a[i];
17             a[i]=a[k];
18             a[k]=temp;
19         }
20     }
21 }

插入排序：

 1 void insert_sort(long a[],int n)
 2 {
 3     for(int i=1;i)
 4     {
 5         int j=i-1;
 6         long temp = a[i];
 7         while(j>=0 && a[j]>temp)
 8         {
 9             a[j+1]=a[j];
10             j--;
11         }
12         a[j+1] = temp;
13     }
14 }

希尔排序：

 1 void shell_sort(long a[],int n)
 2 {
 3     int gap = 1;
 4     while(gap < n/3) gap = gap*3+1;
 5     for(gap;gap>0;gap/=2)
 6     {
 7         for(int i=gap;i)
 8         {
 9             int temp = a[i];
10             int j;
11             for(j=i-gap;j>=0&&a[j]>temp;j-=gap)
12             {
13                 a[j+gap]=a[j];
14             }
15             a[j+gap] = temp;
16         }
17     }
18 }

归并排序：

 1 //运动分治递归的思想
 2 void merge_he(long a[],int left,int mid,int right,long *temp)
 3 {
 4     int i=left;
 5     int j=mid+1;
 6     int k=left;
 7     while(i<=mid && j<=right)
 8     {
 9         if(a[i]<a[j])
10         {
11             temp[k++]=a[i++];
12         }
13         else if(a[i]>=a[j])
14         {
15             temp[k++]=a[j++];
16         }
17     }
18     while(i<=mid)
19     {
20         temp[k++]=a[i++];
21     }
22     while(j<=right)
23     {
24         temp[k++]=a[j++];
25     }
26     memcpy(a+left,temp+left,sizeof(long)*(right-left+1));
27 }
28 void merge_fen(long a[],int left,int right,long *temp)
29 {
30     if(left < right)
31     {
32         int mid = left + (right - left)/2;
33         merge_fen(a,left,mid,temp);
34         merge_fen(a,mid+1,right,temp);
35         merge_he(a,left,mid,right,temp);
36     }
37 }
38 void merge_sort(long a[],int n)
39 {
40     long *temp = (long *)malloc(sizeof(long)*n);
41     merge_fen(a,0,n-1,temp);
42     free(temp);
43 }

快速排序：

 1 void quick(long a[],int left,int right)
 2 {
 3     if(left<right)
 4     {
 5         int i=left;
 6         int j=right;
 7         long temp = a[i];
 8         while(i<j)
 9         {
10             while(itemp) j--;
11             if(ia[j];
12             while(i;
13             if(ia[i];
14         }
15         a[i]=temp;
16         quick(a,left,i-1);
17         quick(a,i+1,right);
18     }
19 }
20 void quick_sort(long a[],int n)
21 {
22     quick(a,0,n-1);
23 }

堆排序：

 1 void heap(long a[],int parent,int n)
 2 {
 3     int child = 2*parent+1;
 4     long temp = a[parent];
 5     while(child < n)
 6     {
 7         if(child+1 1])
 8         {
 9             child++;
10         }
11         if(a[child] < temp)
12             break;
13 
14         a[parent] = a[child];
15 
16         parent = child;
17         child = 2*parent +1;
18     }
19     a[parent] = temp;
20 }
21 void heap_sort(long a[],int n)
22 {
23     for(int i=n/2-1;i>=0;i--)
24         heap(a,i,n);
25 
26     for(int i=n-1;i>0;i--)
27     {
28         int temp = a[0];
29         a[0] = a[i];
30         a[i] = temp;
31 
32         heap(a,0,i);
33     }
34 }

基数排序：

 1 long get_max(long a[],int n)
 2 {
 3     long max = a[0];
 4     for(int i=1;i)
 5     {
 6         if(a[i]>max)
 7             max = a[i];
 8     }
 9     return max;
10 }
11 void radix_sort(long a[],int n)
12 {
13     long bucket[10][n];   //桶
14     int count[10]={0};       //记录每个桶中存入数的个数
15 
16     long max = get_max(a,n);
17     for(long i=1;max/i>0;i*=10)
18     {
19         for(int j=0;j)
20         {
21             int num = (a[j]/i)%10;
22             bucket[num][count[num]]=a[j];
23             count[num]++;
24         }
25         int c=0;
26         for(int i=0;i<10;i++)
27         {
28             if(count[i]!=0)
29             {
30                 for(int j=0;j)
31                 {
32                     a[c++] = bucket[i][j];
33                 }
34             }
35             count[i]=0;
36         }
37     }
38 }