排序算法复习——交换类排序

在交换类排序算法中，有冒泡排序和快速排序。

冒泡排序：

这个算法大家估计很熟悉了，不做介绍了。

这里有一个算法优化的地方，那就是设置标志位，如果在上一趟的比较当中，没有进行交换的话，就说明已经排好序了，不需要再进行排序了。

演练程序：

1. #include <stdio.h>
   
2. 
   
3. #define N 10
   
4. 
   
5. int main()
   
6. {
   
7.     int a[N] = {62, 48, 35, 77, 55, 14, 35, 98, 22, 10};
   
8.     int tmp, i, j, flag;
   
9. 
   
10.     for(i = 0; i < N; i++) {
    
11.         printf("%d ", a[i]);
    
12.     }
    
13.     printf("\n");
    
14. 
    
15.     flag = 1;
    
16.     /*控制比较的趟数，总共比较N-1趟*/
17.     for(i=0; i < N-1 && flag==1; i++) {
    
18.         flag = 0;
    
19.         /*相邻的两个元素进行比较，把泡泡冒到最底*/
20.         for(j=0; j < N-i-1; j++) {
    
21.             if(a[j] > a[j+1]) {
    
22.                 tmp = a[j+1];
    
23.                 a[j+1] = a[j];
    
24.                 a[j] = tmp;
    
25.                 flag = 1;
    
26.             }
    
27.         }
    
28.     }
    
29. 
    
30.     for(i = 0; i < N; i++) {
    
31.         printf("%d ", a[i]);
    
32.     }
    
33.     printf("\n");
    
34.     return 0;
    
35. }

执行结果：

1. 62 48 35 77 55 14 35 98 22 10
   
2. 10 14 22 35 35 48 55 62 77 98

快速排序：

对于快速排序，一般是这么来设计的：首先保存第一个元素到一个变量x中，让它当作一个枢纽值，然后设置low和high下标分别指向最低处和最高处，总之，在一趟排序之后，x所放的位置要保证x前面的元素比x都小，x之后的元素都比x大就行了。

演练程序：

1. #include <stdio.h>
   
2. 
   
3. #define N 10
   
4. 
   
5. int sort(int *a, int low, int high)
   
6. {
   
7.     int pos, x;
   
8. 
   
9.     x = a[low];
   
10.     while(low < high) {
    
11.         while(low<high && a[high] >= x) {
    
12.             high--;
    
13.         }
    
14.         if(low < high) {
    
15.             a[low] = a[high];
    
16.             low++;
    
17.         }
    
18.         while(low<high && a[low] <= x) {
    
19.             low++;
    
20.         }
    
21.         if(low < high) {
    
22.             a[high] = a[low];
    
23.             high--;
    
24.         }
    
25.     }
    
26.     a[low] = x;
    
27.     pos = low;
    
28.     return pos;
    
29. }
    
30. 
    
31. void quicksort(int *a, int low, int high)
    
32. {
    
33.     int pos;
    
34. 
    
35.     if(low < high) {
    
36.         pos = sort(a, low, high);
    
37.         quicksort(a, low, pos-1);
    
38.         quicksort(a, pos+1, high);
    
39.     }
    
40. }
    
41. 
    
42. int main()
    
43. {
    
44.     int a[N] = {62, 48, 35, 77, 55, 14, 35, 98, 22, 10};
    
45.     int i, j;
    
46. 
    
47.     for(i = 0; i < N; i++) {
    
48.         printf("%d ", a[i]);
    
49.     }
    
50.     printf("\n");
    
51. 
    
52.     quicksort(a, 0, N-1);
    
53. 
    
54.     for(i = 0; i < N; i++) {
    
55.         printf("%d ", a[i]);
    
56.     }
    
57.     printf("\n");
    
58.     return 0;
    
59. }

执行结果：

1. 62 48 35 77 55 14 35 98 22 10
   
2. 10 14 22 35 35 48 55 62 77 98