本章介绍排序算法中的希尔排序。内容包括:
1. 希尔排序介绍
2. 希尔排序图文说明
3. 希尔排序的时间复杂度和稳定性
4. 希尔排序实现
4.1 希尔排序C实现
4.2 希尔排序C++实现
4.3 希尔排序Java实现

转载请注明出处:http://www.cnblogs.com/skywang12345/p/3597597.html


更多内容:数据结构与算法系列 目录

 

希尔排序(Shell Sort)是插入排序的一种,它是针对直接插入排序算法的改进。该方法又称缩小增量排序,因DL.Shell于1959年提出而得名。

希尔排序实质上是一种分组插入方法。它的基本思想是:对于n个待排序的数列,取一个小于n的整数gap(gap被称为步长)将待排序元素分成若干个组子序列,所有距离为gap的倍数的记录放在同一个组中;然后,对各组内的元素进行直接插入排序。 这一趟排序完成之后,每一个组的元素都是有序的。然后减小gap的值,并重复执行上述的分组和排序。重复这样的操作,当gap=1时,整个数列就是有序的。

 

希尔排序代码(一)

  1. /*
  2. * 希尔排序
  3. *
  4. * 参数说明:
  5. * a -- 待排序的数组
  6. * n -- 数组的长度
  7. */
  8. void shell_sort1(int a[], int n)
  9. {
  10. int i,j,gap;
  11. // gap为步长,每次减为原来的一半。
  12. for (gap = n / 2; gap > 0; gap /= 2)
  13. {
  14. // 共gap个组,对每一组都执行直接插入排序
  15. for (i = 0 ;i < gap; i++)
  16. {
  17. for (j = i + gap; j < n; j += gap)
  18. {
  19. // 如果a[j] < a[j-gap],则寻找a[j]位置,并将后面数据的位置都后移。
  20. if (a[j] < a[j - gap])
  21. {
  22. int tmp = a[j];
  23. int k = j - gap;
  24. while (k >= 0 && a[k] > tmp)
  25. {
  26. a[k + gap] = a[k];
  27. k -= gap;
  28. }
  29. a[k + gap] = tmp;
  30. }
  31. }
  32. }
  33. }
  34. }

在上面的希尔排序中,首先要选取步长gap的值。选取了gap之后,就将数列分成了gap个组,对于每一个组都执行直接插入排序。在排序完所有的组之后,将gap的值减半;继续对数列进行分组,然后进行排序。重复这样的操作,直到gap<0为止。此时,数列也就是有序的了。

为了便于观察,我们将希尔排序中的直接插入排序独立出来,得到代码(二)。

 

希尔排序代码(二)

  1. /*
  2. * 对希尔排序中的单个组进行排序
  3. *
  4. * 参数说明:
  5. * a -- 待排序的数组
  6. * n -- 数组总的长度
  7. * i -- 组的起始位置
  8. * gap -- 组的步长
  9. *
  10. * 组是"从i开始,将相隔gap长度的数都取出"所组成的!
  11. */
  12. void group_sort(int a[], int n, int i,int gap)
  13. {
  14. int j;
  15. for (j = i + gap; j < n; j += gap)
  16. {
  17. // 如果a[j] < a[j-gap],则寻找a[j]位置,并将后面数据的位置都后移。
  18. if (a[j] < a[j - gap])
  19. {
  20. int tmp = a[j];
  21. int k = j - gap;
  22. while (k >= 0 && a[k] > tmp)
  23. {
  24. a[k + gap] = a[k];
  25. k -= gap;
  26. }
  27. a[k + gap] = tmp;
  28. }
  29. }
  30. }
  31. /*
  32. * 希尔排序
  33. *
  34. * 参数说明:
  35. * a -- 待排序的数组
  36. * n -- 数组的长度
  37. */
  38. void shell_sort2(int a[], int n)
  39. {
  40. int i,gap;
  41. // gap为步长,每次减为原来的一半。
  42. for (gap = n / 2; gap > 0; gap /= 2)
  43. {
  44. // 共gap个组,对每一组都执行直接插入排序
  45. for (i = 0 ;i < gap; i++)
  46. group_sort(a, n, i, gap);
  47. }
  48. }

 

