C++实现直接插入排序，折半插入排序，希尔排序，冒泡排序，简单选择排序，快速排序，堆排序

转自：http://blog.csdn.net/yushuai007008/article/details/7163062

如有不足之处，还望指正！ 

[cpp]  view plain copy

1. // Sort.cpp : 定义控制台应用程序的入口点。  
2. //  
3.   
4. #include "stdafx.h"  
5. #include <iostream>  
6.   
7. using namespace std;  
8.   
9. #define MAXSIZE 30//一个用作示例的小顺序表的最大长度  

[cpp]  view plain copy

1. /************************************************************************ 
2. 方法：直接插入排序 
3. 说明：将数组的第一个元素r[0]当做哨兵单元，不存储有效数字                                                                  
4. ************************************************************************/  
5. void InsertSort(int r[],int n)  
6. {//作直接插入排序  
7.     int i,j;  
8.     for(i=2;i<=n;i++)  
9.     {   
10.         r[0]=r[i];      //r[0]用作哨兵单元,  
11.         j=i-1;  
12.         while(r[0]<r[j]) //这样j最小值为0  
13.         {   
14.             r[j+1]=r[j];    //记录后移  
15.             j--;  
16.         }//while  
17.         r[j+1]=r[0];        //插入到正确位置  
18.         for(j=1;j<=n;j++)    //输出每趟排序的结果  
19.         {  
20.             cout << r[j] << " ";    
21.         }//for  
22.         cout << endl;  
23.     }//for  
24. }//InsertSort  

[cpp]  view plain copy

1. /************************************************************************ 
2. 方法：折半插入排序（Binary Insert Sort） 
3. 说明：将数组的第一个元素r[0]当做哨兵单元，不存储有效数字 ，与直接插入排序相比， 
4.       比较才次数减少，但移动元素的次数并没有减少。 
5. ************************************************************************/  
6. void BinaryInsertSort(int r[],int n)  
7. {//作直接插入排序  
8.     int i, low, high, mid;  
9.     for( i = 2; i <= n; i++)  
10.     {   
11.         r[0] = r[i];        //r[0]用作哨兵单元,  
12.         low = 1;   
13.         high = i-1;  
14.         while(low <= high)   
15.         { //寻找插入点，high之后的元素都需要后移  
16.             mid = (low + high)/2;  
17.             if (r[mid] > r[0])  
18.             {  
19.                 high = mid - 1;  
20.             }  
21.             else  
22.             {  
23.                 low = mid + 1;  
24.             }  
25.         }  
26.         for (int j = i - 1; j > high; j--  )  
27.         {  
28.             r[j+1] = r[j];  //记录后移  
29.         }  
30.         r[high + 1] = r[0];     //插入到正确位置  
31.         for(int j = 1; j <= n; j++)  //输出每趟排序的结果  
32.         {  
33.             cout << r[j] << " ";    
34.         }  
35.         cout << endl;  
36.     }  
37. }  

[cpp]  view plain copy

1. /************************************************************************ 
2. 方法：希尔（Shell's Sort)排序 
3. 说明：将数组的第一个元素r[0]当做哨兵单元，不存储有效数字  
4.       先将待排序的记录按一定的增量分成若干组，分别进行直接插入排序， 
5.       增量减小，再进行直接插入排序，循环至增量为1，则待排序序列此时有序 
6. ************************************************************************/  
7. void ShellSort(int r[],int n)  
8. {  
9.     for (int d = 10; d != 1;)  
10.     {  
11.         d = d/2;  //增量序列可以去不同的值，这里取5、2、1（应使增量序列中的值没有除1以外的  
12.                   //公因子，并且最后一个增量值必须为1。  
13.         int i,j;  
14.   
15.         for(i = 1 + d; i <= n; i++)  
16.         {   
17.             r[0] = r[i];  
18.             j = i-d;  
19.             while( r[0] < r[j])   
20.             {   
21.                 r[j+d] = r[j];  //记录后移  
22.                 j -= d;  
23.             }  
24.             r[j+d]=r[0];        //插入到正确位置  
25.         }  
26.         for(j = 1; j <= n; j++)  //输出每趟排序的结果  
27.         {  
28.             cout << r[j] << " ";    
29.         }  
30.         cout << endl;  
31.     }  
32. }  

