闲了，再写写排序算法，一个最麻烦的归并排序。

Code:

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. #define MAX_SIZE 10000  
5. /*全局数据结构 
6. */  
7. int num;  
8. int arr[MAX_SIZE];  
9.   
10. //functions  
11. void input();  
12. void print();  
13. void print(int * arr,int len);  
14. void sort(int,int);  
15. int* Merge(int *arr1,int len1,int *arr2 ,int len2);  
16. int* Merge(int first,int last);  
17. void test();  
18.   
19. int main()  
20. {  
21.     input();  
22. //  print();  
23.     //test();  
24.     sort(0,num-1);  
25.     print();  
26.     return 0;  
27. }  
28.   
29. void sort(int first,int last)  
30. {  
31.     if(last > first)  
32.     {  
33.         int mid = (first + last)/2;  
34.         sort(first,mid);  
35.         sort(mid+1,last);  
36.         Merge(first,last);  
37.     }  
38. }  
39.   
40. int* Merge(int first,int last)  
41. {  
42.     int mid = (first + last)/2;  
43.     int i,count = 0;  
44.     int loop ;  
45.     //临时向量  
46.     int size1 = (last - first + 2)/2;  
47.     int size2 = (last - first + 1) -size1;  
48.     int * arr1 = (int *)malloc(sizeof(int) * size1);  
49.     loop = first;  
50.     for(i = 0; i < size1; ++i)  
51.     {  
52.         *(arr1 + i) = arr[loop];  
53.         ++loop;  
54.     }  
55.     int * arr2 = (int *)malloc(sizeof(int) * size2);   
56.     loop = first + size1;  
57.     for(i = 0; i < size2; ++i)  
58.     {  
59.         *(arr2 + i) = arr[loop];  
60.         ++loop;  
61.     }  
62.     int * tmparr = Merge(arr1,size1,arr2,size2);  
63.     for(i = first;i <= last; ++i)  
64.     {  
65.         arr[i] = *(tmparr+count);  
66.         ++ count;  
67.     }  
68.     //释放向量占用的空间  
69.     free(tmparr);  
70.   
71.     return arr;  
72. }  
73.   
74. int* Merge(int *arr1,int len1,int *arr2 ,int len2)  
75. {  
76.     int len = len1 + len2;      //新分配的数组的长度  
77.     int * arr = (int *)malloc(sizeof(int) * len);  
78.     int pos1 = 0,pos2 = 0;  // 记录两个数组的要进行比较的数字的位置  
79.     int pos;  
80.     for(pos = 0; pos < len; ++pos)  
81.     {  
82.         //两个向量都有数据时  
83.         if(pos1 < len1 && pos2 <len2)  
84.         {  
85.             if( *(arr1+pos1) <= *(arr2 + pos2) )  
86.             {  
87.                 *(arr+pos) = *(arr1 + pos1);  
88.                 ++pos1;  
89.             }  
90.             else  
91.             {  
92.                   
93.                 *(arr+pos) = *(arr2 + pos2);  
94.                 ++pos2;  
95.             }  
96.         }  
97.         else  
98.         //此时，只有一个向量有数据  
99.         {  
100.             //向量1有数据时  
101.             if(pos1 < len1)  
102.             {  
103.                 for(;pos < len; ++pos)  
104.                 {  
105.                     *(arr+pos) = *(arr1+pos1);  
106.                     ++pos1;  
107.                 }  
108.             }  
109.             //向量2有数据时  
110.             else  
111.             {  
112.                 for(;pos < len; ++pos)  
113.                 {  
114.                     *(arr+pos) = *(arr2+pos2);  
115.                     ++pos2;  
116.                 }  
117.             }  
118.         }  
119.     }  
120.     //释放向量占用的空间  
121.     free(arr1);  
122.     free(arr2);  
123.     return arr;  
124. }  
125.   
126. void input()  
127. {  
128.     scanf("%d",&num);  
129.     int i;  
130.     for(i = 0; i < num; ++i)  
131.     {  
132.         scanf("%d",arr+i);  
133.     }  
134.     getchar();  
135. }  
136.   
137. void print()  
138. {  
139.     int i;  
140.     for(i = 0; i < num; ++i)  
141.     {  
142.         printf("%d/n",*(arr+i));  
143.     }     
144. }  
145.   
146. void print(int * arr,int len)  
147. {  
148.     int i;  
149.     for(i = 0; i < len; ++i)  
150.     {  
151.         printf("%d/n",*(arr+i));  
152.     }     
153. }  
154.   
155. void test()  
156. {  
157.     int * arr1 = (int *)malloc(sizeof(int) * 6);  
158.     int * arr2 = (int *)malloc(sizeof(int) * 8);  
159.     int i;  
160.     for(i = 0; i < 6; ++i)  
161.     {  
162.         *(arr1+i) = rand() % 30;  
163.         if(i>0)  
164.         {  
165.             if(*(arr1+i) < *(arr1+i-1) )  
166.             {  
167.                 --i;  
168.             }  
169.         }  
170.     }  
171.     for(i = 0; i < 8; ++i)  
172.     {  
173.         *(arr2+i) = rand() % 43;  
174.         if(i>0)  
175.         {  
176.             if(*(arr2+i) < *(arr2+i-1) )  
177.             {  
178.                 --i;  
179.             }  
180.         }  
181.     }  
182.     print(Merge(arr1,6,arr2,8),14);;  
183.   
184. }