下面以数列{80,30,60,40,20,10,50,70}为例,演示它的希尔排序过程。

第1趟:(gap=4)

当gap=4时,意味着将数列分为4个组: {80,20},{30,10},{60,50},{40,70}。 对应数列: {80,30,60,40,20,10,50,70}
对这4个组分别进行排序,排序结果: {20,80},{10,30},{50,60},{40,70}。 对应数列: {20,10,50,40,80,30,60,70}

第2趟:(gap=2)

当gap=2时,意味着将数列分为2个组:{20,50,80,60}, {10,40,30,70}。 对应数列: {20,10,50,40,80,30,60,70}
注意:{20,50,80,60}实际上有两个有序的数列{20,80}和{50,60}组成。
          {10,40,30,70}实际上有两个有序的数列{10,30}和{40,70}组成
对这2个组分别进行排序,排序结果:{20,50,60,80}, {10,30,40,70}。 对应数列: {20,10,50,30,60,40,80,70}

 

第3趟:(gap=1)

当gap=1时,意味着将数列分为1个组:{20,10,50,30,60,40,80,70}
注意:{20,10,50,30,60,40,80,70}实际上有两个有序的数列{20,50,60,80}和{10,30,40,70}组成。
对这1个组分别进行排序,排序结果:{10,20,30,40,50,60,70,80}

 

希尔排序时间复杂度
希尔排序的时间复杂度与增量(即,步长gap)的选取有关。例如,当增量为1时,希尔排序退化成了直接插入排序,此时的时间复杂度为O(N²),而Hibbard增量的希尔排序的时间复杂度为O(N3/2)。

希尔排序稳定性
希尔排序是不稳定的算法,它满足稳定算法的定义。对于相同的两个数,可能由于分在不同的组中而导致它们的顺序发生变化。
算法稳定性 — 假设在数列中存在a[i]=a[j],若在排序之前,a[i]在a[j]前面;并且排序之后,a[i]仍然在a[j]前面。则这个排序算法是稳定的!

 

