基本思想
希尔排序是直接插入排序的优化版。
对比直接插入排序的一个位置一个位置的移动,希尔排序则是放大移动的步数,让元素一开始就更快的接近它终点所在的位置,以此减少移动元素的次数。
然后逐渐缩小移动的步数,直至步数为 1 时,排序结束。
步数的缩小算法一般是指数级的, 假如 序列长度为 n, 那么 step = n/2, step /= 2。
示例:
// 升序,左起
/*初始值*/ 3, 10, 1, 5, 7, 2, 4, 9, 6
|____________|___________| // step = (9 / 2 = 4)
|___________|
|___________|
|___________|
/*第一趟*/ 3, 2, 1, 5, 6, 10,4, 9, 7 // step = (4 / 2 = 2)
|______|_____|_____|_____|
|______|______|____|
/*第二趟*/ 1, 2, 3, 5, 4, 9, 6, 10,7 // step = (2 / 1 = 1)
/*第三趟*/ 1, 2, 3, 4, 5, 6, 7, 9,10
// 每一趟都是简单插入排序
可以这么理解,将 长度为 n 的序列, 分成 n / step 个子序列, 然后分别对子序列进行直接插入排序。
如, 第一趟排序中, 将序列 分成了 {3, 7,6} { 10, 2} {1 ,4 } {5 , 9} 四个子序列,分别插入排序后为 {3,6,7} { 2, 10} {1 ,4 } {5 , 9},还原后的序列则为{3,2,1,5,6,10,4,9,7}
第二趟排序中,分为{3,1,6,4,7} {2,5,10,9} 两个个子序列,分别插入排序后 {1, 3, 4, 6,7} {2, 5, 9,10}, 还原后{1, 2, 3, 5, 4, 9, 6, 10, 7}
三趟排序就是直接排序了。
可以看出,每一次移动的跨度相对插入排序要大,插入排序每次移动一格,而希尔排序移动的步数大很多,每个节点也就越接近终点位置。
代码
void printList(int *l, int n) {
for (int i = 0; i < n; i++) {
printf("%d ", l[i]);
}
printf("\n");
}
// 插入排序,插入步长为 jp
void shellInsertSort(int *a, int n, int jp) {
// 直接插入排序的 jp 为1,一格一格移动
for (int i = jp; i < n; i++ ) {
// 插入的跨度 为 jp,但循环的 step 仍然为 1
int k = a[i];
// 要插入的位置
int index = i;
for ( int j = i - jp; j >= 0; j = j - jp){
if ( a[j] > k ){
// 如果 j 节点的值大于 k,那么就将 j 节点后移jp位,并更新插入位置
a[j + jp] = a[j];
index = j;
printList(a, 8);
}
else {
break;
}
}
a[index] = k;
printList(a, 8);
printf("\n");
}
}
// 先按长度的一半分组,然后指数缩小,直到缩小为1,此时则是直接插入排序了
void shellSort(int *a, int n) {
int step = 2;
int jp = n / step; // 第一次分组
while (jp >= 1) {
shellInsertSort(a, n, jp);
jp /= step;
}
}
int main() {
int a[9] = { 3, 10, 1,5,7,2,4,9,6 };
printList(a, 9);
// 直接插入排序
//shellInsertSort(a, 9, 1);
// 希尔排序
shellSort(a, 9);
printList(a, 9);
system("pause");
return 0;
}
看似有三层循环,但时间复杂度是 n*(logn)^2,只需要知道时间复杂度比 直接插入排序小就行了,以后再解释。
以上
原文链接 http://blog.csdn.net/u011546766/article/details/74034815