常用排序算法实现(C语言)

排序算法原理都不难，实现起来却没那么简单，特别是一些边界问题的处理。
前些天把这些常有的排序算法实现了一遍，代码写的也不太好，很多i,j,k之类的变量，也很多循环嵌套，不过初步测试是正确的。

  1 #include <stdio.h>
  2 
  3 void swap(int *a, int *b);        //交换两个整数
  4 void output_arr(int arr[], int n);    //输出数组
  5 
  6 void strai_sort(int arr[], int n);    //直接插入排序
  7 void bubble_sort(int arr[], int n);    //冒泡排序
  8 
  9 int  qpass(int arr[], int i, int j);    //一趟快速排序
 10 void qsort(int arr[], int s, int t);    //快速排序
 11 
 12 void sift(int arr[], int n, int k);        //堆排序一趟筛选
 13 void makeheap(int arr[], int n);        //建堆
 14 void heapsort(int arr[], int n);        //堆排序
 15 
 16 void merge(int arr[], int low, int mid, int high);    //合并
 17 void mergesort(int arr[], int low, int high);        //归并排序
 18 
 19 
 20 static int temp[100];
 21 
 22 int main(int argc, char **argv)
 23 {
 24     int arr[] = {28, 40, 19, 20, 98, 74, 1, 40, 10, 35};
 25 
 26     printf("before sort:");
 27     output_arr(arr, sizeof(arr)/sizeof(arr[0]));
 28 
 29     //strai_sort(arr, sizeof(arr)/sizeof(arr[0]));
 30     //bubble_sort(arr, sizeof(arr)/sizeof(arr[0]));
 31     //qsort(arr, 0, sizeof(arr)/sizeof(arr[0])-1);    
 32     //heapsort(arr, sizeof(arr)/sizeof(arr[0]));    
 33     mergesort(arr, 0, sizeof(arr)/sizeof(arr[0])-1);
 34 
 35     printf("after sort:");
 36     output_arr(arr, sizeof(arr)/sizeof(arr[0]));    
 37 
 38     return 0;
 39 }
 40 
 41 void swap(int *a, int *b)
 42 {
 43     int temp;
 44     temp = *b;
 45     *b = *a;
 46     *a = temp;
 47 }
 48 
 49 void output_arr(int arr[], int n)
 50 {
 51     int i;
 52     for (i=0; i<n; ++i)
 53         printf("%d  ", arr[i]);
 54     printf("\n");
 55 }
 56 
 57 /*
 58  * 直接插入排序
 59  * 思想: 依次把 无序序列里的值 插入 到有序序列里；初始时，有序序列为arr[0]，无序序列为arr[1]arr[n-1]
 60  * 这种算法要不断的比较、移动数据，性能很差
 61  */
 62 void strai_sort(int arr[], int n)
 63 {
 64     int i,j,k;
 65     int temp;
 66 
 67     for (i=1; i<n; ++i)
 68     {
 69         temp = arr[i];  //记录下要插入的值为temp
 70         for (j=0; j<i; ++j)
 71         {
 72             if (temp < arr[j])  //如果有序序列arr[0]arr[i-1]里存在比temp大的值，这个值的索引为j
 73             {               //把arr[j]arr[i-1]向后移动，把temp插入到arr[j]的位置上
 74                 for (k=i; k>j; k--)
 75                 {
 76                     arr[k] = arr[k-1];
 77                 }
 78                 arr[j] = temp;
 79                 break;
 80             }
 81         }
 82     }        
 83 }
 84 
 85 /*
 86  * 冒泡排序原理：
 87  * 对n个整数，将最大数放到最后，即第n个位置
 88  * 然后剩余n-1个数，把剩余n-1个数中最大的放到最后，即第n-1个位置
 89  * 依次对前n-2 n-3个数处理，最后得到有序序列
 90  */
 91 void bubble_sort(int arr[], int n)
 92 {
 93     int i,j;
 94     for (i=0;i<n;++i)
 95     {
 96         for (j=1;j<n-i;++j)  //把arr[0]arr[n-i]中的最大值，放到n-i位置上
 97         {                //把这段代码抽象为一个函数会更简单    
 98             if (arr[j-1]>arr[j])
 99                 swap(&arr[j-1],&arr[j]);
100         }
101     }
102 }
103 
104 /*
105  * 一趟快速排序：
106  * 这里选择开始位置整数为标点，即第i个元素为标点
107  * 从后向前，找到比标点小的元素，跟标点交换位置；然后再从前向后，找到比标点大的元素后，跟标点交换位置
108  * 即不断把比标点小的元素移动标点左边，比标点大的元素移到标点右边
109  * 一趟快速排序快速排序后，标点元素就在一个正确位置上
110  */
111 int qpass(int arr[], int i, int j)
112 {
113     while (i<j)
114     {
115         while (j > i)
116         {
117             if (arr[j]<arr[i])
118             {
119                 swap(&arr[i],&arr[j]);
120                 i += 1;
121                 break;
122             }
123             j -= 1;
124         }
125         while (i < j)
126         {
127             if (arr[i]>arr[j])
128             {
129                 swap(&arr[i],&arr[j]);
130                 j -= 1;
131                 break;
132             }
133             i += 1;
134         }
135     }
136 
137     return i;
138 }
139 
140 void qsort(int arr[], int s, int t)
141 {
142     int pos;
143     if (s<t)
144     {
145         pos = qpass(arr, s, t);
146         qsort(arr,s,pos-1);
147         qsort(arr,pos+1,t);
148     }
149 }
150 
151 /*
152  * 堆排序
153  */
154 
155 //arr[k+1]arr[n-1]满足大顶堆的性质
156 //新元素arr[k]，左右孩子分别为arr[2*k+1]、arr[2*k+2]
157 //交换arr[k]和其左右孩子中较大的值，直到比其左右孩子都大 或者 到了序列边界
158 void sift(int arr[], int n, int k)
159 {
160     int i = k;
161     int j = 2i+1;
162     int flag = 0;
163 
164     while (j<n && !flag)
165     {
166         if ( j+1<n && arr[j+1]>arr[j] )
167             j += 1;
168         if ( arr[i]>=arr[j] )
169             flag = 1;
170         else
171         {
172             swap(&arr[i],&arr[j]);
173             i = j;
174             j = 2*i+1;
175         }
176     }
177 }
178 //对数组arr建堆
179 //初始时，arr[n/2]arr[n-1]都是叶子节点，即arr[n/2]arr[n-1]满足大顶堆的性质
180 void makeheap(int arr[], int n)
181 {
182     int i;
183     for (i=n/2-1; i>=0; i--)
184         sift(arr, n, i);
185 }
186 
187 void heapsort(int arr[], int n)
188 {
189     int i;
190 
191     makeheap(arr, n);
192 
193     for (i=n-1; i>0; i--)
194     {
195         swap(&arr[0],&arr[i]);
196         sift(arr, i-1, 0);
197     }
198 }
199 
200 /*
201  *arr[low]arr[mid] arr[mid+1]arr[high]为有序序列
202  * 合并这两个有序子序列为一个有序序列 
203  */
204 void merge(int arr[], int low, int mid, int high)
205 {
206     int i = low;
207     int j = mid+1;
208     int k;
209 
210     for(k=low; k<=high; k++)
211     {
212         temp[k] = arr[k];
213     }
214 
215     k = low;
216 
217     while ( i<=mid && j<=high )
218     {
219         if (temp[i]<temp[j])
220             arr[k++] = temp[i++];
221         else
222             arr[k++] = temp[j++];
223     }
224     while ( i<=mid )
225     {
226         arr[k++] = temp[i++];
227     }
228     while ( j<=high )
229     {
230         arr[k++] = temp[j++];
231     }
232 }
233 
234 /*
235  * 归并排序原理:
236  * 把一个无序序列中的每个元素视为有序子序列，把这些子序列两两合并成有序子序列
237  */
238 void mergesort(int arr[], int low, int high)
239 {
240     int mid;
241     if (low<high)
242     {
243         mid = (low+high)/2;
244         mergesort(arr, low, mid);
245         mergesort(arr, mid+1, high);
246         merge(arr, low, mid, high);
247     }
248 }
249