排序算法

  最近看排序算法的书籍，记录下自己的心得和总结。关于几种常见排序的原理和实现。（快速排序借了别人的步骤描述，可以很清晰的理解每一趟怎么跑的）

首先说下稳定排序和非稳定排序，简单地说就是所有相等的数经过某种排序方法后，

仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。反之，就是非稳定的。

     几个基本常见的排序，插入排序（包括直接插入，希尔插入，折半插入等），交换排序（包括冒泡排序，快速排序），选择排序（简单选择，堆排序，树形排序等），归并排序，基数排序（多关键字，链式基数）。

 

1.      直接插入排序（稳定排序）

简单的说就是将序列分为有序序列和无序序列。每一趟排序都是将无序序列的第一个元素插入有序序列中。R[1… i-1]  <-  R[i…n] , 每次取R[i]插入到R[1… i-1]中。

步骤如下：

1>  在R[1 … i-1]中找到R[i]的插入位置k （0<k<i）

2>  将R[k … i-1]均后移一位，K位置上插入R[i]

改进版：

1>    在R[1 … i-1]中将R[i]从右向左一一比较，R[j] >R[i],则R[j]后移一位（j = i-1开始）

2>    如果R[j] <=R[i],则j+1 为R[i]的插入位置

 

实现如下(包括测试)：

[cpp]  view plain  copy

1. <span style="font-size:14px;">  
2. #include<iostream>  
3. using namespace std;  
4. void insert_sort(int a[],int len)  
5. {  
6. int i=0,j=0,temp=0;  
7. for(i=1;i<len;i++)  
8. {  
9. temp =a[i];  
10. for(j=i-1;j>=0&&temp<a[j];j--)  
11. {  
12.  a[j+1]=a[j];  
13. }  
14.  a[j+1]=temp;  
15. }  
16. }  
17.   
18. void print_array(int a[].int len)  
19. {  
20. for(int i=0;i<len;i++)  
21. {  
22.   cout<<a[i]<<””;  
23. }  
24.  cout<<endl;  
25. }  
26.   
27.    
28. int main()  
29. {  
30.  inta[]={1,3,5,9,8,6,4,2,7} ;  
31.  cout<<”before sort:”;  
32.  print_array(a,9);  
33.  insert_sort(a,9);  
34.  cout<<”after sort:”;  
35.  print_array(a,9);  
36.  return 0;  
37. }  
38. </span>  

 

2.      希尔排序（不稳定排序）

希尔排序算法是先将要排序的一组数按照某个增量d分成若干组，对每组中的元素进行排序，然后在用更小的增量来进行再次分组，并给每个分组重新排序，直到增量为1时，整个要排序的数被分成一组，排序结束。

形象点说，例如[R1 ,R2 , R3, R4,R5,R6,R7,R8]，先增量d =len/2 =4 ,则先分成[R1 R5] ,[R2 R6] ,[R3 R7] ,[R4 R8]四组，进行组内排序；再d=d/2 =2,分成[R1 R3 R5R7] 和 [R2 R4 R6 R8]两组，组内排序；再d=d/2=1,整个数组只剩一个大的分组[R1 , R2 , R3, R4,R5,R6,R7,R8]，组内排序。全部结束。

实现如下(包括测试)：

[cpp]  view plain  copy

1. <span style="font-size:14px;">  
2. #include<iostream>  
3. using namespace std;  
4. void shell_sort(int a[],int len)  
5. {  
6. int d,i,j,temp;  
7. for(d=len/2;d>0;d=d/2)  
8. {  
9. for(i=d;i<len;i++)  
10. {  
11.  temp= a[i];  
12.  for(j=i-d;j>=0&&temp<a[j];j-=d)  
13.  {  
14.  a[j+d]=a[j];  
15. }  
16.  a[j+d]=temp;  
17. }  
18. }  
19. }  
20.    
21. void print_array(int a[],int len)  
22. {  
23. for(int i=0;i<len;i++)  
24. {  
25.  cout<<a[i]<<" ";  
26. }  
27.  cout<<endl;  
28. }  
29.    
30. int main()  
31. {  
32.  inta[]={2,3,5,9,8,6,4,1,7} ;  
33.  cout<<"before sort:";  
34.  print_array(a,9);  
35.  shell_sort(a,9);  
36.  cout<<"after sort:";  
37.  print_array(a,9);  
38.  return 0;  
39. }  
40. </span>  

 

3.      冒泡排序（稳定排序）

冒泡排序也叫起泡排序，顾名思义，就是每一趟，从左到右，两两比较，大的（小的）后移，最后最轻的气泡到最后的位置R[i]，为最大或最小值，然后下一趟，选出次大的到R[i-1]，以此，到最后R[1]，至此全部有序。（按照递增递减都可以）