希尔排序C实现
实现代码(shell_sort.c)

  1. 1 /**
  2. 2 * 希尔排序:C 语言
  3. 3 *
  4. 4 * @author skywang
  5. 5 * @date 2014/03/11
  6. 6 */
  7. 7
  8. 8 #include <stdio.h>
  9. 9
  10. 10 // 数组长度
  11. 11 #define LENGTH(array) ( (sizeof(array)) / (sizeof(array[0])) )
  12. 12
  13. 13 /*
  14. 14 * 希尔排序
  15. 15 *
  16. 16 * 参数说明:
  17. 17 * a -- 待排序的数组
  18. 18 * n -- 数组的长度
  19. 19 */
  20. 20 void shell_sort1(int a[], int n)
  21. 21 {
  22. 22 int i,j,gap;
  23. 23
  24. 24 // gap为步长,每次减为原来的一半。
  25. 25 for (gap = n / 2; gap > 0; gap /= 2)
  26. 26 {
  27. 27 // 共gap个组,对每一组都执行直接插入排序
  28. 28 for (i = 0 ;i < gap; i++)
  29. 29 {
  30. 30 for (j = i + gap; j < n; j += gap)
  31. 31 {
  32. 32 // 如果a[j] < a[j-gap],则寻找a[j]位置,并将后面数据的位置都后移。
  33. 33 if (a[j] < a[j - gap])
  34. 34 {
  35. 35 int tmp = a[j];
  36. 36 int k = j - gap;
  37. 37 while (k >= 0 && a[k] > tmp)
  38. 38 {
  39. 39 a[k + gap] = a[k];
  40. 40 k -= gap;
  41. 41 }
  42. 42 a[k + gap] = tmp;
  43. 43 }
  44. 44 }
  45. 45 }
  46. 46
  47. 47 }
  48. 48 }
  49. 49
  50. 50 /*
  51. 51 * 对希尔排序中的单个组进行排序
  52. 52 *
  53. 53 * 参数说明:
  54. 54 * a -- 待排序的数组
  55. 55 * n -- 数组总的长度
  56. 56 * i -- 组的起始位置
  57. 57 * gap -- 组的步长
  58. 58 *
  59. 59 * 组是"从i开始,将相隔gap长度的数都取出"所组成的!
  60. 60 */
  61. 61 void group_sort(int a[], int n, int i,int gap)
  62. 62 {
  63. 63 int j;
  64. 64
  65. 65 for (j = i + gap; j < n; j += gap)
  66. 66 {
  67. 67 // 如果a[j] < a[j-gap],则寻找a[j]位置,并将后面数据的位置都后移。
  68. 68 if (a[j] < a[j - gap])
  69. 69 {
  70. 70 int tmp = a[j];
  71. 71 int k = j - gap;
  72. 72 while (k >= 0 && a[k] > tmp)
  73. 73 {
  74. 74 a[k + gap] = a[k];
  75. 75 k -= gap;
  76. 76 }
  77. 77 a[k + gap] = tmp;
  78. 78 }
  79. 79 }
  80. 80 }
  81. 81
  82. 82 /*
  83. 83 * 希尔排序
  84. 84 *
  85. 85 * 参数说明:
  86. 86 * a -- 待排序的数组
  87. 87 * n -- 数组的长度
  88. 88 */
  89. 89 void shell_sort2(int a[], int n)
  90. 90 {
  91. 91 int i,gap;
  92. 92
  93. 93 // gap为步长,每次减为原来的一半。
  94. 94 for (gap = n / 2; gap > 0; gap /= 2)
  95. 95 {
  96. 96 // 共gap个组,对每一组都执行直接插入排序
  97. 97 for (i = 0 ;i < gap; i++)
  98. 98 group_sort(a, n, i, gap);
  99. 99 }
  100. 100 }
  101. 101
  102. 102 void main()
  103. 103 {
  104. 104 int i;
  105. 105 int a[] = {80,30,60,40,20,10,50,70};
  106. 106 int ilen = LENGTH(a);
  107. 107
  108. 108 printf("before sort:");
  109. 109 for (i=0; i<ilen; i++)
  110. 110 printf("%d ", a[i]);
  111. 111 printf("\n");
  112. 112
  113. 113 shell_sort1(a, ilen);
  114. 114 //shell_sort2(a, ilen);
  115. 115
  116. 116 printf("after sort:");
  117. 117 for (i=0; i<ilen; i++)
  118. 118 printf("%d ", a[i]);
  119. 119 printf("\n");
  120. 120 }

View Code