[cpp]  view plain copy

1. /************************************************************************ 
2. 方法：冒泡排序（交换排序的一种）（Bubble Sort） 
3. 说明：相邻的元素作比较，将较大元素向后移，第一趟将最大元素移至最末尾， 
4.       第二趟将次大元素移至倒数第二位。（注意：此处应用的这个数组下标从1开始计算） 
5. ************************************************************************/  
6. void BubbleSort(int r[],int n)  
7. {  
8.     for (int i = 1; i < n; i++)  
9.     {  
10.         for (int j = 1; j <= n - i; j++)  
11.         {  
12.             if (r[j] > r[j + 1])  
13.             {  
14.                 int temp = r[j];  
15.                 r[j] = r[j + 1];  
16.                 r[j + 1] = temp;  
17.             }  
18.         }  
19.         //输出一趟排序的结果  
20.         for (int i = 1; i <= n; i++)  
21.         {  
22.             cout << r[i] << " ";  
23.         }  
24.         cout << endl;  
25.     }  
26. }  

[cpp]  view plain copy

1. /************************************************************************ 
2. 方法：快速排序（Quick Sort） 
3. 说明：通过一趟排序将待排记录分割成独立的两部分，其中一部分的关键字均比另一部分的关键字 
4.       小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。 
5. ************************************************************************/  
6. void QSort(int r[], int low, int high)  
7. {  
8.     if (low < high)  
9.     {  
10.         int i = low, j = high;  
11.   
12.         r[0] = r[i];   //用子表的r[0]位置存储枢轴记录  
13.           
14.         while (i < j)  
15.         {//循环结束后，i，j指向同一个位置，这个位置的左面比枢轴元素小  
16.          //右面比枢轴元素大  
17.             while (i < j && r[j] >= r[0])  
18.             {//从后往前找，找到下一个比枢轴元素小的  
19.                 j--;  
20.             }  
21.             r[i] = r[j];// 将其放到r[i]位置  
22.   
23.             while (i < j && r[i] <= r[0])  
24.             {//从前往后找，找到下一个比枢轴元素大的  
25.                 i++;  
26.             }  
27.             r[j] = r[i];//将其放到r[j]位置  
28.         }  
29.         r[i] = r[0];  //将枢轴元素放到i和j共同指向的那个位置（此时i==j）  
30.           
31.         //递归排序枢轴的左右两部分  
32.         QSort(r, low, i - 1);  
33.         QSort(r, i + 1, high);  
34.     }  
35. }  
36.   
37. void QuickSort(int r[],int n)  
38. {  
39.     QSort(r, 1, n);  
40.     //输出排序后的结果  
41.     for (int i = 1; i <= n; i++)  
42.     {  
43.         cout << r[i] << " ";  
44.     }  
45.     cout << endl;  
46. }  

[cpp]  view plain copy

1. /************************************************************************ 
2. 方法：简单选择排序（Simple Selection Sort） 
3. 说明：每次排序时，选择最大或者最小项，将其放入适当的位置，反复操作，直到所有数据 
4.       排序完成为止。（注意：此处应用的这个数组下标从1开始计算） 
5. ************************************************************************/  
6. void SimpleSelectionSort(int r[],int n)  
7. {  
8.     for (int i = 1; i < n; i++)            
9.     {     
10.         int min = i;  
11.   
12.         for (int j = i + 1; j <= n; j++)  
13.         {  
14.             if (r[min] > r[j])  
15.             {  
16.                 min = j;// 寻找当前值最小元素的下标  
17.             }  
18.         }  
19.         int temp = r[i];  
20.         r[i] = r[min];  
21.         r[min] = temp;  
22.         //输出一趟排序的结果  
23.         for (int i = 1; i <= n; i++)  
24.         {  
25.             cout << r[i] << " ";  
26.         }  
27.         cout << endl;  
28.     }  
29. }  

