排序算法之希尔排序(4)

最新推荐文章于 2024-08-29 22:25:44 发布
最新推荐文章于 2024-08-29 22:25:44 发布
阅读量80 收藏
点赞数
分类专栏： 算法之旅
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46701838/article/details/113058219
版权

希尔排序 交换法 移位法 排序算法 性能测试
关键词由CSDN通过智能技术生成

4.希尔排序

插入排序存在的问题：

2,3,4,5,6,7,1

希尔排序针对插入排序存在的问题，做出了改进

4.1排序思路

在这里插入图片描述

4.1具体实现

1.交换法

1.第一轮排序
public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shellSort(int[] array) {
        //第一轮排序
        //将10个数据分成了5组10/2=5
        int temp = 0;
        for (int i = 5; i < array.length; i++) {
            //从第一元素开始配对做比较
            for (int j = i - 5; j >= 0; j -= 5) {
                if (array[j] > array[j + 5]) {
                    temp = array[j];
                    array[j] = array[j + 5];
                    array[j + 5] = temp;
                }

            }
        }
    }
}

[3, 5, 1, 6, 0, 8, 9, 4, 7, 2]
2.第二轮排序
public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shellSort(int[] array) {
        //第一轮排序
        //将10个数据分成了5组 10/2=5
        int temp = 0;
        for (int i = 5; i < array.length; i++) {
            //从第一元素开始配对做比较
            for (int j = i - 5; j >= 0; j -= 5) {
                if (array[j] > array[j + 5]) {
                    temp = array[j];
                    array[j] = array[j + 5];
                    array[j + 5] = temp;
                }
            }
        }
        //第二轮排序
        //将10个数组分成了2组 10/2=5/2=2
        for (int i = 2; i < array.length; i++) {
            //从第一元素开始配对做比较
            for (int j = i - 2; j >= 0; j -= 2) {
                if (array[j] > array[j + 2]) {
                    temp = array[j];
                    array[j] = array[j + 2];
                    array[j + 2] = temp;
                }
            }
        }        
    }
}

[0, 2, 1, 4, 3, 5, 7, 6, 9, 8]
3.第三轮排序
public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shellSort(int[] array) {
        //第一轮排序
        //将10个数据分成了5组 10/2=5
        int temp = 0;
        for (int i = 5; i < array.length; i++) {
            //从第一元素开始配对做比较
            for (int j = i - 5; j >= 0; j -= 5) {
                if (array[j] > array[j + 5]) {
                    temp = array[j];
                    array[j] = array[j + 5];
                    array[j + 5] = temp;
                }
            }
        }
        //第二轮排序
        //将10个数组分成了2组 10/2=5/2=2
        for (int i = 2; i < array.length; i++) {
            //从第一元素开始配对做比较
            for (int j = i - 2; j >= 0; j -= 2) {
                if (array[j] > array[j + 2]) {
                    temp = array[j];
                    array[j] = array[j + 2];
                    array[j + 2] = temp;
                }
            }
        }
        //第三轮排序
        //将10个数组分成了1组 10/2=5/2=2/2=1
        //使用插入排序
        for (int i = 1; i < array.length; i++) {
            //从第一元素开始配对做比较
            for (int j = i - 1; j >= 0; j -= 1) {
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
4.代码优化
public class ShellSort1 {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shellSort(int[] array) {
        int temp = 0;
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < array.length; i++) {
                //从第一元素开始配对做比较
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (array[j] > array[j + gap]) {
                        temp = array[j];
                        array[j] = array[j + gap];
                        array[j + gap] = temp;
                    }
                }
            }
        }
    }
}

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

2.移位法

public class ShellSort2 {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shellSort(int[] array) {
        //分组
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < array.length; i++) {
                int insertIndex = i;
                int insertVal = array[insertIndex];
                //比较配对的两个数的大小
                while (insertIndex -gap>= 0 && insertVal<array[insertIndex-gap]){
                    array[insertIndex]=array[insertIndex-gap];
                    insertIndex-=gap;
                }
                array[insertIndex]=insertVal;
            }
        }
    }
}