实现如下：

 /*a[0]..从a[0]最小开始 */

[cpp]  view plain  copy

1. <span style="font-size:14px;">  
2. void bubble_sort(int a[],int len)  
3. {  
4.   int i,j,temp;    
5.   for(i=0;i<len-1;i++)  
6. {  
7.  for(j=len-2;j>=i;j--)  
8. {  
9.  if(a[j+1]<a[j])  
10. {  
11.  temp=a[j];  
12.  a[j]=a[j+1];  
13.  a[j+1]=temp;  
14. }  
15. }  
16. }  
17. }  
18.    
19. /* ...a[n] ,从a[n]最大开始，*/  
20. void bubble_sort1(int a[],int len)  
21. {  
22.   inti,j,temp;    
23.   for(i=0;i<len-1;i++)  
24. {  
25.  for(j=0;j<len-i-1;j++)  
26. {  
27.  if(a[j+1]<a[j])  
28. {  
29.  temp=a[j];  
30.  a[j]=a[j+1];  
31.  a[j+1]=temp;  
32. }  
33. }  
34. }  
35. }  
36.   
37. //考虑如果中间的某一趟扫描之前，数组已经全部有序，后面的扫描则没有必要。此时可以加一个标记，来判断是否提前结束循环。  
38.   
39. 改进：  
40.   
41. void bubble_sort(int a[],int len)  
42. {  
43.   int i,j,temp;  
44.   int exchange=0;   
45.   for(i=0;i<len-1;i++)  
46. {  
47.   exchange = 0;  
48.   for(j=len-2;j>=i;j--)  
49. {  
50.   if(a[j+1]<a[j])  
51. {  
52.  temp=a[j];  
53.  a[j]=a[j+1];  
54.  a[j+1]=temp;  
55.  exchange=1;  //如果发生过交换，exchange置为1  
56. }  
57. }  
58. if(exchange!=1)  //如果exchange为0，说明已经有序，这一趟没发生交换，直接结束循环  
59.  return;  
60. }  
61. }  
62.  </span>  

4.      快速排序（不稳定排序）

快速排序是一种划分交换排序，采用的是分治法的策略。该方法的基本思想是：

1．先从数列中取出一个数作为基准数。

2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3．再对左右区间重复第二步，直到各区间只有一个数。

 

下面借助这篇文章的步骤描述，就会很好理解快速排序每一趟到底怎么走的：

来源：http://blog.csdn.net/liuchen1206/article/details/6954074

 

以一个数组作为示例，取区间第一个数为基准数(pivot)。

0	1	2	3	4	5	6	7	8	9
72	6	57	88	60	42	83	73	48	85

初始时，i = 0;  j =9;   X = a[i] = 72

由于已经将a[0]中的数保存到X中，可以理解成在数组a[0]上挖了个坑，可以将其它数据填充到这来。

从j开始向前找一个比X小或等于X的数。当j=8，符合条件，将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8];i++; 这样一个坑a[0]就被搞定了，但又形成了一个新坑a[8]，这怎么办了？简单，再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数，当i=3，符合条件，将a[3]挖出再填到上一个坑中a[8]=a[3];j--;

 

数组变为：

0	1	2	3	4	5	6	7	8	9
48	6	57	88	60	42	83	73	88	85

 i = 3;   j =7;   X=72

再重复上面的步骤，先从后向前找，再从前向后找。

从j开始向前找，当j=5，符合条件，将a[5]挖出填到上一个坑中，a[3] = a[5]; i++;

从i开始向后找，当i=5时，由于i==j退出。

此时，i = j = 5，而a[5]刚好又是上次挖的坑，因此将X填入a[5]。

 

数组变为：

0	1	2	3	4	5	6	7	8	9
48	6	57	42	60	72	83	73	88	85

可以看出a[5]前面的数字都小于它，a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。a[5]已经确定好位置。后面每一趟也是。

 

 

对挖坑填数进行总结

1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。

2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。

3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。

4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

 

[cpp]  view plain  copy

1. 具体实现如下（测试不重复，在前面的代码上加个函数，都测试过）：  
2.   
3. <span style="font-size:14px;">  
4. /*这里的low和high是数组的头和尾的下标*/  
5. void quick_sort(int a[],int low,int high)  
6. {  
7.   int i,j,pivot;  
8.   if(low<high)  
9. {  
10.  pivot =a[low];   //pivot的初始值为a[low]  
11.  i=low;  
12.  j=high;  
13.  while(i<j)  
14. {  
15.  while(i<j&&a[j]>=pivot)  
16.    j--;  
17.  if(i<j)  
18.    a[i++]=a[j];        //比pivot小的元素移动到低端  
19. while(i<j&&a[i]<=pivot)  
20.    i++;  
21. if(i<j)  
22.    a[j--]=a[i];         //比pivot大的元素移动到高端  
23. }  
24. a[i]=pivot;  
25. quick_sort(a,low,i-1);    //对左右两个子区间进行递归  
26. quick_sort(a,i+1,high);  
27. }  
28. }  
29. </span>  

