排序算法

排序

1.js的sort方法，按数值大小排序

var arr=[2,4,1,4];
arr.sort(function(a,b){return a<b?-1:1});//递增

2.json数组对象排序

//先按attr1数值大小排序，再按attr2字符编码排序
function sortBy(attr1,attr2){
    return function(o,p){
        if(typeof o ==="object"&&typeof p==="object"&&o&&p){
            a=o[attr1];
             b=p[attr1];
            if(a===b){//当数值大小相等，按attr2排序
                var c=o[attr2];
                var d=p[attr2];
                if(typeof c===typeof d){
                 //按数值大小排序
                  //  return c<d?-1:1;
                 //按字符编码顺序
                 var arr2=[c,d];//将c,d放入数组中，得到排序结果，判断是否结果为c,d
                 arr2.sort();
                 return arr2[0]==c?-1:1;    
                }
            }
            if(typeof a===typeof b){
                return a<b?-1:1;
               
            }
        }
    }
}
var employees=[];
employees[0]={"name":"3", "age":32, "retiredate":"March 12, 2014"};
employees[1]={"name":"aa", "age":17, "retiredate":"June 2, 2023"};
employees[2]={"name":"2", "age":58, "retiredate":"December 20, 2036"};
employees[3]={"name":"4", "age":62, "retiredate":"April 30, 2020"};
employees[4]={"name":"bb", "age":17, "retiredate":"April 30, 2020"};
employees.sort(sortBy(2,3));
employees.sort(sortBy("age","retiredate"));

3. 对象{"react":100,"angular":75,"javascript":116,"backbone":15}排序输出为{"backbone": 15, "angular": 75, "react": 100, "javascript": 116}

var o={"react":100,"angular":75,"javascript":116,"backbone":15};
var arr=[];
//将对象转化为数组[4],每个数组项是一个数组[o[attr],attr]
for(var p in o){
    arr.push([o[p],p]);
}

arr.sort(function(o,p){return o[0]-p[0]});
//将数组转化为对象
var des={};
for (var i=0;i<arr.length;i++)des[arr[i][1]]=arr[i][0];

 

 

 

所谓排序，就是要整理文件中的记录，使之按关键字递增(或递减)次序排列起来。当待排序记录的关键字都不相同时，排序结果是惟一的，否则排序结果不惟一。
在待排序的文件中，若存在多个关键字相同的记录，经过排序后这些具有相同关键字的记录之间的相对次序保持不变，该排序方法是稳定的；若具有相同关键字的记录之间的相对次序发生改变，则称这种排序方法是不稳定的。
要注意的是，排序算法的稳定性是针对所有输入实例而言的。即在所有可能的输入实例中，只要有一个实例使得算法不满足稳定性要求，则该排序算法就是不稳定的。


一.插入排序
插入排序的基本思想是每步将一个待排序的记录按其排序码值的大小，插到前面已经排好的文件中的适当位置，直到全部插入完为止。插入排序方法主要有直接插入排序和希尔排序。

①.直接插入排序(稳定)
接插入排序的过程为：在插入第i个记录时，R1,R2,..Ri-1已经排好序，将第i个记录的排序码Ki依次和R1,R2,..,Ri-1的排序码逐个进行比较，找到适当的位置。使用直接插入排序，对于具有n个记录的文件，要进行n-1趟排序。

代码如下:

[cpp] view plaincopy
 
  1. void Dir_Insert(int A[],int N) //直接插入排序  
  2. {  
  3. int j,t;  
  4. for(int i=1;i<N;i++)  
  5. {  
  6. t=A[i];  
  7. j=i-1;  
  8. while(A[j]>t)  
  9. {  
  10. A[j+1]=A[j];  
  11. j--;  
  12. }  
  13. A[j+1]=t;  
  14. }  
  15. }  


②.希尔排序(不稳定)：
希尔(Shell)排序的基本思想是：先取一个小于n的整数d1作为第一个增量把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取得第二个增量d2<d1重复上述的分组和排序，直至所取的增量di=1，即所有记录放在同一组中进行直接插入排序为止。该方法实质上是一种分组插入方法。
一般取d1=n/2，di+1=di/2。如果结果为偶数，则加1，保证di为奇数。
希尔排序是不稳定的，希尔排序的执行时间依赖于增量序列，其平均时间复杂度为O(n^1.3).

