排序2-希尔排序

最新推荐文章于 2022-04-12 19:20:04 发布
最新推荐文章于 2022-04-12 19:20:04 发布
阅读量540 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwhlxl/article/details/46673523
版权

希尔排序（Shell Sort)

基本思想

先将整个待排元素序列分割成若干子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序（增量为1）

时间复杂度分析

希尔排序的时间复杂度跟选取步长序列有关，如上面的代码中，步长序列如果是 n/2i 的话，最坏的情况下的复杂度为 O(n2) ，步长序列如果是 (3k–1)/2 的话，最坏的情况下的复杂度为 O(n3/2) 。

代码实现

void Shell_sort(int arr[], int len)
{
    int increment = len / 2;

    while(increment)
    {
        for(int i = increment; i < len; i ++)
        {
            int key = arr[i];
            /*int j ;
            for(j = i; j >= increment; j -= increment)
            {
                if(arr[j-increment] > key )
                    arr[j] = arr[j-increment];
                else 
                    break;

            }*/

            int j = i;
            while(j >= increment && arr[j-increment] > key)
            {
                arr[j] = arr[j-increment];
                j -= increment;
            }

            arr[j] = key;
        }

        increment /= 2;
    }
}

void Shell_sort1(int arr[], int len)
{
    int increment = 0;
    for(increment = len/2; increment > 0; increment /=2)
    {
        for(int i = increment; i < len; i++)
        {
            int key = arr[i];
            int j = 0;
            for(j = i; j >= increment; j -=increment)
            {
                if(arr[j-increment] > key)
                    arr[j] = arr[j-increment];
                else 
                    break;
            }

            arr[j] = key;
        }
    }
}

void Shell_sort2(int arr[], int len)
{
    int index = log( 2*len + 1) / log(3.0);

    //cout << index << endl;

    int increment = ( pow(3.0, index) - 1 ) / 2;

    //cout << increment << endl;

    while(increment)
    {
        for(int i = increment; i < len; i ++)
        {
            int key = arr[i];
            /*int j ;
            for(j = i; j >= increment; j -= increment)
            {
                if(arr[j-increment] > key )
                    arr[j] = arr[j-increment];
                else 
                    break;

            }*/

            int j = i;
            while(j >= increment && arr[j-increment] > key)
            {
                arr[j] = arr[j-increment];
                j -= increment;
            }

            arr[j] = key;
        }
        index -= 1;
        increment = ( pow(3.0, index) - 1 ) / 2;
    }
}

测试代码

#include <iostream>
#include <cstring>
#include <ctime>
#include <cmath>
using namespace std;


#define ArraySize 100000


void swap(int *x, int *y)
{
    int temp;
    temp = *x;
    *x   = *y;
    *y   = temp;
}

void Bubble_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = i + 1; j < len; j ++)
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
    }
}

void Bubble_sort1(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = len - 1; j >= i; j --)
        {
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
        }
    }
}

void Bubble_sort2(int arr[], int len)
{
    bool flag = true;

    while(flag)
    {
        flag = false;
        for(int i = 0; i < len; i ++)
            for(int j = len - 1; j >= i; j --)
                if(arr[i] > arr[j])
                    swap(arr[i], arr[j]);
    }
}

void Slect_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        int min_index = i ;
        for(int j = i + 1; j < len; j ++)
        {
            if(arr[min_index] > arr[j])
                min_index = j;
        }

        if(i != min_index)
            swap(arr[i],arr[min_index]);
    }
}

void Insert_sort(int arr[], int len)
{

    for(int i= 1; i < len; i ++)
    {   
        int key = arr[i];
        int j = i;
        while(j && arr[j - 1] > key)
        {
            arr[j] = arr[j - 1];
            j --;
        }

        arr[j] = key;
    }
}

void Shell_sort(int arr[], int len)
{
    int increment = len / 2;

    while(increment)
    {
        for(int i = increment; i < len; i ++)
        {
            int key = arr[i];
            /*int j ;
            for(j = i; j >= increment; j -= increment)
            {
                if(arr[j-increment] > key )
                    arr[j] = arr[j-increment];
                else 
                    break;

            }*/

            int j = i;
            while(j >= increment && arr[j-increment] > key)
            {
                arr[j] = arr[j-increment];
                j -= increment;
            }

            arr[j] = key;
        }

        increment /= 2;
    }
}

void Shell_sort1(int arr[], int len)
{
    int increment = 0;
    for(increment = len/2; increment > 0; increment /=2)
    {
        for(int i = increment; i < len; i++)
        {
            int key = arr[i];
            int j = 0;
            for(j = i; j >= increment; j -=increment)
            {
                if(arr[j-increment] > key)
                    arr[j] = arr[j-increment];
                else 
                    break;
            }

            arr[j] = key;
        }
    }
}