[cpp]  view plain  copy

1. erlang的快排：  
2. myqsort([])     -> [];  
3. myqsort([T|L])  -> myqsort([X || X <- L,X < T])  
4.                         ++ [T] ++  
5.                 myqsort([X || X <- L,X >= T]).  

5.      直接选择排序（不稳定排序）

选择排序的基本思想：每一次从待排序的记录中选出关键字最小的记录，顺序的放在有序的序列的最后，直至全部记录排序完毕。

而直接选择排序就是n条记录经过n-1次后，直接得到有序记录。

实现如下：

[cpp]  view plain  copy

1. void select_sort(int a[],int len)  
2. {  
3.  int i,j,min,k; //min保存最小数，k记录最小数的位置  
4.  for(i=0;i<len;i++)  
5.  {  
6.   min= a[i];  
7.   k =i;  
8.  for(j=i+1;j<len;j++)  
9.   {  
10.     if(a[j]<min)  
11.      {  
12.           min = a[j];  
13.           k  = j;  
14.      }  
15.   }  
16.  a[k]=a[i];  //a[k]为最小值，已由min保存  
17.  a[i]=min;  
18.  }  
19. }  
20.   
21. 或者简化：  
22.   
23. void select_sort(int a[],int len)    
24. {    
25.  int i,j,temp;   
26.  for(i=0;i<len;i++)    
27.  {    
28.  for(j=i+1;j<len;j++)    
29.   {    
30.     if(a[i]>a[j])    
31.      {    
32.          temp=a[i];  
33.          a[i]=a[j];  
34.          a[j]=temp;     
35.      }    
36.   }     
37.  }    
38. }   

6.      堆排序（不稳定排序）