希尔排序C++实现
实现代码(ShellSort.cpp)

  1. 1 /**
  2. 2 * 希尔排序:C++
  3. 3 *
  4. 4 * @author skywang
  5. 5 * @date 2014/03/11
  6. 6 */
  7. 7
  8. 8 #include <iostream>
  9. 9 using namespace std;
  10. 10
  11. 11 /*
  12. 12 * 希尔排序
  13. 13 *
  14. 14 * 参数说明:
  15. 15 * a -- 待排序的数组
  16. 16 * n -- 数组的长度
  17. 17 */
  18. 18 void shellSort1(int* a, int n)
  19. 19 {
  20. 20 int i,j,gap;
  21. 21
  22. 22 // gap为步长,每次减为原来的一半。
  23. 23 for (gap = n / 2; gap > 0; gap /= 2)
  24. 24 {
  25. 25 // 共gap个组,对每一组都执行直接插入排序
  26. 26 for (i = 0 ;i < gap; i++)
  27. 27 {
  28. 28 for (j = i + gap; j < n; j += gap)
  29. 29 {
  30. 30 // 如果a[j] < a[j-gap],则寻找a[j]位置,并将后面数据的位置都后移。
  31. 31 if (a[j] < a[j - gap])
  32. 32 {
  33. 33 int tmp = a[j];
  34. 34 int k = j - gap;
  35. 35 while (k >= 0 && a[k] > tmp)
  36. 36 {
  37. 37 a[k + gap] = a[k];
  38. 38 k -= gap;
  39. 39 }
  40. 40 a[k + gap] = tmp;
  41. 41 }
  42. 42 }
  43. 43 }
  44. 44
  45. 45 }
  46. 46 }
  47. 47
  48. 48 /*
  49. 49 * 对希尔排序中的单个组进行排序
  50. 50 *
  51. 51 * 参数说明:
  52. 52 * a -- 待排序的数组
  53. 53 * n -- 数组总的长度
  54. 54 * i -- 组的起始位置
  55. 55 * gap -- 组的步长
  56. 56 *
  57. 57 * 组是"从i开始,将相隔gap长度的数都取出"所组成的!
  58. 58 */
  59. 59 void groupSort(int* a, int n, int i,int gap)
  60. 60 {
  61. 61 int j;
  62. 62
  63. 63 for (j = i + gap; j < n; j += gap)
  64. 64 {
  65. 65 // 如果a[j] < a[j-gap],则寻找a[j]位置,并将后面数据的位置都后移。
  66. 66 if (a[j] < a[j - gap])
  67. 67 {
  68. 68 int tmp = a[j];
  69. 69 int k = j - gap;
  70. 70 while (k >= 0 && a[k] > tmp)
  71. 71 {
  72. 72 a[k + gap] = a[k];
  73. 73 k -= gap;
  74. 74 }
  75. 75 a[k + gap] = tmp;
  76. 76 }
  77. 77 }
  78. 78 }
  79. 79
  80. 80 /*
  81. 81 * 希尔排序
  82. 82 *
  83. 83 * 参数说明:
  84. 84 * a -- 待排序的数组
  85. 85 * n -- 数组的长度
  86. 86 */
  87. 87 void shellSort2(int* a, int n)
  88. 88 {
  89. 89 int i,gap;
  90. 90
  91. 91 // gap为步长,每次减为原来的一半。
  92. 92 for (gap = n / 2; gap > 0; gap /= 2)
  93. 93 {
  94. 94 // 共gap个组,对每一组都执行直接插入排序
  95. 95 for (i = 0 ;i < gap; i++)
  96. 96 groupSort(a, n, i, gap);
  97. 97 }
  98. 98 }
  99. 99
  100. 100 int main()
  101. 101 {
  102. 102 int i;
  103. 103 int a[] = {80,30,60,40,20,10,50,70};
  104. 104 int ilen = (sizeof(a)) / (sizeof(a[0]));
  105. 105
  106. 106 cout << "before sort:";
  107. 107 for (i=0; i<ilen; i++)
  108. 108 cout << a[i] << " ";
  109. 109 cout << endl;
  110. 110
  111. 111 shellSort1(a, ilen);
  112. 112 //shellSort2(a, ilen);
  113. 113
  114. 114 cout << "after sort:";
  115. 115 for (i=0; i<ilen; i++)
  116. 116 cout << a[i] << " ";
  117. 117 cout << endl;
  118. 118
  119. 119 return 0;
  120. 120 }

View Code