代码如下:

[cpp] view plaincopy
 
  1. void Shell(int A[],int n) //Shell排序  
  2. {  
  3. int i,j,k,t;  
  4. (n/2)%2 == 0 ? k = n/2+1 : k = n/2; //保证增量为奇数  
  5. while(k > 0)  
  6. {  
  7. for(j=k;j<n; j++)  
  8. {  
  9. t = A[j];  
  10. i = j - k;  
  11. while(i>=0 && A[i]>t)  
  12. {  
  13. A[i+k]=A[i];  
  14. i=i-k;  
  15. }  
  16. A[i+k]=t;  
  17. }  
  18. if(k == 1) break;  
  19. (k/2)%2 ==0 ? k=k/2+1 : k=k/2;  
  20. }  
  21. }  





二.选择排序
选择排序的基本思想是每步从待排序的记录中选出排序码最小的记录，顺序存放在已排序的记录序列的后面，直到全部排完。选择排序中主要使用直接选择排序和堆排序。

①.直接选择排序(不稳定)
直接选择排序的过程是：首先在所有记录中选出序码最小的记录，把它与第1个记录交换，然后在其余的记录内选出排序码最小的记录，与第2个记录交换......依次类推，直到所有记录排完为止。
无论文件初始状态如何，在第i趟排序中选出最小关键字的记录，需要做n-i次比较，因此，总的比较次数为n(n-1)/2=O(n^2)。当初始文件为正序时，移动次数为0；文件初态为反序时，每趟排序均要执行交换操作，总的移动次数取最大值3(n-1)。直接选择排序的平均时间复杂度为O(n^2)。直接选择排序是不稳定的。

代码如下:

[cpp] view plaincopy
 
  1. void Dir_Choose(int A[],int n) //直接选择排序  
  2. {  
  3. int k,t;  
  4. for(int i=0;i<n-1;i++)  
  5. {  
  6. k=i;  
  7. for(int j=i+1;j<n;j++)  
  8. {  
  9. if(A[j]<A[k]) k=j;  
  10. }  
  11. if(k!=i)  
  12. {  
  13. t=A[i];  
  14. A[i]=A[k];  
  15. A[k]=t;  
  16. }  
  17. }  
  18. }  



②.堆排序(不稳定)
堆排序是一种树形选择排序，是对直接选择排序的有效改进。n个关键字序列
K1,K2,...,Kn称为堆，当且仅当该序列满足(Ki<=K2i且Ki<=K2i+1)或(Ki>=K2i且Ki>=K2i+1),(1<=i<=n/2)。根结点(堆顶)的关键字是堆里所有结点关键字中最小者，称为小根堆；根结点的关键字是堆里所有结点关键字中最大者，称为大根堆。
若将此序列所存储的向量R[1..n]看作是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。
堆排序的关键步骤有两个：一是如何建立初始堆；二是当堆的根结点与堆的最后一个结点交换后，如何对少了一个结点后的结点序列做调整，使之重新成为堆。堆排序的最坏时间复杂度为O(nlog2n),堆排序的平均性能较接近于最坏性能。由于建初始堆所需的比较 次数较多，所以堆排序不适宜于记录较少的文件。堆排序是就地排序，辅助空间为O(1)，它是不稳定的排序方法。

代码略..


三.交换排序
交换排序的基本思想是：两两比较待排序记录的排序码，并交换不满足顺序要求的那写偶对，直到满足条件为止。交换排序的主要方法有冒泡排序和快速排序.