堆排序是一种树形选择排序方法，它的特点是：在排序过程中，将A[n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲节点和孩子节点之间的内在关系，在当前无序区中选择关键字最大（或最小）的元素。

堆的定义如下：n个关键字序列A[n]成为堆，当且仅当该序列满足：
①L(i) <= L(2i)且L(i) <= L(2i+1)  或者  ②L(i) >=L(2i)且L(i) >= L(2i+1)  其中i属于[1, n/2]。

满足第①种情况的堆称为小根堆（小顶堆），满足第②种情况的堆称为大根堆（大顶堆）。

 

如上的小根堆或大根堆，输出堆顶的最小（大）值之后，使得剩下的n-1个元素的序列重新建成一个新的堆，则又得到n个数中的次小（大）值，如此反复，最后得到的有序序列，这个过程就是堆排序。

代码实现：

[cpp]  view plain  copy

1. <span style="font-size:14px;">  
2. void swap(int *a ,int *b)   
3. {   
4.     int temp = *a;   
5.     *a = *b;   
6.     *b = temp;   
7. }   
8.   
9. void HeapAdjust(int a[],int i)   
10. {   
11.     int left = 2*i+1;//左孩子节点   
12.     int right = 2*i + 2;//右孩子节点   
13.     int max = 0;//暂存最大元素下标   
14.     if(left <=heapsize  && a[left] >a[i])   
15.         max = left;  
16.     else  
17.         max = i;  
18.     if(right <= heapsize&& a[right] > a[max])   
19.         max = right;   
20.     if(max != i)//表明当前的父节点并不是最大的   
21.     {   
22.        swap(&a[i],&a[max]);   
23.        HeapAdjust(a,max);//有交换就要递归把子树也整成最大堆   
24.     }   
25. }   
26.    
27. void BuildHeap(int a[],int len)   
28. {   
29.      int i = 0;  
30.      heapsize = len;  
31.      for( i = len/ 2;i >=0;i--)//非叶节点最大下标为/2   
32.     {   
33.         HeapAdjust(a,i);   
34.     }   
35. }   
36.   
37. //堆排序对要排序的序列有个要求就是下标是从1开始到size的，而并非常用的0~size-1   
38.   
39. void heap_sort(int a[],int len)   
40. {   
41.     int i;  
42.     BuildHeap(a,len-1);//先建立初始的最大堆   
43.     for( i = len-1;i >=1;i--)   
44.     {   
45.        swap(&a[0],&a[i]);//把最大的元素放到最后面   
46.        heapsize--;//不再包括最大的元素   
47.        HeapAdjust(a,0);   
48.     }   
49.     //至此数组就已经从小到大排好序了,   
50.   
51.     //如果要从大到小输出，则倒着输出就行了；   
52.   
53.     //而如果要将序列从大到小排序，则应建立最小堆。   
54.   
55. }  
56.  </span>  

 

7.      归并排序（稳定排序）

归并是指将若干个已排序的子文件合并成一个有序的文件。常见的归并排序有两路归并排序。它是采用分治法的。

归并操作的基本步骤如下：
1.申请两个与已经排序序列相同大小的空间，并将两个序列拷贝其中；
2.设定最初位置分别为两个已经拷贝排序序列的起始位置，比较两个序列元素的大小，依次选择相对小的元素放到原始序列；
3.重复2直到某一拷贝序列全部放入原始序列，将另一个序列剩下的所有元素直接复制到原始序列尾。

 

设归并排序的当前区间是R[low..high]，三个步骤分别是：
1.分解：将当前区间一分为二，即求分裂点
2.求解：递归地对两个子区间R[low..mid]和R[mid+1..high]进行归并排序；
3.组合：将已排序的两个子区间R[low..mid]和R[mid+1..high]归并为一个有序的区间R[low..high]。
递归的终结条件：子区间长度为1（一个记录自然有序）。

 

代码实现：

[cpp]  view plain  copy

1. <span style="font-size:14px;">  
2. void Merge(int *a, int p, int q, int r)    
3. {    
4.     int n1 = q-p+1;    
5.     int n2 = r-q;    
6.     int *L = new int[n1+1];    
7.     int *R = new int[n2+1];    
8.     int i, j, k;       
9.     for (i=0; i<n1; i++)  
10. {    
11.         L[i] = a[p+i];     
12. }    
13.     for (j=0; j<n2; j++)  
14.      {    
15.         R[j] = a[q+j+1];    
16.      }    
17.     L[n1] = 10000000;    
18.     R[n2] = 10000000;    
19.     for (i=0, j=0, k=p; k<=r; k++)    
20.     {    
21.         if (L[i]<=R[j])    
22.         {    
23.             a[k] = L[i];    
24.             i++;    
25.         }  
26.         else  
27.        {   
28.            a[k] = R[j];    
29.            j++;    
30.         }    
31.     }    
32.     delete []L;    
33.     delete []R;    
34. }      
35.   
36. void merge_sort(int *a, int p, int r)  //测试时候，参为a，0，len-1  
37. {   
38.    if (p<r)   
39.    {   
40.        int q = (p+r)/2;   
41.        merge_sort(a, p, q);   
42.        merge_sort(a, q+1, r);   
43.        merge_sort(a, p, q, r);   
44.    }   
45. }   
46.  </span>  

8.  基数排序（稳定排序） 

http://blog.csdn.net/u012580566/article/details/47702955

实现如下：

[cpp]  view plain  copy

1. <span style="font-size:14px;">  
2. int maxbit(int data[], int n)     
3. {    
4.     int d = 1; //保存最大的位数    
5.     int p = 10;    
6.     for(int i = 0; i < n; ++i)    
7.     {    
8.         while(data[i] >= p)    
9.         {    
10.             p *= 10;    
11.             ++d;    
12.         }    
13.     }    
14.     return d;    
15. }    
16.   
17. void radixsort(int data[], int n) //基数排序    
18. {    
19.     int d = maxbit(data, n);    
20.     int tmp[n];    
21.     int count[10]; //计数器    
22.     int i, j, k;    
23.     int radix = 1;    
24.     for(i = 1; i <= d; i++) //进行d次排序    
25.     {    
26.         for(j = 0; j < 10; j++)    
27.             count[j] = 0; //每次分配前清空计数器    
28.         for(j = 0; j < n; j++)    
29.         {    
30.             k = (data[j] / radix) % 10; //统计每个桶中的记录数    
31.             count[k]++;    
32.         }    
33.         for(j = 1; j < 10; j++)    
34.             count[j] = count[j - 1] + count[j]; //将tmp中的位置依次分配给每个桶    
35.         for(j = n - 1; j >= 0; j--) //将所有桶中记录依次收集到tmp中    
36.         {    
37.             k = (data[j] / radix) % 10;    
38.             tmp[count[k] - 1] = data[j];    
39.             count[k]--;    
40.         }    
41.         for(j = 0; j < n; j++) //将临时数组的内容复制到data中    
42.             data[j] = tmp[j];    
43.         radix = radix * 10;    
44.     }    
45. }    
46. </span>  

总结：选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，

     冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。