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. }  
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值