①.冒泡排序(稳定的)
冒泡排序将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为ki的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R；凡扫描到违反本原则的轻气泡，就使其向上"漂浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。
冒泡排序的具体过程如下：
第一步，先比较k1和k2，若k1>k2，则交换k1和k2所在的记录，否则不交换。继续对k2和k3重复上述过程，直到处理完kn-1和kn。这时最大的排序码记录转到了最后位置，称第1次起泡，共执行n-1次比较。
与第一步类似，从k1和k2开始比较，到kn-2和kn-1为止，共执行n-2次比较。
依次类推，共做n-1次起泡，完成整个排序过程。
若文件的初始状态是正序的，一趟扫描即可完成排序。所需关键字比较次数为n-1次，记录移动次数为0。因此，冒泡排序最好的时间复杂度为O(n)。
若初始文件是反序的，需要进行n-1趟排序。每趟排序要进行n-i次关键字的比较(1<=i<=n-1),且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较次数达到最大值n(n-1)/2=O(n^2),移动次数也达到最大值3n(n-1)/2=O(n^2)。因此，冒泡排序的最坏时间复杂度为O(n^2)。
虽然冒泡排序不一定要进行n-1趟，但由于它的记录移动次数较多，故平均性能比直接插入排序要差得多。冒泡排序是就地排序，且它是稳定的。

代码如下:

[cpp] view plaincopy
 
  1. void QP(int A[],int n) //优化的冒泡排序   
  2. {  
  3. int count=0,t,flag;  
  4. for(int i=0;i<n-1;i++)  
  5. {  
  6. flag=0;  
  7. for(int j=0;j<n-i;j++)  
  8. {  
  9. if(A[j+1]<A[j])  
  10. {  
  11. t=A[j];  
  12. A[j]=A[j+1];  
  13. A[j+1]=t;  
  14. flag=1;  
  15. count+=3;  
  16. }  
  17. }  
  18. if(flag==0) break;  
  19. }  
  20. }  



②.快速排序：(不稳定的)
快速排序采用了一种分治的策略，通常称其为分治法，其基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。
快速排序的具体过程如下：
第一步，在待排序的n个记录中任取一个记录，以该记录的排序码为准，将所有记录分成两组，第1组各记录的排序码都小于等于该排序码，第2组各记录的排序码都大于该排序码，并把该记录排在这两组中间。
第二步，采用同样的方法，对左边的组和右边的组进行排序，直到所有记录都排到相应的位置为止。

代码如下:

 

[cpp] view plaincopy
 
  1.  void swap(int *a, int *b) //交换函数  
  2. {  
  3.         int temp = *a;  
  4.         *a = *b;  
  5.         *b = temp;  
  6. }  
  7.   
  8. int partition(int *array, int low, int high)  
  9. {  
  10.         int middle = (low+high)/2, temp, pivot,i,j;  
  11.         //选择第一个元素，最后一个元素，中间元素中的中间值作为支点  
  12.   
  13.         if (array[middle] < array[low])  
  14.                 swap(&array[middle], &array[low]);  
  15.         if (array[high] < array[low])  
  16.                 swap(&array[high], &array[low]);  
  17.         if (array[high] < array[middle])  
  18.                 swap(&array[high], &array[middle]);  
  19.   
  20.         pivot = array[middle]; // 选中支点  
  21.   
  22.         swap(&array[middle], &array[high-1]);//将支点值换到倒数第二个位置  
  23.   
  24.         for (i=low, j=high-1; ;) {  
  25.                 while (array[++i]<pivot) {} //找到一个大于支点的元素  
  26.                 while (pivot<array[--j]) {} //找到一个小于支点的元素  
  27.                 if (i < j) { //交换两个元素  
  28.                         temp = array[j];  
  29.                         array[j]=array[i];  
  30.                         array[i]=temp;  
  31.                 } else  
  32.                         break;  
  33.         }  
  34.         swap(&array[i], &array[high-1]); //将支点换回i点, 第一次分组结结束  
  35.   
  36.         return i;  
  37. }  


给出一种比较简洁的写法：

 

[cpp] view plaincopy
 
  1. void Quick_Sort(int A[],int low,int high) //low和high是数组的下标  
  2. {  
  3. if(low<high)  
  4. {  
  5. int temp,t=A[low];  
  6. int l=low,h=high;  
  7. while(l<h)  
  8. {  
  9. while(A[l]<t) l++;  
  10. while(A[h]>=t) h--;  
  11. if(h>l)  
  12. {  
  13. temp=A[l];  
  14. A[l]=A[h];  
  15. A[h]=temp;  
  16. }  
  17. }  
  18. Quick_Sort(A,low,l-1);  
  19. Quick_Sort(A,l+1,high);  
  20. }  
  21. }  



