冒泡法，熟悉熟悉

[cpp]  view plain  copy

1. 1）“冒泡法”   
2. 冒泡法大家都较熟悉。其原理为从a[0]开始，依次将其和后面的元素比较,  
3. 若a[0]>a[i]，则交换它们，一直比较到a[n]。  
4. 同理对a[1],a[2],...a[n-1]处理，即完成排序。   
5.   
6. void bubble(int *a,int n)   /*定义两个参数：数组首地址与数组大小*/   
7. {   
8.     int i,j,temp;   
9.     for(i=0;i<n-1;i++)   
10.         for(j=i+1;j<n;j++)           /*注意循环的上下限*/   
11.             if(a[i]>a[j])   
12.                 {   
13.                     temp=a[i];   
14.                     a[i]=a[j];   
15.                     a[j]=temp;   
16.                 }  
17. }   
18.   
19. 冒泡法原理简单，但其缺点是交换次数多，效率低。   
20.   
21. 下面介绍一种源自冒泡法但更有效率的方法“选择法”。  
22.    
23. （2）“选择法”   
24. 选择法循环过程与冒泡法一致，它还定义了记号k=i  
25. 然后依次把a[k]同后面元素比较，若a[k]>a[j],则使k=j.  
26. 最后看看k=i是否还成立，不成立则交换a[k],a[i]  
27. 这样就比冒泡法省下许多无用的交换，提高了效率。   
28.   
29. void choise(int *a,int n)   
30. {   
31.     int i,j,min,temp;   
32.     for(i=0;i<n-1;i++)   
33.     {   
34.         min=i;                                              /*给记号赋值*/   
35.         for(j=i+1;j<n;j++)   
36.         {  
37.             if(a[min]>a[j])   
38.                 min=j;                                      /*是k总是指向最小元素*/   
39.         }  
40.         if(i!=min)   
41.         {                                                       /*当k!=i是才交换，否则a[i]即为最小*/   
42.                 temp=a[i];   
43.                 a[i]=a[min];   
44.                 a[min]=temp;   
45.         }   
46.     }   
47. }   
48. 选择法比冒泡法效率更高，但说到高效率，非“快速法”莫属，现在就让我们来了解它。   
49.   
50. （3）“快速法”   
51. 快速法定义了三个参数,（数组首地址*a,要排序数组起始元素下标i,要排序数组结束元素下标j).  
52. 它首先选一个数组元素（一般为a[ (i+j)/2 ],即中间元素）作为参照,把比它小的元素放到它的左边，比它大的放在右边。  
53. 然后运用递归，在将它左，右两个子数组排序，最后完成整个数组的排序。  
54. 下面分析其代码：   
55.   
56. void quick(int *a,int i,int j)   
57. {   
58.     int m,n,temp;   
59.     int k;   
60.     m=i;   
61.     n=j;   
62.     k=a[(i+j)/2]; /*选取的参照*/   
63.     do   
64.     {   
65.         while(  a[m]<k && m<j  )   
66.             m++;                                            /* 从左到右找比k大的元素*/   
67.               
68.         while( a[n] >k && n>i )   
69.           n--;                                          /* 从右到左找比k小的元素*/   
70.           
71.         if(m<=n)   
72.         {                                                   /*若找到且满足条件，则交换*/   
73.                 temp=a[m];  
74.                 a[m]=a[n];  
75.                 a[n]=temp;  
76.                 m++;  
77.                 n--;  
78.         }  
79.     }  
80.     while(m<=n);   
81.           
82.     if(m<j)   
83.         quick(a,m,j);                           /*运用递归*/   
84.           
85.     if(n>i)   
86.         quick(a,i,n);   
87. }   
88.   
89. （4）“插入法”   
90. 插入法是一种比较直观的排序方法。  
91. 它首先把数组头两个元素排好序，再依次把后面的元素插入适当的位置。  
92. 把数组元素插完也就完成了排序。   
93.   
94. void insert(int *a,int n)   
95. {   
96.     int i,j,temp;   
97.     for(i=1;i<n;i++)   
98.     {   
99.         temp=a[i];                          /*temp为要插入的元素*/   
100.         j=i-1;   
101.           
102.         while( j>=0&&temp<a[j] )   
103.         {                                           /*从a[i-1]开始找比a[i]小的数，同时把数组元素向后移*/   
104.             a[j+1]=a[j];   
105.             j--;   
106.         }   
107.         a[j+1]=temp; /*插入*/   
108.     }   
109. }   
110.   
111. （5）“shell法”   
112. shell法是一个叫 shell 的美国人与1969年发明的。  
113. 它首先把相距k(k>=1)的那几个元素排好序，再缩小k值（一般取其一半），再排序，直到k=1时完成排序。  
114. 下面让我们来分析其代码：   
115.   
116. void shell(int *a,int n)   
117. {   
118.     int i,j,k,x;   
119.     k=n/2;                                          /*间距值*/   
120.     while(k>=1)   
121.     {   
122.         for(i=k;i<n;i++)   
123.         {   
124.             x=a[i];   
125.             j=i-k;   
126.             while(j>=0&&x<a[j])   
127.             {   
128.                 a[j+k]=a[j];   
129.                 j-=k;   
130.             }   
131.                 a[j+k]=x;   
132.         }   
133.         k/=2;                                       /*缩小间距值*/   
134.     }   
135. }   