[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

4.2测试希尔排序算法速度

1.交换法

public class ShellSort1 {
    public static void main(String[] args) {
//        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
//        shellSort(arr);
//        System.out.println(Arrays.toString(arr));
        int[] arr=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i]=(int)(Math.random()*800000);
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format1 = simpleDateFormat1.format(date1);
        System.out.println("排序前的时间是："+format1);
        shellSort(arr);
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format2 = simpleDateFormat2.format(date2);
        System.out.println("排序后的时间是："+format2);
    }

    public static void shellSort(int[] array) {
        int temp = 0;
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < array.length; i++) {
                //从第一元素开始配对做比较
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (array[j] > array[j + gap]) {
                        temp = array[j];
                        array[j] = array[j + gap];
                        array[j + gap] = temp;
                    }
                }
            }
        }
    }
}

排序前的时间是：2021-01-09 13:38:40
排序后的时间是：2021-01-09 13:38:51

速度反而比插入排序慢，没有必要

2.移位法

public class ShellSort2 {
    public static void main(String[] args) {
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 800000);
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format1 = simpleDateFormat1.format(date1);
        System.out.println("排序前的时间是：" + format1);
        shellSort(arr);
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format2 = simpleDateFormat2.format(date2);
        System.out.println("排序后的时间是：" + format2);
    }

    public static void shellSort(int[] array) {
        //分组
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < array.length; i++) {
                int insertIndex = i;
                int insertVal = array[insertIndex];
                //比较配对的两个数的大小
                while (insertIndex -gap>= 0 && insertVal<array[insertIndex-gap]){
                    array[insertIndex]=array[insertIndex-gap];
                    insertIndex-=gap;
                }
                array[insertIndex]=insertVal;
            }
        }
    }
}