四.归并排序
归并排序是将两个或两个以上的有序子表合并成一个新的有序表。初始时，把含有n个结点的待排序序列看作由n个长度都为1的有序子表组成，将它们依次两两归并得到长度为2的若干有序子表，再对它们两两合并。直到得到长度为n的有序表，排序结束。
归并排序是一种稳定的排序，可用顺序存储结构，也易于在链表上实现，对长度为n的文件，需进行log2n趟二路归并，每趟归并的时间为O(n),故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlog2n)。归并排序需要一个辅助向量来暂存两个有序子文件归并的结果，故其辅助空间复杂度为O(n),显然它不是就地排序。

[cpp] view plaincopy
 
  1. void merge(int *array, int *temp_array, int left, int right, int right_end)  
  2. {  
  3.         int left_end = right - 1, i;  
  4.         int tmp = left;  
  5.         int num = right_end - left+1;  
  6.   
  7.         while (left <= left_end && right <= right_end)  
  8.                 if (array[left] <= array[right])  
  9.                         temp_array[tmp++] = array[left++];  
  10.                 else  
  11.                         temp_array[tmp++] = array[right++];  
  12.   
  13.         while (left <= left_end)  
  14.                 temp_array[tmp++] = array[left++];  
  15.         while (right <= right_end)  
  16.                 temp_array[tmp++] = array[right++];  
  17.         for (i=0; i<num; i++, right_end--)  
  18.                 array[right_end] = temp_array[right_end];  
  19. }  
  20.   
  21. void m_sort(int *array, int *temp_array, int left, int right)  
  22. {  
  23.         int center;  
  24.         if (left < right) {  
  25.                 center = (left+right)/2;  
  26.                 m_sort(array, temp_array, left, center);  
  27.                 m_sort(array, temp_array, center+1, right);  
  28.                 merge(array, temp_array, left, center+1, right);  
  29.         }  
  30. }  
  31. void merge_sort(int *array, int size)  
  32. {  
  33.         int *temp = (int*)malloc(size);  
  34.         memset(temp, 0, size);  
  35.         m_sort(array, temp, 0, size-1);  
  36.         free(temp);  
  37. }  





五.基数排序
设单关键字的每个分量的取值范围均是C0<=Kj<=Crd-1(0<=j<=rd),可能的取值个数rd称为基数．基数的选择和关键字的分解因关键字的类型而异．
　　(1).若关键字是十进制整数，则按个、十等位进行分解，基数rd=10,C0=0,C9=9,d为最长整数的位数．
　　(2).若关键字是小写的英文字符串，则rd=26,C0='a',C25='z',d为最长字符串的长度．
　　基数排序的基本思想是：从低位到高位依次对待排序的关键码进行分配和收集，经过d趟分配和收集，就可以得到一个有序序列．


排序时间列表：

 

名称

复杂度

说明

备注

冒泡排序
Bubble Sort

O(N*N)

将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮

 

插入排序

Insertion sort

O(N*N)

逐一取出元素，在已经排序的元素序列中从后向前扫描，放到适当的位置

起初，已经排序的元素序列为空

选择排序

O(N*N)

首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。以此递归。

 

快速排序

Quick Sort

O(n *log2(n))

先选择中间值，然后把比它小的放在左边，大的放在右边（具体的实现是从两边找，找到一对后交换）。然后对两边分别使用这个过程（递归）。

 

堆排序HeapSort

O(n *log2(n))

利用堆（heaps）这种数据结构来构造的一种排序算法。堆是一个近似完全二叉树结构，并同时满足堆属性：即子节点的键值或索引总是小于（或者大于）它的父节点。

近似完全二叉树

希尔排序

SHELL

O(n1+￡)

0<￡<1

选择一个步长(Step) ,然后按间隔为步长的单元进行排序.递归,步长逐渐变小,直至为1.

 

箱排序
Bin Sort