http://814193594.blog.51cto.com/10729329/1715944

冒泡排序（bubble sort）算法的运作如下：从前往后一次比较相邻的两个元素，如果第二个比第一个元素小，则交换这两个元素，一直到与最后一个元素比较完成，这样最大的元素就放到了最后；这样重复比较（n-1）次即可完成排序。

------------------------------------------------------------------------------------------------------

      快速排序（quicksort）算法（冒泡排序的一种优化）：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

                                                                                                         

      设置标志位（sign）（冒泡排序的另一种优化方法）每一趟比较完成后，看元素是否进行交换，如果有，则继续下一次循环，如果没有则结束循环。

 

    “设置标志位”这种方法没有“快速排序算法”效率高。

------------------------------------------------------------------------------------------------------

 

 C语言代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111

/* ** bubble sort */  void  bubble_sort( int  *str,  int  size) {       int  i = 0, j = 0;       int  tmp = 0;              /*       ** 进行size-1趟排序；       */       for  (i = 0; i < size - 1; i++)       {           /*           ** 每排序一趟，将最大的元素沉底。下一趟少比较i次；           */              for  (j = 0; j < size - 1 - i; j++)                   {                 if  (str[j] > str[j + 1])                 {                      tmp = str[j];                      str[j] = str[j + 1];                      str[j + 1] = tmp;                 }            }         } }   /* ** 优化一：设置一个标志位sign的bubble sort； */   void  bubble_sort( int  *str,  int  size) {       int  i = 0, j = 0;       int  tmp = 0, sign = 0;              for  (i = 0; i < size - 1; i++)       {            /*            ** 每趟排序前将sign置为0，如果相邻元素进行了交换则sign>1;            ** 否则，sign==0，没有进行交换，排序完成，跳出循环；            */            flag = 0;            for  (j = 0; j < size - 1 - i; j++)            {                 if  (str[j] > str[j + 1])                 {                      tmp = str[j];                      str[j] = str[j + 1];                      str[j + 1] = tmp;                      sign++;                 }            }            if  (0 == sign)            break ;       } }     /* ** 优化二：quick sort； */ void  quicksort( int  *str,  int  left,  int  right) {       assert (str);              /*       **如果左边大于或等于右边，则该数组已经排序完成；       */       if  (left >= right)       {            return ;       }              int  i = left;       int  j = right;       int  key = str[left];              /*       **当i=j时，一趟排序完成，将所有数分为一大一小两组；       */       while  (i < j)       {            /*            **第一次从后向前遍历，遇到第一个比key小的交换两数位置；            */            while  ((i < j) && (key <= str[j]))            {                 j--;            }            str[i] = str[j];                        /*            **第二次从前向后遍历，遇到第一个比key大的交换两数位置；            */            while  ((i < j) && (key >= str[i]))            {                 i++;            }            str[j] = str[i];       }              str[i] = key;       /*       **递归调用，完成左、右子序列的排序；       */       quicksort(str, left, i - 1);       quicksort(str, i + 1, right); }