学习排序算法

先来看看国外学校优美的舞蹈吧！！！点击打开链接，被震撼到了有没有！

一、初等的三种排序算法：

选择排序（Selection sort）、插入排序（Insertion sort）与冒泡排序（Bubble sort）這三个排序方式是初学排序所必须知道的三个基本排序方式，它们由于速度不快而不实用（时间复杂度都是O(n²)），然而它们排序的方式确实值得我们观察和探讨。

1、选择排序

原理：将初始序列(A[0]~A[n-1])作为待排序序列，第一趟在待排序序列(A[0]~A[n-1])中找到最小值元素，将其与第一个元素A[0]交换，这样子序列(A[0])已经有序，下一趟在排序在待排序子序列(A[1]~A[n-1])中进行。第i趟排序在待排序子序列(A[i-1]~A[n-1])中找到最小值元素，与该子序列中第一个元素A[i-1]交换。经过 n-1 趟排序后使得初始序列有序。

示例： 初始序列：70 80 31 37 10 1 48 60 33 80

[plain] view plaincopyprint?

1. 第1趟：  [1] 80 31 37 10 70 48 60 33 80  
2. 第2趟：  [1 10] 31 37 80 70 48 60 33 80  
3. 第3趟：  [1 10 31] 37 80 70 48 60 33 80  
4. 第4趟：  [1 10 31 33] 80 70 48 60 37 80  
5. 第5趟：  [1 10 31 33 37] 70 48 60 80 80  
6. 第6趟：  [1 10 31 33 37 48] 70 60 80 80  
7. 第7趟：  [1 10 31 33 37 48 60] 70 80 80  
8. 第8趟：  [1 10 31 33 37 48 60 70] 80 80  
9. 第9趟：  [1 10 31 33 37 48 60 70 80] 80  
10. 结 果：  [1 10 31 33 37 48 60 70 80 80]  

其他说明：选择排序的最好、最坏和平均情况的时间复杂度都为O(n²)，而且它还需交换元素(n-1)次和移动元素3(n-1)次；它是不稳定的排序算法。

2、插入排序

原理：将初始序列中的第一个元素作为一个有序序列，然后将剩下的 n-1 个元素按关键字大小依次插入该有序序列，每插入一个元素后依然保持该序列有序，经过 n-1 趟排序后使初始序列有序。

示例： 初始序列：92 77 67 8 6 84 55 85 43 67

[plain] view plaincopyprint?

1. 第1趟：  [77 92] 67 8 6 84 55 85 43 67  
2. 第2趟：  [67 77 92] 8 6 84 55 85 43 67  
3. 第3趟：  [8 67 77 92] 6 84 55 85 43 67  
4. 第4趟：  [6 8 67 77 92] 84 55 85 43 67  
5. 第5趟：  [6 8 67 77 84 92] 55 85 43 67  
6. 第6趟：  [6 8 55 67 77 84 92] 85 43 67  
7. 第7趟：  [6 8 55 67 77 84 85 92] 43 67  
8. 第8趟：  [6 8 43 55 67 77 84 85 92] 67  
9. 第9趟：  [6 8 43 55 67 67 77 84 85 92]  
10. 结 果：  [6 8 43 55 67 67 77 84 85 92]  

其他说明：插入排序在最好的情况下时间复杂度为O(n)，比较次数为(n-1)次，移动元素次数是2(n-1)；最坏的情况下时间复杂度为O(n²)；插入排序是稳定的排序算法。

3、冒泡排序

原理：第一趟在序列(A[0]~A[n-1])中从前往后进行两个相邻元素的比较，若后者小，则交换，比较 n-1 次；第一趟排序结束，最大元素被交换到A[n-1]中，下一趟排序只需要在子序列(A[0]~A[n-2])中进行；冒泡排序最多进行 n-1 趟。基本的冒泡排序可以利用旗标的方式稍微减少一些比较的时间，当寻访完序列后都沒有发生任何的交换动作，表示排序已经完成，而无需再进行之后的比较与交换动作。

示例： 初始序列：95 27 90 49 80 58 6 9 18 50

