各种经典排序算法汇总.docx
《各种经典排序算法汇总.docx》由会员分享，可在线阅读，更多相关《各种经典排序算法汇总.docx（14页珍藏版）》请在冰豆网上搜索。
各种经典排序算法汇总
1，选择排序
对于一个a[0,n]的数组，依次遍历数组，每次选出最大或最小的一个数
[cpp] viewplaincopy
1.void selectSort（int *a,int size）
2.{
3. int min;
4. for（int i=0;i5. {
6. min=i; //将当前下标定义为最小值下标
7. for（int j=i+1;j8. if（a[min]>a[j]）
9. min=j; // 记录当前最小下标
10. if（i!
=min）
11. swap（a[i],a[min]）; // 如果i不是最小下标 则交换
12. }
13. print（a,size）;
14.}
2，冒泡排序
依次比较相邻的两个数，将小数放在前面，大数放在后面。
即在第一趟：
首先比较第1个和第2个数，将小数放前，大数放后。
然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。
至此第一趟结束，将最大的数放到了最后。
在第二趟：
仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。
如此下去，重复以上过程，直至最终完成排序。
[cpp] viewplaincopy
1.void BubbleSort（int *a,int size）
2.{
3. for（int i=0;i4. for（int j=0;j5. {
6. if（a[j]>a[j+1]）
7. swap（a[j],a[j+1]）;
8. }
9. print（a,size）;
10.}
优化：
使用标志的冒泡排序，因为当一次遍历时没有发生任何的交换事实上证明数组排序已经完成函数可以退出
[cpp] viewplaincopy
1.void BubbleSortWithFlag（int *a,int size）
2.{
3. bool flag;
4.for（int i=0;i5. {
6. flag=true;
7. for（int j=0;j8. {
9. if（a[j]>a[j+1]）
10. {
11. swap（a[j],a[j+1]）;
12. flag=false;
13. }
14. }
15. if（flag==true）
16. {
17. print（a,size）;
18. return;
19. }
20. }
21.}
鸡尾酒排序：
冒泡排序的变形（转）
鸡尾酒排序等于冒泡排序的轻微变形，不同的地方在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素。
他可以得到比冒泡排序稍微好一点的效能，原因是冒泡排序只从一个方向进行比对（由低到高），每次循环只移动一个项目。
以序列（2,3,4,5,1）为例，鸡尾酒排序只需要访问两次（升序降序各一次）次序列就可以完成排序，但如果使用冒泡排序则需要四次。
（1）先对数组从左到右进行冒泡排序（升序），则最大的元素去到最右端；
（2）再对数组从右到左进行冒泡排序（降序），则最小的元素去到最左端。
以此类推，依次改变冒泡的方向，并不断缩小未排序元素的范围。
[cpp] viewplaincopy
1.void CockSort（int *a,int size）
2.{
3. int low=0;
4. int up=size-1;
5. int index=0;
6. while（low7. {
8. for（int i=low;i9. if（a[i]>a[i+1]）
10. {
11. swap（a[i],a[i+1]）;
12. index=i;
13. }
14. up=index;
15. for（int i=up;i>low;i--）
16. if（a[i]17. {
18. swap（a[i],a[i-1]）;
19. index=i;
20. }
21. low=index;
22. }
23. print（a,size）;
24.}
3，插入排序（直接，折半，路插入，表插入）
依次取出便利每一项将每一项temp=a[j]和其之前的数进行比较，如果发现了比自己大的数就将其放在当前j的位置同时j--，继续用temp和之前的数进行比较，直到没有比自己大的数时结束。
[cpp] viewplaincopy
1.//直接插入排序
2.void insertSort（int *a,int size）
3.{
4. if（size<2）
5. return;
6. int temp;
7. int j;
8. for（int i=1;i9. {
10. temp=a[i];
11. for（ j=i;j>0&&temp12. {
13. a[j]=a[j-1];
14. }
15. a[j]=temp;
16. }
17. print（a,size）;
18.}
折半插入排序：
折半插入排序（binaryinsertionsort）是对插入排序算法的一种改进，由于排序算法过程中，就是不断的依次将元素插入前面已排好序的序列中。
由于前半部分为已排好序的数列，这样我们不用按顺序依次寻找插入点，可以采用折半查找的方法来加快寻找插入点的速度。
折半插入排序算法的具体操作为：
在将一个新元素插入已排好序的数组的过程中，寻找插入点时，将待插入区域的首元素设置为a[low],末元素设置为a[high]，则轮比较时将待插入元素与a[m],其中m=（low+high）/2相比较,如果比参考元素小，则选择a[low]到a[m-1]为新的插入区域（即high=m-1），否则选择a[m+1]到a[high]为新的插入区域（即low=m+1），如此直至low<=high不成立，即将此位置之后所有元素后移一位，并将新元素插入a[high+1]。
[cpp] viewplaincopy
1.void binaryInsertSort（int *a,int size）
2.{
3. int low,high,m,temp,j;
4. for （int i=1;i5. temp=a[i];
6. low=0;
7. high=i-1;
8. /* if（a[i]>a[i-1]） //这句话可以稍微优化一下下速度 不影响结果
9. continue;*/
10. while （low<=high）{
11. m=（low+high）/2;
12. if （temp<=a[m]）
13. high=m-1; //当程序跳出时 high指向的其实并不是 >=temp的值的位置 而是>=temp的值的左边的位置 所以....
14. else
15. low=m+1;
16. }
17. for（ j=i;j>high+1;--j） //所以 这里的high要加一哇
18. a[j]=a[j-1];
19. a[j]=temp;
20. }
21. print（a,size）;
22.}
4，希尔排序
希尔算法思想：
将整个无序序列分割成若干小的子序列分别进行插入排序。
如一个长度为13的数组
81 94 11 96 12 35 17 95 28 58 41 75 15
先以13/2=5为gap进行比较即对（813541）（941775）（119515）分别进行排序 即对数组进行一次间距为5的插入排序
之后以3和1为间距对数组进行插入排序
[cpp] viewplaincopy
1.void shellSort（int *a,int size） // 代码取自 数据结构于问题求解（c++版）
2.{
3. for（int gap=size/2;gap>0;gap=gap==2?
1:
static_cast（gap/2.2）） // 这里计算出当前的 间距
4. {
5. for（int i=gap;i6. {
7. int temp=a[i];
8. int j;
9. for（j=i;j>=gap&&temp10. {
11. a[j]=a[j-gap];
12. }
13. a[j]=temp;
1
升级会员 