八大排序算法(2) 希尔排序

基本思想

希尔排序是直接插入排序的优化版。
对比直接插入排序的一个位置一个位置的移动,希尔排序则是放大移动的步数,让元素一开始就更快的接近它终点所在的位置,以此减少移动元素的次数。
然后逐渐缩小移动的步数,直至步数为 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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值