[plain] view plaincopyprint?

1. 第1趟：  27 90 49 80 58 6 9 18 50 [95]  
2. 第2趟：  27 49 80 58 6 9 18 50 [90 95]  
3. 第3趟：  27 49 58 6 9 18 50 [80 90 95]  
4. 第4趟：  27 49 6 9 18 50 [58 80 90 95]  
5. 第5趟：  27 6 9 18 49 [50 58 80 90 95]  
6. 第6趟：  6 9 18 27 [49 50 58 80 90 95]  
7. 第7趟：  6 9 18 [27 49 50 58 80 90 95] 由于之后不会再发生交换动作，排序提早结束  
8. 结 果：  [6 9 18 27 49 50 58 80 90 95]  

其他说明：冒泡排序最好的情况下只需进行一趟排序，(n-1)次比较，此时的时间复杂度为O(n)，无需移动元素；最坏的情况下进行 n-1 趟排序，时间复杂度为O(n²)；冒泡排序是稳定的排序算法。

4、三种排序算法的实现

C语言：

[cpp] view plaincopyprint?

1. #include <stdio.h>   
2. #include <stdlib.h>   
3. #include <time.h>   
4. #define MAX 10   
5. #define SWAP(x,y) {int t; t = x; x = y; y = t;}   
6.   
7. void selsort(int[]);  // 选择排序   
8. void insort(int[]);   // 插入排序   
9. void bubsort(int[]);  // 冒泡排序   
10.   
11. int main(void) {    
12.     int number[MAX] = {0};   
13.     int i;    
14.   
15.     srand(time(NULL));   
16.   
17.     printf("排序前：");   
18.     for(i = 0; i < MAX; i++) {   
19.         number[i] = rand() % 100;   
20.         printf("%d ", number[i]);   
21.     }   
22.   
23.     printf("\n请选择排序方式：\n");   
24.     printf("(1)选择排序\n(2)插入排序\n(3)冒泡排序\n:");   
25.     scanf("%d", &i);   
26.   
27.     switch(i) {   
28.         case 1:   
29.             selsort(number); break;   
30.         case 2:   
31.             insort(number); break;   
32.         case 3:   
33.             bubsort(number); break;   
34.         default:   
35.             printf("选项错误(1..3)\n");   
36.     }   
37.   
38.     return 0;   
39. }   
40.   
41. void selsort(int number[]) {   
42.     int i, j, k, m;   
43.   
44.     for(i = 0; i < MAX-1; i++) {   
45.         m = i;   
46.         for(j = i+1; j < MAX; j++)   
47.             if(number[j] < number[m])   
48.                 m = j;   
49.   
50.         if( i != m)   
51.             SWAP(number[i], number[m])   
52.   
53.         printf("第 %d 次排序：", i+1);   
54.         for(k = 0; k < MAX; k++)   
55.             printf("%d ", number[k]);   
56.         printf("\n");   
57.     }   
58.  }   
59.   
60.  void insort(int number[]) {   
61.     int i, j, k, tmp;   
62.   
63.     for(j = 1; j < MAX; j++) {   
64.         tmp = number[j];   
65.         i = j - 1;   
66.         while(tmp < number[i]) {   
67.             number[i+1] = number[i];   
68.             i--;   
69.             if(i == -1)   
70.                 break;   
71.         }   
72.         number[i+1] = tmp;   
73.   
74.         printf("第 %d 次排序：", j);   
75.         for(k = 0; k < MAX; k++)   
76.             printf("%d ", number[k]);   
77.         printf("\n");   
78.     }   
79. }   
80.   
81. void bubsort(int number[]) {   
82.     int i, j, k, flag = 1;   
83.   
84.     for(i = 0; i < MAX-1 && flag == 1; i++) {   
85.         flag = 0;   
86.         for(j = 0; j < MAX-i-1; j++) {   
87.             if(number[j+1] < number[j]) {   
88.                 SWAP(number[j+1], number[j]);   
89.                 flag = 1;   
90.             }   
91.         }   
92.   
93.         printf("第 %d 次排序：", i+1);   
94.         for(k = 0; k < MAX; k++)   
95.             printf("%d ", number[k]);   
96.         printf("\n");   
97.     }   
98. } 
99. 以上原文出处：http://blog.csdn.net/wuxianglong/article/details/6869115 
100. 
     