void Shell_sort2(int arr[], int len)
{
    int index = log( 2*len + 1) / log(3.0);

    //cout << index << endl;

    int increment = ( pow(3.0, index) - 1 ) / 2;

    //cout << increment << endl;

    while(increment)
    {
        for(int i = increment; i < len; i ++)
        {
            int key = arr[i];
            /*int j ;
            for(j = i; j >= increment; j -= increment)
            {
                if(arr[j-increment] > key )
                    arr[j] = arr[j-increment];
                else 
                    break;

            }*/

            int j = i;
            while(j >= increment && arr[j-increment] > key)
            {
                arr[j] = arr[j-increment];
                j -= increment;
            }

            arr[j] = key;
        }
        index -= 1;
        increment = ( pow(3.0, index) - 1 ) / 2;
    }
}

void Print_array(int arr[], int len)
{
    for(int i = 0; i < len; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

}

int main(int argc, char const *argv[])
{
    /* code */
    int Array[ArraySize];
    int Array1[ArraySize];
    int Array2[ArraySize];

    time_t begin , end;

    srand(time(NULL));



    for(int i = 0; i < ArraySize; i ++)
    {
        Array[i] = rand()%ArraySize;
        //cout << Array[i] << " ";
    }

    memcpy(Array1, Array, ArraySize * sizeof(Array1[0]));
    memcpy(Array2, Array, ArraySize * sizeof(Array2[0]));

//  Print_array(Array, ArraySize);

/*  begin = clock();
    Bubble_sort2(Array, ArraySize);
    end = clock();
    cout << "Bubble_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Slect_sort(Array1, ArraySize);
    end = clock();
    cout << "Slect_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;*/  

    begin = clock();
    Insert_sort(Array2, ArraySize);
    end = clock();
    cout << "Insert_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Shell_sort1(Array1, ArraySize);
    end = clock();
    cout << "Shell_sort1 runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Shell_sort2(Array2, ArraySize);
    end = clock();
    cout << "Shell_sort2 runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;
    //Print_array(Array2, ArraySize);
    return 0;
}

运行结果如下，明显比插入排序快很多

Insert_sort runtime:   6.367s
Shell_sort1 runtime:   0.024s
Shell_sort2 runtime:   0.004s
zengwh513
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解Java常用排序算法-希尔排序
08-26
希尔排序的时间复杂度为 O(n^2)，但实际上它的性能比插入排序要好得多，特别是在大型列表上。希尔排序的性能取决于间隔序列的选择，但是目前还没有一种最优的间隔序列。 在 Java 中，希尔排序可以使用以下代码实现...
头歌：排序学习效果自测-练习题 | 快排、冒泡、堆排、归并、基数、递归、希尔、计数
Molly 的博客
02-06 733
基本思想是：首先用要查找的关键字k与中间位置的结点的关键字相比较，这个中间结点把线性表分成了两个子表，若比较结果相等则查找完成;若不相等，再根据k与该中间结点关键字的比较大小确定下一步查找哪个子表，这样递归进行下去，直到找到满足条件的结点或者该线性表中没有这样的结点。希尔排序每次是对划分的子表进行排序，得到局部有序的结果，所以不能保证每一趟排序结束都能确定一个元素的最终位置。不一定会位于最终的位置，因为不确定后面插入的元素对于前面的元素是否产生影响。选出的枢轴在一趟排序中就位于了它最终的位置。
算法-基本排序算法-04 希尔排序详解
半亩方糖
10-05 1135
算法-基本排序算法-04 希尔排序 目录1.要点2.动图演示2.1 先了解插入排序 InsertSort2.2 希尔排序ShellSort 就是在多次不同增量的插入排序3.（重点） 理解增量increment3.1 增量increment = 4 的时候.3.2增量为 2的时候3.3 增量为 1 ，最后一次排序4.算法步骤5.代码6 代码解释5. 优缺点 1.要点 希尔排序就是多次不同增量（increment）的插入排序，是跳跃性的插入排序。 增量的理解是重点和难点 2.动图演示 2.1 先了解插入排序
排序算法-希尔排序20220412
beConcentration的博客
04-12 416
希尔排序的思想是，在拿到无序数组后，我们首先对这个数组进行一个粗略的排序，让整个数组没那么无序之后，再进行插入排序，是对插入排序的一个优化升级。 而怎样确定这个粗略的排序有多粗呢，这涉及到一个增量序列的概念，我们要根据增量序列逐次将数组分成多个小的无序数组，然后将每个小的无序数组通过插入排序进行有序化，最终跨度为1将对这个初步有序数组进行最后的插入排序。 增量序列默认为shell增量每次增量折半，比如8,4,2,1，而后期的优化中比较出名的有：Hibbard增量和 Sedgewick增量等，这个不在排序的范
可视化排序之 - 希尔排序-易语言
06-12
希尔排序是一种基于插入排序的快速排序算法，由Donald Shell于1959年提出。它通过将待排序的数组元素按某个增量分组，然后对每组进行直接插入排序，随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，...
C语言的数据结构-希尔排序
03-08
附件提供的是C语言实现的希尔排序的代码，同时提供了代码实现的结果
基于python的排序算法-希尔排序Shell Sort
06-25
希尔排序的时间复杂度与所选的增量序列有关，最坏情况下可达到O(n^2)，但通常情况下其平均时间复杂度为O(n^(3/2))，比原始的插入排序有了显著的提升。由于其不稳定性（即相等元素可能会改变相对顺序），希尔排序在...
数据结构从入门到精通-希尔排序
最新发布
03-19
数据结构从入门到精通-希尔排序
分治算法例子集锦
热门推荐
zengwh
03-07 2万+
分治算法例子集锦
动态规划（DP）之入门学习-数字三角形
zengwh
05-29 2万+
数字三角形案例题目描述 Description下图给出了一个数字三角形，请编写一个程序，计算从顶至底的某处的一条路径，使该路径所经过的数字的总和最大。 （1）每一步可沿左斜线向下或右斜线向下 （2）1 < 三角形行数 < 100 （3）三角形数字为0，1，…99 输入描述 Input Description有很多个测试案例，对于每一个测试案例， 通过键盘逐行输入，第1行是输入整数（如
二叉树最大深度和最小深度
zengwh
08-12 1万+
二叉树的最大深度给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的距离。如果二叉树为空，则深度为0 如果不为空，分别求左子树的深度和右子树的深度，去最大的再加1，因为根节点深度是1，要加进去。int maxDepth(TreeNode *root) { // write your code (here) if(root == NULL)
散列表-开放地址法和链地址法的实现
zengwh
06-30 9894
基本定义散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系 f，使得每个关键字key对应一个存储位置f(key)。这种对应关系f称为散列或哈希函数。采用上述思想将数据存储在一块连续的存储空间中，这块连续的存储空间称为散列或哈希表。关键字对应的存储位置称为散列地址。散列技术最适合的求解问题是查找与给定值相等的记录。 如果碰到两个不同的关键字key1≠key2key_1 \neq key
数组和链表的归并排序算法实现（C语言）
zengwh
03-05 9393
数组和链表的归并排序算法实现（C语言）
后缀表达式的栈实现(C语言）
zengwh
01-21 6951
中缀表达式转为后缀表达式的栈实现以及计算(C语言）
图的表示-邻接矩阵表示
zengwh
04-15 6830
描述图的邻接矩阵（Adjacency Matrix）表示是采用二维数组的方式。通过邻接矩阵可以立刻看出两顶点之间是否存在一条边，只需要检查邻接矩阵重行i和列j是否是非零值。对于无向图，邻接矩阵是对称的。下图是摘自《算法：C语言实现》 代码实现#include <iostream> using namespace std; const int VERTEX_NUM = 20; // 顶点的最
翻转二叉树（递归与非递归）
zengwh
08-12 6337
翻转一棵二叉树样例 1 1 / \ / \ 2 3 => 3 2 / \ 4 4 递归版本先翻转左子树，后翻转右子树，然后对整个树进行翻转void swapTree(TreeNode *&root){ TreeNode *tmp = root->left; root->left = root->right
【面试题】-判断两个单链表是否相交并求出相交的第一结点
zengwh
05-15 5948
问题描述判断两个单链表是否相交,如果相交，给出相交的第一个点（假设两个链表都不存在环）。相交的链表示意图如下所示。 解题思路方法一两个没有环的链表如果是相交于某一结点，如上图所示，这个结点后面都是共有的。所以如果两个链表相交，那么两个链表的尾结点的地址也是一样的。程序实现时分别遍历两个单链表，直到尾结点。判断尾结点地址是否相等即可。时间复杂度为O(L1+L2)。方法二代码实现方法一void Is_
最大子序列问题
zengwh
01-12 4955
最大子序列的三种算法求解
高精度计算-大整数乘法
zengwh
05-04 4655
大整数乘法问题描述求两个不超过 200 位的非负整数的积。 输入数据 有两行,每行是一个不超过 200 位的非负整数,没有多余的前导 0。 输出要求 一行,即相乘后的结果。结果里不能有多余的前导 0,即如果结果是 342,那么就不能 输出为 0342。输入样例 12345678900 98765432100 输出样例 1219326311126352690000解题思路乘法规律，一
C. DS排序--希尔排序
06-03
希尔排序的时间复杂度与间隔序列的选择有关，最坏时间复杂度为$O(n^2)$，平均时间复杂度为$O(n \log n)$。相比于插入排序，希尔排序的时间复杂度有了明显的提升，且其在实际应用中也表现得比插入排序好。 下面是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值