O(n)

设置若干个箱子，把关键字等于 k 的记录全都装入到第k 个箱子里 ( 分配 ) ，然后按序号依次将各非空的箱子首尾连接起来 ( 收集 ) 。

分配排序的一种：通过" 分配 " 和 " 收集 " 过程来实现排序。

桶排序

Bucket Sort

O(n)

桶排序的思想是把 [0 ， 1) 划分为 n 个大小相同的子区间，每一子区间是一个桶。

 

 

 

排序法

 平均时间

最差情形

稳定度

额外空间

备注

冒泡

 O(n2)

  O(n2)

 稳定

O(1)

n小时较好

交换

  O(n2)

  O(n2)

不稳定

O(1)

n小时较好

选择

 O(n2)

 O(n2)

不稳定

O(1)

n小时较好

插入

 O(n2)

 O(n2)

稳定

O(1)

大部分已排序时较好

基数

O(logRB)

O(logRB)

稳定

O(n)

B是真数(0-9)，R是基数(个十百)

Shell

O(nlogn)

O(ns) 1<s<2

不稳定

O(1)

s是所选分组

快速

O(nlogn)

O(n2)

不稳定

O(nlogn)

n大时较好

归并

O(nlogn)

O(nlogn)

稳定

O(1)

n大时较好

堆

O(nlogn)

O(nlogn)

不稳定

O(1)

n大时较好

 

 

 

按平均时间将排序分为四类：

（1）平方阶(O(n2))排序
　一般称为简单排序，例如直接插入、直接选择和冒泡排序；

（2）线性对数阶(O(nlgn))排序
　如快速、堆和归并排序；

（3）O(n1+￡)阶排序
　￡是介于0和1之间的常数，即0<￡<1，如希尔排序；

（4）线性阶(O(n))排序
　如基数排序。

各种排序方法比较
简单排序中直接插入最好，快速排序最快，当文件为正序时，直接插入和冒泡均最佳。

影响排序效果的因素
　因为不同的排序方法适应不同的应用环境和要求，所以选择合适的排序方法应综合考虑下列因素：
　　①待排序的记录数目n；
　　②记录的大小(规模)；
　　③关键字的结构及其初始状态；
　　④对稳定性的要求；
　　⑤语言工具的条件；
　　⑥存储结构；
　　⑦时间和辅助空间复杂度等。

不同条件下，排序方法的选择

(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
　当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。
(2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜；
(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或
归并排序。
快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况。这两种排序都是不稳定的。

若要求排序稳定，则可选用归并排序。但从单个记录起进行两两归并的 排序算法并不值得提倡，通常可以将它和直接插入排序结合在一起使用。先利用直接插入排序求得较长的有序子文件，然后再两两归并之。因为直接插入排序是稳定的，所以改进后的归并排序仍是稳定的。

 

--------------------------------------------------------------排序稳定性的分析，有助于理解掌握--------------------------------------------

首先，排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj, Ai原来在位置前，排序后Ai还是要在Aj位置前。

其次，说一下稳定性的好处。排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就 是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，对基于比较的排序算法而言，元素交换 的次数可能会少一些(个人感觉，没有证实)。

回到主题，现在分析一下常见的排序算法的稳定性，每个都给出简单的理由。

(1)冒泡排序

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

(2)选择排序

选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个 元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么 交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9， 我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。

(3)插入排序
插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开 始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相 等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳 定的。

(4)快速排序
快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j] > a[center_index]。如果i和j都走不动了，i <= j, 交换a[i]和a[j],重复上面的过程，直到i>j。 交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为 5 3 3 4 3 8 9 10 11， 现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j]交换的时刻。

(5)归并排序
归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有 序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定 性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结 果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。

(6)基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优 先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。

(7)希尔排序(shell)
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小， 插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元 素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

(8)堆排序
我们知道堆的结构是节点i的孩子为2*i和2*i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n 的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n /2-1, n/2-2, ...1这些个父节点选择元素时，就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没 有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法。

posted @ 2015-08-25 22:36  半夏微凉ysy  阅读(251)  评论(0)  编辑  收藏  举报