[cpp]  view plain copy

1. /************************************************************************ 
2. 方法：堆排序（Heap Sort）（选择排序的一种） 
3. 说明：只需要一个记录大小的辅助空间，每个待排序的记录仅占有一个存储空间。 
4.       用数组根据层次遍历的方式创建一个完全二叉树，设父节点在数组中位置为i，则左子树 
5.       的位置为2i，右子树的位置为2i+1（树从1开始计数）。算法可从第n/2(取下标）开始， 
6.       到第一个元素，若子节点中有比该元素大的元素，则将该子节点（若两个子节点均比父节点大，则去较大的那个） 
7.       与父节点交换。交换后如出现子节点比孙子节点小，则继续上面的交换至叶子节点。 
8.       这样就建立一个最大堆。也可以建立一个最小堆。（注意：此处应用的这个数组下标从1开始计算） 
9. ************************************************************************/  
10. void HeapAdjust(int r[], int m, int n)  
11. {  
12.     int temp = r[m];  
13.     int mm = m;  
14.     int j(0);  
15.     for (j = 2*mm; j <= n; j *= 2)  
16.     {  
17.         if (j < n && r[j] < r[j + 1])  
18.         {  
19.             j++;  
20.         }  
21.         if (r[j] <= temp)  
22.         {  
23.             break;  
24.         }  
25.         r[mm] = r[j];  
26.   
27.         mm = j;  
28.     }  
29.     r[mm] = temp;  
30. }  
31. //  
32. //对r数组中的前n个数排序（从1开始）  
33. void HeapSort(int r[],int n)  
34. {   //“筛选”工作可从前n/2的元素开始（n/2取下标）  
35.     //建立起一个最大堆(最小堆)  
36.     for (int m = n/2; m > 0; m--)  
37.     {  
38.         HeapAdjust(r, m, n);  
39.     }  
40.   
41.     //依次取出最大（小）值，并调整堆仍未最大堆（最小堆）  
42.     for (int i = n; i > 1; i--)  
43.     {  
44.         int temp = r[1];  
45.         r[1] = r[i];  
46.         r[i] = temp;    //将最后一个元素与第一个元素交换  
47.         HeapAdjust(r, 1, i - 1); // 调整取出元素之核的堆仍未最大堆（最小堆）  
48.     }  
49.   
50.     //输出排序之后的结果  
51.     for (int i = 1; i <= n; i++)  
52.     {  
53.         cout << r[i] << " ";  
54.     }  
55.     cout << endl;  
56. }  

[cpp]  view plain copy

1. //测试代码  
2. int _tmain(int argc, _TCHAR* argv[])  
3. {  
4.     int n,i;        //待排序的关键字个数  
5.     int r[MAXSIZE];  
6.     cout << "Please input the total count you want to sort: ";  
7.     cin >> n;  
8.     cout << "Please input the numbers you want to sort,use space to separate:" << endl;  
9.     for( i=1 ; i <= n ; i++ )//输入待排序的关键字  
10.     {  
11.         cin >> r[i];  
12.     }  
13.     //InsertSort(r,n);  //直接插入排序  
14.   
15.     //BinaryInsertSort(r,n);   //折半插入排序  
16.   
17.     //ShellSort(r,n);  //希尔排序  
18.   
19.     //BubbleSort(r,n);  //冒泡排序  
20.   
21.     //SimpleSelectionSort(r,n);  //简单选择排序  
22.   
23.     //QuickSort(r, n);  //快速排序  
24.   
25.     HeapSort(r, n);   //堆排序  
26.   
27. }