C语言的冒泡排序法改进

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. //冒泡排序  
5. void BubbleSort(int *array,int n)  
6. {  
7.     int temp;  
8.     for (int i=n-1;i>0;i--)  
9.     {  
10.         for (int j=0;j<i;j++)  
11.         {  
12.             if (*(array+j)>*(array+j+1))  
13.             {  
14.                 temp=*(array+j);  
15.                 *(array+j)=*(array+j+1);  
16.                 *(array+j+1)=temp;  
17.             }  
18.         }  
19.     }  
20. }  
21. //改进的冒泡排序，在一次冒泡的过程中，如果没有发生交换，则已经有序  
22. void ImprovedBubbleSort(int *array,int n)  
23. {  
24.     int flag,temp;  
25.     for (int i=n-1;i>0;i--)  
26.     {  
27.         flag=0;//每次冒泡前将flag置0  
28.         for (int j=0;j<i;j++)  
29.         {  
30.             if (*(array+j)>*(array+j+1))  
31.             {  
32.                 temp=*(array+j);  
33.                 *(array+j)=*(array+j+1);  
34.                 *(array+j+1)=temp;  
35.                 flag=1;//只要发生了一次交换，flag置1  
36.             }  
37.         }  
38.         //在一次冒泡过程后，flag依然为0，表示未发生交换，则排序结束  
39.         if (0==flag)  
40.         {  
41.             break;  
42.         }  
43.     }  
44. }  
45.   
46. //进一步改进的冒泡排序，如果在某次冒泡过程中，最后一次进行交换的位置为flag，则  
47. //表示flag之后的序列已经有序，那么下一次冒泡就无需比较flag之后的序列，即只要比  
48. //较到flag就可以结束此次冒泡过程。当flag=0时，表示某趟冒泡没有发生交换，即可结束。  
49. void BetterBubbleSort(int *array,int n)  
50. {  
51.     int temp,flag,bound=n-1;//bound记录每趟冒泡的边界  
52.     while (bound!=0)  
53.     {  
54.         flag=0;//flag初始置为0，一趟冒泡后如果flag仍然为0，则已经有序，排序结束  
55.         for (int j=0;j<bound;j++)  
56.         {  
57.             if (*(array+j)>*(array+j+1))  
58.             {  
59.                 temp=*(array+j);  
60.                 *(array+j)=*(array+j+1);  
61.                 *(array+j+1)=temp;  
62.                 flag=j;//flag用于记录一次冒泡过程中最后一次交换的位置  
63.             }  
64.         }  
65.         bound=flag;  
66.     }  
67. }  
68.   
69. //双向冒泡排序，一次冒泡的过程中，分别将最大的记录和最小的记录都放到最终的位置  
70. void DoubleBubbleSort(int *array,int n)  
71. {  
72.     int temp,j;  
73.     int maxFlag,minFlag;//分别作为双向冒泡的标志  
74.     int maxBound=n-1,minBound=0;//分别记录最大和最小的边界  
75.     while (maxBound>minBound)  
76.     {  
77.         //初始将标志位置为0，某次交换过程后标志位依然为0，则排序结束  
78.         maxFlag=0;  
79.         minFlag=0;  
80.         //此次交换将最大值下沉  
81.         for (j=minBound;j<maxBound;j++)  
82.         {  
83.             if (*(array+j)>*(array+j+1))  
84.             {  
85.                 temp=*(array+j);  
86.                 *(array+j)=*(array+j+1);  
87.                 *(array+j+1)=temp;  
88.                 maxFlag=j;//记录下沉过程中最后一次交换的位置  
89.             }  
90.         }  
91.         //下沉的过程没有发生交换，排序结束  
92.         if (0==maxFlag)  
93.         {  
94.             break;  
95.         }  
96.         //下沉过程结束后，重新设置下边界（最大有序边界）  
97.         maxBound=maxFlag;  
98.         //此次交换将最小值上浮  
99.         for (j=maxBound;j>minBound;j--)  
100.         {  
101.             if (*(array+j)<*(array+j-1))  
102.             {  
103.                 temp=*(array+j);  
104.                 *(array+j)=*(array+j-1);  
105.                 *(array+j-1)=temp;  
106.                 minFlag=j;//记录上浮过程中最后一次交换的位置  
107.             }  
108.         }  
109.         //上浮的过程没有发生交换，排序结束  
110.         if (0==minFlag)  
111.         {  
112.             break;  
113.         }  
114.         //上浮过程结束后，重新设置上边界（最小有序边界）  
115.         minBound=minFlag;  
116.     }  
117. }  
118.   
119.   
120. int main(int argc, char* argv[])  
121. {  
122.     int array[8]={5,9,2,16,7,4,12,15};  
123.     int i;  
124.     printf("Before Sort: ");  
125.     for (i=0;i<8;i++)   
126.     {  
127.         printf("%2d ",array[i]);  
128.     }  
129.   
130.     //BubbleSort(array,8);  
131.     //ImprovedBubbleSort(array,8);  
132.     //BetterBubbleSort(array,8);  
133.     DoubleBubbleSort(array,8);  
134.   
135.     printf("\n After Sort: ");  
136.     for (i=0;i<8;i++)   
137.     {  
138.         printf("%2d ",array[i]);  
139.     }  
140.     printf("\n");  
141.     return 0;  
142. }