c语言排序

1. #include <stdio.h>  
2.   
3. void swap(int *a, int *b);  
4. void bubble_sort(int a[], int n);  
5. void select_sort(int a[], int n);  
6. void insert_sort(int a[], int n);  
7. void shell_sort(int a[], int n);  
8. void heap_adjust(int a[], int i, int n);  
9. void heap_sort(int a[], int n);  
10. void quick_sort(int a[], int low, int high);  
11.   
12. int main()  
13. {  
14. //    int arr[] = {0,2,3,1,6,9,8,7,4,5};  
15.     int arr[1000];  
16.     int n,m;   
17.     printf("请输入你排序的数字个数：\n");  
18.     scanf("%d",&n);  
19.     printf("请输入你排序的%d个数字:\n",n);  
20.     for(int i=0;i<n;i++)  
21.          scanf("%d",&arr[i]);  
22.       printf("请输入你所使用的排序方法(数字)：\n1 冒泡排序\n2 选择排序\n3 插入排序\n4 希尔排序\n5 堆排序\n6 快速排序\n");  
23.       scanf("%d",&m);  
24.     switch(m){  
25.         case 1:  
26.      bubble_sort(arr, n);  
27.      break;  
28.         case 2:  
29.       select_sort(arr, n);  
30.       break;  
31.         case 3:  
32.     insert_sort(arr, n);  
33.       break;  
34.         case 4:  
35.     shell_sort(arr, n);  
36.      break;  
37.         case 5:  
38.     heap_sort(arr, n);  
39.     break;  
40.         case 6:  
41.     quick_sort(arr, 0, n-1);  
42.       break;  
43.   }  
44.       
45.     for (int i = 0; i < n; i++)  
46.     {  
47.         printf("%d\n", arr[i]);  
48.     }  
49.       
50.     return 0;  
51. }  
52.   
53. //交換數據  
54. void swap(int *a, int *b)  
55. {  
56.     int tmp = *a;  
57.     *a = *b;  
58.     *b = tmp;  
59. }  
60.   
61. //冒泡排序法  
62. //時間複雜度O(n^2) 空間複雜度O(1)  
63. void bubble_sort(int a[], int n)  
64. {  
65.     int i, j;  
66.     //旗幟位，判斷這次遍歷是否有交換  
67.     int flag = 1;  
68.       
69.     for (i = 0; i < n && flag; i++)  
70.     {  
71.         flag = 0;  
72.         for (j = n-2 ; j >= i; j--)  
73.         {  
74.             if (a[j] > a[j+1])  
75.             {  
76.                 swap(&a[j], &a[j+1]);  
77.                 flag = 1;  
78.             }  
79.         }  
80.     }  
81. }  
82.   
83. //簡單選擇排序  
84. //時間複雜度O(n^2) 空間複雜度O(1)  
85. void select_sort(int a[], int n)  
86. {  
87.     int i, j, min;  
88.       
89.     for (i = 0; i < n ; i++)  
90.     {  
91.         min = i;  
92.         for (j = i+1; j < n; j++)  
93.         {  
94.             if (a[j] < a[min])  
95.             {  
96.                 min = j;  
97.             }  
98.         }  
99.         if (min != i)  
100.         {  
101.             swap(&a[min], &a[i]);  
102.         }  
103.     }  
104. }  
105.   
106. //直接插入排序  
107. //時間複雜度O(n^2) 空間複雜度O(1)  
108. void insert_sort(int a[], int n)  
109. {  
110.     for (int i = 0; i < n ; i++)  
111.     {  
112.         int temp = a[i];  
113.         int j = i-1;  
114.         while (j>=0 && a[j] > temp)  
115.         {  
116.             a[j+1] = a[j];  
117.             j--;  
118.         }  
119.         a[j+1] = temp;  
120.     }  
121. }  
122.   
123. //希爾排序  
124. //時間複雜度為O(nlogn) 空間複雜度為O(1)  
125. void shell_sort(int a[], int n)  
126. {  
127.     int i,j,temp;  
128.     int gap = 0;  
129.     while (gap <= n) gap = gap*3+1;  
130.     while (gap > 0)  
131.     {  
132.         for (i = gap; i < n; i++)  
133.         {  
134.             temp = a[i];  
135.             j = i - gap;  
136.             while (j >= 0 && a[j] > temp)  
137.             {  
138.                 a[j+gap] = a[j];  
139.                 j = j - gap;  
140.             }  
141.             a[j+gap] = temp;  
142.         }  
143.         gap = (gap-1)/3;  
144.     }  
145. }  
146.   
147. //堆排序  
148. //時間複雜度為O(nlogn) 空間複雜度為O(1)  
149. void heap_sort(int a[], int n)  
150. {  
151.     for (int i = n/2 - 1; i >= 0; i--)  
152.     {  
153.         heap_adjust(a, i, n);  
154.     }  
155.     for (int i = n-1; i > 0; i--)  
156.     {  
157.         swap(&a[0], &a[i]);  
158.           
159.         heap_adjust(a, 0, i);  
160.     }  
161. }  
162.   
163. //構建大頂堆  
164. void heap_adjust(int a[], int i, int n)  
165. {  
166.     int child, temp;  
167.       
168.     for (temp = a[i]; 2*i+1 < n; i = child)  
169.     {  
170.         child = 2*i+1;  
171.         //取得較大子結點索引  
172.         if (child < n -1 && a[child] < a[child+1]) child++;  
173.         //保證父結點大於等於子結點  
174.         if (temp < a[child]) swap(&a[i], &a[child]);  
175.         else break;  
176.     }  
177. }  
178.   
179. //快速排序  
180. //時間複雜度為O(nlogn) 空間複雜度為O(logn) ~ O(n)  
181. void quick_sort(int a[], int low, int high)  
182. {  
183.     int i = low+1;  
184.     int j = high;  
185.     int key = a[low];  
186.       
187.     if (low >= high) return;  
188.       
189.     while (1) {  
190.         while (key<a[j]) j--;  
191.         while (key>a[i] && i<j) i++;  
192.         if (i >= j) break;  
193.           
194.         swap(&a[i], &a[j]);  
195.           
196.         if (a[i] == key) j--;  
197.         else i++;  
198.     }  
199.       
200.     swap(&a[low], &a[j]);  
201.       
202.     if (i-1>low) quick_sort(a, low, i-1);  
203.     if (j+1<high) quick_sort(a, j+1, high);  
204. }