希尔排序Java实现
实现代码(ShellSort.java)

  1. 1 /**
  2. 2 * 希尔排序:Java
  3. 3 *
  4. 4 * @author skywang
  5. 5 * @date 2014/03/11
  6. 6 */
  7. 7
  8. 8 public class ShellSort {
  9. 9
  10. 10 /**
  11. 11 * 希尔排序
  12. 12 *
  13. 13 * 参数说明:
  14. 14 * a -- 待排序的数组
  15. 15 * n -- 数组的长度
  16. 16 */
  17. 17 public static void shellSort1(int[] a, int n) {
  18. 18
  19. 19 // gap为步长,每次减为原来的一半。
  20. 20 for (int gap = n / 2; gap > 0; gap /= 2) {
  21. 21
  22. 22 // 共gap个组,对每一组都执行直接插入排序
  23. 23 for (int i = 0 ;i < gap; i++) {
  24. 24
  25. 25 for (int j = i + gap; j < n; j += gap) {
  26. 26
  27. 27 // 如果a[j] < a[j-gap],则寻找a[j]位置,并将后面数据的位置都后移。
  28. 28 if (a[j] < a[j - gap]) {
  29. 29
  30. 30 int tmp = a[j];
  31. 31 int k = j - gap;
  32. 32 while (k >= 0 && a[k] > tmp) {
  33. 33 a[k + gap] = a[k];
  34. 34 k -= gap;
  35. 35 }
  36. 36 a[k + gap] = tmp;
  37. 37 }
  38. 38 }
  39. 39 }
  40. 40 }
  41. 41 }
  42. 42
  43. 43 /**
  44. 44 * 对希尔排序中的单个组进行排序
  45. 45 *
  46. 46 * 参数说明:
  47. 47 * a -- 待排序的数组
  48. 48 * n -- 数组总的长度
  49. 49 * i -- 组的起始位置
  50. 50 * gap -- 组的步长
  51. 51 *
  52. 52 * 组是"从i开始,将相隔gap长度的数都取出"所组成的!
  53. 53 */
  54. 54 public static void groupSort(int[] a, int n, int i,int gap) {
  55. 55
  56. 56 for (int j = i + gap; j < n; j += gap) {
  57. 57
  58. 58 // 如果a[j] < a[j-gap],则寻找a[j]位置,并将后面数据的位置都后移。
  59. 59 if (a[j] < a[j - gap]) {
  60. 60
  61. 61 int tmp = a[j];
  62. 62 int k = j - gap;
  63. 63 while (k >= 0 && a[k] > tmp) {
  64. 64 a[k + gap] = a[k];
  65. 65 k -= gap;
  66. 66 }
  67. 67 a[k + gap] = tmp;
  68. 68 }
  69. 69 }
  70. 70 }
  71. 71
  72. 72 /**
  73. 73 * 希尔排序
  74. 74 *
  75. 75 * 参数说明:
  76. 76 * a -- 待排序的数组
  77. 77 * n -- 数组的长度
  78. 78 */
  79. 79 public static void shellSort2(int[] a, int n) {
  80. 80 // gap为步长,每次减为原来的一半。
  81. 81 for (int gap = n / 2; gap > 0; gap /= 2) {
  82. 82 // 共gap个组,对每一组都执行直接插入排序
  83. 83 for (int i = 0 ;i < gap; i++)
  84. 84 groupSort(a, n, i, gap);
  85. 85 }
  86. 86 }
  87. 87
  88. 88 public static void main(String[] args) {
  89. 89 int i;
  90. 90 int a[] = {80,30,60,40,20,10,50,70};
  91. 91
  92. 92 System.out.printf("before sort:");
  93. 93 for (i=0; i<a.length; i++)
  94. 94 System.out.printf("%d ", a[i]);
  95. 95 System.out.printf("\n");
  96. 96
  97. 97 shellSort1(a, a.length);
  98. 98 //shellSort2(a, a.length);
  99. 99
  100. 100 System.out.printf("after sort:");
  101. 101 for (i=0; i<a.length; i++)
  102. 102 System.out.printf("%d ", a[i]);
  103. 103 System.out.printf("\n");
  104. 104 }
  105. 105 }

View Code

 

上面3种实现的原理和输出结果都是一样的。下面是它们的输出结果:

  1. before sort:80 30 60 40 20 10 50 70
  2. after sort:10 20 30 40 50 60 70 80

 

posted on
2014-04-24 09:28 
如果天空不死 
阅读(42521
评论(12
编辑 
收藏 
举报

版权声明:本文为skywang12345原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/skywang12345/p/3597597.html