排序前的时间是：2021-01-09 14:06:10
排序后的时间是：2021-01-09 14:06:10
Coder-liu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python-十大排序算法之希尔排序
08-07
python python_十大排序算法之希尔排序
Java希尔排序
Emperor_Hd的博客
06-21 612
希尔排序也是十大经典排序算法之一，其原理和代码实现都不太好理解，要结合图才容易理解(可以参考这里)。 算法步骤 它通过比较相距一定间隔的元素大小先排序，然后每次比较所用的距离随着算法的进行而减小，知道只比较相邻元素的最后一趟排序位置，算是插入排序的升级版。 代码实现 public static void main(String[] args) { int[] arr = {50,15,56,...
Java经典排序算法之希尔排序详解
08-30
希尔排序(Shell Sort)是一种基于插入排序的高效排序算法，由Donald Shell于1959年提出。它的核心思想是通过设置一系列的增量序列来逐步减少元素间的距离，从而优化插入排序的过程。希尔排序的基本步骤如下： 1. **...
JS排序算法之希尔排序与快速排序实现方法
10-18
Hoare在1960年提出，是目前最常用的内部排序算法之一。它采用分治策略，通过选取一个基准值(pivot)，将数组分为两部分，一部分元素小于基准值，另一部分大于基准值，然后对这两部分分别进行快速排序，最后将结果...
C++ 算法之希尔排序详解及实例
08-30
C++ 算法之希尔排序详解及实例 希尔排序是一种高效的排序算法，属于插入排序的一种。下面是关于希尔排序的详细知识点： 一、希尔排序定义： 希尔排序是一种插入排序，可以看作是直接插入排序的改进版本。该算法将...
算法的学习笔记—连续子数组的最大和
业精于勤，荒于嬉
08-29 653
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
递归、搜索与回溯算法
无聊_人的博客
08-29 158
所谓的递归其实就是函数自己调用自己的情况。
力扣（无重叠区间）
yyssas的博客
08-29 70
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 320
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
C语言刷题日记(附详解)(2)
ixiaotang_的博客
08-24 3479
你所厌恶的今天，是昨天死去之人奢望的明天。你所浪费的现在，是未来的你回不去的曾经。时间如此宝贵，作为学生，学习就是我们的职责，那么不要懈怠！让我们开始今天的学习吧！
字节跳动（社招）三面算法原题
宫水三叶的刷题日记
08-29 455
但当招聘市场"供过于求"的时候，为了不让招聘过程显得突兀（距离招聘截止日期还有很久，但人已招满），这时候通常会卡住一些流程，尽量拖时间，此时越到后面要求越高，希望越少。当我们有了所有排好序的候选边集合之后，我们可以对边进行从前往后处理，每次加入一条边之后，使用并查集来查询「起点」和「终点」是否连通（并查集部分）。所以，虽然目前某些字节跳动的 BU 已经开始拖流程，但在下半年，必然会有新业务大量招兵买马，抓紧准备吧各位。你每次可以往「上，下，左，右」四个方向之一移动，你想要找到耗费体力最小的一条路径。
【数据结构-二维前缀和】【含空间优化】力扣3070. 元素和小于等于 k 的子矩阵的数目
sjsjs11的博客
08-29 156
col_sum[j]在遍历行的时候，也会依次计算该列的元素和，要计算前缀和s，实际上就是目前该列的元素和逐列累加，当发现s大于k的时候，那么就停止该行接下来的前缀和，继续计算下一行第一列开始的前缀和，继续遍历行的某个位置的前缀和。这种方法就是传统的前缀和做法，在这道题中，如果group[i][j]小于k，则继续遍历，然后count增加，如果group[i][j]大于k，说明不需要继续遍历这一行接下来列的前缀和了，直接开始计算新一行每一列的前缀和。返回包含 grid 左上角元素、元素和小于或等于 k 的。
【算法】深入浅出聚类算法：原理、应用与Java实现
一个不断前行的程序者
08-26 1800
聚类算法是一种将数据集中的对象自动划分为多个子集的算法。每个子集称为一个簇，簇内的对象具有较高的相似度，而簇与簇之间的相似度较低。聚类算法的主要目的是发现数据中的自然结构，而不是通过已知的类别标签。本文介绍了聚类算法的原理、应用场景以及如何在Java中实现一个简单的聚类算法。通过聚类算法，我们可以发现数据集中的自然结构，有助于更好地理解数据。在实际应用中，可以根据具体需求选择合适的聚类算法。希望本文能够帮助读者更好地理解和应用聚类算法。
树上dp+分组背包类问题
最新发布
2301_80475191的博客
08-29 198
今天也是无意间看到了一个树上dp+分组背包类的问题，有些难度的，不好想的嘞，话不多说直接看题。
河南萌新2024第二场
2301_80281705的博客
08-25 348
将用户名和对应信息set映射到map中: map< string ,set< string > > 方便了存储。给两个整数a和b，输出a∗b 但是a,b非常大，0
超分之最近邻插值、线性插值、双线性插值、双三次插值原理
weixin_44342777的博客
08-25 920
超分用于对照实验，或生成低分辨率数据集的常用插值方式：最近邻插值、线性插值、双线性插值、双三次插值的实现原理
【算法】动态规划
小匠码农
08-26 1930
动态规划、最长公共子序列
算法学习019 BFS实现迷踪步 c++算法学习 中小学算法思维学习 比赛算法题解 信奥算法解析
青少年编程学习指导
08-25 1564
​ C++BFS实现迷踪步 一、题目要求 1、编程实现 有一个 n 行 m列的方格迷宫，用 0 表示可以通过，用 1 表示不可以通过，每一步可以向上、下、左、右任意方向移动一格，请计算从左上角(1，1)位置移动到右下角(n，m)位置，最少移动多少步？ 2、输入输出 输入描述：第一行输入矩阵大小n和m（3
迭代器的失效问题
qq_58158950的博客
08-24 643
同理再看这段代码，在所有偶数元素位置前插入一个该偶遇元素减去1的元素。
排序算法大全：快速排序、希尔排序、插入排序等
快速排序算法是常用的排序算法之一，通过测试，快速排序算法的速度远远超过其他排序算法。在本文中，我们将对快速排序算法、希尔排序算法、插入排序算法和冒泡排序算法进行介绍和比较。 一、快速排序算法 快速排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值