101. 
     
102. 区别感悟：
103. 冒泡是说讲前一个与后一个进行比较，进行移动
     选择就是为每个从左到右的位置选择最极值，j=i+1,。（插入位置固定，选择元素位置不固定）
     插入就是每次j=i+1然后向左找，如果比自己大就交换，直到遇到第一个比自己小的停止。
     
     
104. 第二套实现代码：
105. 1、冒泡排序：
106. 1. void BublleSort (int arr [], int count)
        
     2.     {
        
     3.         int i, j, temp;
        
     4.         for(j=0; j<count-1; j ) /* 冒泡法要排序n-1次*/
        
     5.             for(i=0; i<count-j-1; i )/* 值比较大的元素沉下去后，只把剩下的元素中的最大值再沉下去就可以啦 */
        
     6.             {
        
     7.                 if(arr[i]>arr[i 1])/* 把值比较大的元素沉到底 */
        
     8.                 {
        
     9.                     temp=arr[i 1];
        
     10.                     arr[i 1]=arr[i];
         
     11.                     arr[i]=temp;
         
     12.                 }
         
     13.             }
         
     14.     }
     2、插入排序
107. 1. void InsertSort ( int arr[],int count)
        
     2.     {
        
     3.             int i,j,temp;
        
     4.         for(i=1; i<count; i )//数组分两个部分，从第二个数组元素开始
        
     5.         {
        
     6.             temp = arr[i];//操作当前元素，先保存在其它变量中
        
     7.             for(j=i-1; j>-1&&arr[j]>temp;j--)//从当前元素的上一个元素开始查找合适的位置，一直查找到首元素
        
     8.             {
        
     9.                 arr[i] = arr[j];
        
     10.                 arr[j] = temp;
         
     11.             }
         
     12.     }
         
     13. }
     3、选择排序
108. 1. void SelectSort(int arr[], int count)
        
     2.     {
        
     3.         int i,j,min,temp;
        
     4.         for(i=0; i<count; i )
        
     5.             {
        
     6.             min = arr[i];//以此元素为基准
        
     7.             for(j=i 1; j<count; j )//从j往前的数据都是排好的，所以从j开始往下找剩下的元素中最小的
        
     8.             {
        
     9.                 if(min>arr[j])//把剩下元素中最小的那个放到arr[j]中 
        
     10.                 {
         
     11.                     temp = arr[j];
         
     12.                     arr[j] = min;
         
     13.                     min = temp;
         
     14.                 }
         
     15.             }
         
     16.         }
         
     17.     }
     自己要先把他们都敲出来，就先写到这里吧！

109. #include<stdio.h>#define MAXSIZE 5void swap(int *a,int *b){int t;t=*a;*a=*b;*b=t;}void BubbleSort(int a[],int n){//冒泡排序int i,j;for(i=0;i<n-1;i++){for(j=0;j<n-1-i;j++){//j从头向右遍历，n-1-i往左卡一个位置。（也就是最大的不再比较）if(a[j] > a[j+1]){swap(&a[j],&a[j+1]);//每次交换邻近的两个}}}}void SelectSort(int a[],int n){//选择排序int i,j;for(i=0;i<n-1;i++){for(j=i+1;j<n;j++){//j=i+1是核心，j在i后头向右遍历，每次i向右卡一位后j再次遍历。if(a[i] > a[j]){swap(&a[i],&a[j]);}}}}void InsertSort(int a[],int n){//插入排序int i,j;for(i=0;i<n-1;i++){j=i+1;while(a[j-1]>a[j] && j>0){swap(&a[j-1],&a[j]);--j;}//每次j都从i之后的位置开始，j从右向左，直到左边小于右边为止。}}int main(){int a[MAXSIZE]={5,4,3,2,1};int i;InsertSort(a,MAXSIZE);for(i=0;i<MAXSIZE;i++){printf("%d",a[i]);}return 0;}