精华内容
下载资源
问答
  • Java希尔排序算法代码实现时间:2017-08-30来源:华清远见JAVA学院什么是Java希尔排序算法呢?希尔排序算法实际上是一种分组插入的排序算法,又被称为缩小增量排序。今天华清Java学院小编就来和大家分享下Java希尔...

    Java希尔排序算法代码实现

    时间:2017-08-30     来源:华清远见JAVA学院

    什么是Java希尔排序算法呢?

    希尔排序算法实际上是一种分组插入的排序算法,又被称为缩小增量排序。今天华清Java学院小编就来和大家分享下Java希尔排序算法代码实现。

    Java希尔排序算法是的基本思想是:先取一个小于n的整数d1作为第一个增量,把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插人排序;然后,取第二个增量d2

    对于插入排序而言,如果原数组是基本有序的,那排序效率就可大大提高。另外,对于数量较小的序列使用直接插入排序,会因需要移动的数据量少,其效率也会提高。因此,希尔排序具有较高的执行效率,其实现原理如下图。

    8e31c494102932c56e0c2cdb085c290f.png

    Java希尔排序算法实现原理图

    Java希尔排序算法实现示例代码如下:

    public static void shellSortSmallToBig(int[] data) {

    int j = 0;

    int temp = 0;

    for (int increment = data.length / 2; increment > 0; increment /= 2) {

    System.out.println("increment:" + increment);

    for (int i = increment; i < data.length; i++) {

    // System.out.println("i:" + i);

    temp = data[i];

    for (j = i - increment; j >= 0; j -= increment) {

    // System.out.println("j:" + j);

    // System.out.println("temp:" + temp);

    // System.out.println("data[" + j + "]:" + data[j]);

    if (temp < data[j]) {

    data[j + increment] = data[j];

    } else {

    break;

    }}

    data[j + increment] = temp;

    }

    for (int i = 0; i < data.length; i++)

    System.out.print(data[i] + " ");

    }}

    public static void main(String[] args) {

    int[] data = new int[] { 26, 53, 67, 48, 57, 13, 48, 32, 60, 50 };

    shellSortSmallToBig(data);

    System.out.println(Arrays.toString(data));

    }

    展开全文
  • 16_希尔排序算法 一、问题导入 简单插入排序存在的问题 ​ 我们看简单的插入排序可能存在的问题. ​ 数组 arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是: {2,3,4,5,6,6} {2,3,4,5,5,6} {2,3,4,4,5,6...

    16_希尔排序算法

    一、问题导入

    简单插入排序存在的问题

    ​ 我们看简单的插入排序可能存在的问题.

    ​ 数组 arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是:

    {2,3,4,5,6,6}
    {2,3,4,5,5,6}
    {2,3,4,4,5,6}
    {2,3,3,4,5,6}
    {2,2,3,4,5,6}
    {1,2,3,4,5,6}
    

    ​ 结论:当需要插入的数是较小的数时,后移的次数明显增多,对效率有影响。

    二、希尔排序介绍

    2.1 希尔排序基本介绍

    ​ 希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序

    2.2 希尔排序基本思想

    ​ 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。下图为希尔排序算法的示意图。
    在这里插入图片描述

    三、希尔算法代码实现

    3.1 交换法

    3.1.1 逐步分解希尔排序

    //定义未排序数组
    int[] arr = {8,9,1,7,2,3,5,4,6,0};
    
    //逐步推导便于理解
    //希尔排序的第1轮排序
    //因为第1轮排序,是将10个数据分成了5组
    for (int i = 5; i < arr.length; i++) {
        //遍历各组中所有的元素(共5组,每组2个元素,即步长为5)
        for (int j = i - 5; j >= 0; j -= 5) {
            //如果当前元素大于加上步长后的那个元素,说明需要交换
            if (arr[j] > arr[j + 5]){
                arr[j] = arr[j] + arr[j + 5];
                arr[j + 5] = arr[j] - arr[j + 5];
                arr[j] = arr[j] - arr[j + 5];
            }
        }
    }
    System.out.println("数组在希尔排序一轮后:" + Arrays.toString(arr));
    
    //希尔排序的第2轮排序
    //因为第2轮排序,是将10个数据分成了5/2=2组
    for (int i = 2; i < arr.length; i++) {
        //遍历各组中所有的元素(共5组,每组2个元素,即步长为5)
        for (int j = i - 2; j >= 0; j -= 2) {
            //如果当前元素大于加上步长后的那个元素,说明需要交换
            if (arr[j] > arr[j + 2]){
                arr[j] = arr[j] + arr[j + 2];
                arr[j + 2] = arr[j] - arr[j + 2];
                arr[j] = arr[j] - arr[j + 2];
            }
        }
    }
    System.out.println("数组在希尔排序二轮后:" + Arrays.toString(arr));
    
    //希尔排序的第3轮排序
    //因为第3轮排序,是将10个数据分成了2/2=1组
    for (int i = 1; i < arr.length; i++) {
        //遍历各组中所有的元素(共5组,每组2个元素,即步长为5)
        for (int j = i - 1; j >= 0; j--) {
            //如果当前元素大于加上步长后的那个元素,说明需要交换
            if (arr[j] > arr[j + 1]){
                arr[j] = arr[j] + arr[j + 1];
                arr[j + 1] = arr[j] - arr[j + 1];
                arr[j] = arr[j] - arr[j + 1];
            }
        }
    }
    System.out.println("数组在希尔排序三轮后:" + Arrays.toString(arr));
    

    3.1.2 使用for循环进行代码整合

    //定义未排序数组
    int[] arr = {8,9,1,7,2,3,5,4,6,0};
    
    //计数器对希尔排序的次数进行计数
    int count = 0;
    //根据逐步分析,使用循环处理
    for (int gap = arr.length/2; gap > 0; gap /= 2) {
        for (int i = gap; i < arr.length; i++) {
            //遍历各组中所有的元素(共有gap组,每组 个元素,即步长为gap)
            for (int j = i - gap; j >= 0; j -= gap) {
                //如果当前元素大于加上步长后的那个元素,说明需要交换
                if (arr[j] > arr[j + gap]){
                    arr[j] = arr[j] + arr[j + gap];
                    arr[j + gap] = arr[j] - arr[j + gap];
                    arr[j] = arr[j] - arr[j + gap];
                }
            }
        }
        System.out.println("数组在希尔排序第" + (++count) + "轮后:" + Arrays.toString(arr));
    }
    

    3.1.3 交换法代码整合

    import java.util.Arrays;
    
    public class ShellSort {
        public static void main(String[] args) {
            int[] arr = {8,9,1,7,2,3,5,4,6,0};
            System.out.println("数组未排序时:" + Arrays.toString(arr));
            shellSort(arr);
        }
    
        //希尔排序
        public static void shellSort(int[] arr){
            //计数器对希尔排序的次数进行计数
            int count = 0;
            //根据逐步分析,使用循环处理
            for (int gap = arr.length/2; gap > 0; gap /= 2) {
                for (int i = gap; i < arr.length; i++) {
                    //遍历各组中所有的元素(共有gap组,每组 个元素,即步长为gap)
                    for (int j = i - gap; j >= 0; j -= gap) {
                        //如果当前元素大于加上步长后的那个元素,说明需要交换
                        if (arr[j] > arr[j + gap]){
                            arr[j] = arr[j] + arr[j + gap];
                            arr[j + gap] = arr[j] - arr[j + gap];
                            arr[j] = arr[j] - arr[j + gap];
                        }
                    }
                }
                System.out.println("数组在希尔排序第" + (++count) + "轮后:" + Arrays.toString(arr));
            }
            System.out.println("数组在希尔排序后:" + Arrays.toString(arr));
        }
    }
    

    3.2 移位法

    import java.util.Arrays;
    
    public class ShellSort {
        public static void main(String[] args) {
            int[] arr = {8,9,1,7,2,3,5,4,6,0};
            System.out.println("数组未排序时:" + Arrays.toString(arr));
            shellSort2(arr);
        }
        
    	//对交换式的希尔排序进行优化   交换法 --> 移位法
        public static void shellSort2(int[] arr) {
            //计数器对希尔排序的次数进行计数
            int count = 0;
            //增量为gap,并逐步的缩小增量
            for (int gap = arr.length / 2; gap > 0; gap /= 2) {
                //从第gap个元素开始,逐个对其所在的组进行直接插入排序
                for (int i = gap; i < arr.length; i++) {
                    int j = i;
                    int temp = arr[i];
                    if (arr[j] < arr[j - gap]){
                        while (j- gap >= 0 && temp < arr[j - gap]){
                            //移动
                            arr[j] = arr[j - gap];
                            j -= gap;
                        }
                        //当退出while循环后,就给temp找到了插入的位置
                        arr[j] = temp;
                    }
                }
                System.out.println("数组在希尔排序第" + (++count) + "轮后:" + Arrays.toString(arr));
            }
            System.out.println("数组在希尔排序后:" + Arrays.toString(arr));
        }
    }
    

    移位法的时间复杂度远胜于交换法。

    展开全文
  • java 算法希尔排序一、思想希尔排序:使数组中任意间隔为h的元素都是有序的。在进行排序的时候,如果h很大,我们就能将元素移动到很远的地方,为实现更小的h有序创造方便。用这种方式,对任意以1结尾的h序列,我们...

    java 算法之希尔排序

    一、思想

    希尔排序:使数组中任意间隔为h的元素都是有序的。在进行排序的时候,如果h很大,我们就能将元素移动到很远的地方,为实现更小的h有序创造方便。用这种方式,对任意以1结尾的h序列,我们都能够将数据排序;

    二、概念

    h有序数组:任意间隔为h的元素都是有序的数组;

    三、高效原因

    对于大规模乱序数组插入排序很慢,因为它只会交换相邻的元素,因此元素只能一点一点地从数组的一端移动到另一段;

    希尔排序更高效的原因:它权衡了子数组的规模和有序性,在排序之初,各个子数组都很短;在排序之后子数组都是部分有序的,这两种情况很适合插入排序;

    四、代码

    /**

    * 希尔排序

    *

    * @author pengcx

    *

    */

    public class Shell extends Sort {

    public static void main(String[] args) {

    String[] a = { "d", "a", "w", "b", "q" };

    Shell.sort(a);

    show(a);

    }

    /**

    * 排序数组a

    *

    * @param a

    * 排序的数组a

    */

    protected static void sort(Comparable[] a) {

    int N = a.length;

    int h = 1;

    while (h < N / 3) {

    h = 3 * h + 1;

    }

    while (h >= 1) {

    for (int i = 0; i < N; i++) {

    for (int j = i; j >= h && less(a[j], a[j - h]); j -= h) {

    exch(a, j, j - h);

    }

    }

    h = h / 3;

    }

    }

    }

    感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    展开全文
  • java实现希尔排序算法

    2020-12-18 15:25:26
    希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。 简单插入排序很循规蹈矩,不管数组...

    排序算法传送:

    排序算法——java实现冒泡排序
    排序算法——java实现选择排序
    排序算法——java实现直接插入排序
    排序算法——java实现二分法排序
    排序算法——java实现希尔排序
    排序算法——java实现快速排序

    希尔排序

    1、算法思想

    希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。

    简单插入排序很循规蹈矩,不管数组分布是怎么样的,依然一步一步的对元素进行比较,移动,插入,比如[5,4,3,2,1,0]这种倒序序列,数组末端的0要回到首位置很是费劲,比较和移动元素均需n-1次。而希尔排序在数组中采用跳跃式分组的策略,通过某个增量将数组元素划分为若干组,然后分组进行插入排序,随后逐步缩小增量,继续按组进行插入排序操作,直至增量为1。希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序,小的基本在前,大的基本在后。然后缩小增量,到增量为1时,其实多数情况下只需微调即可,不会涉及过多的数据移动。

    我们来看下希尔排序的基本步骤,在此我们选择增量gap=length/2,缩小增量继续以gap = gap/2的方式,这种增量选择我们可以用一个序列来表示,{n/2,(n/2)/2…1},称为增量序列。希尔排序的增量序列的选择与证明是个数学难题,我们选择的这个增量序列是比较常用的,也是希尔建议的增量,称为希尔增量,但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

    在这里插入图片描述
    2、代码实现

    在希尔排序的理解时,我们倾向于对于每一个分组,逐组进行处理,但在代码实现中,我们可以不用这么按部就班地处理完一组再调转回来处理下一组(这样还得加个for循环去处理分组)比如[5,4,3,2,1,0] ,首次增量设gap=length/2=3,则为3组[5,2] [4,1] [3,0],实现时不用循环按组处理,我们可以从第gap个元素开始,逐个跨组处理。同时,在插入数据时,可以采用元素交换法寻找最终位置,也可以采用数组元素移动法寻觅。希尔排序的代码比较简单,如下:

    package sortdemo;
    import java.util.Arrays;
    public class ShellSort {
        public static void main(String []args){
            int []arr ={1,4,2,7,9,8,3,6};
            sort(arr);
            System.out.println(Arrays.toString(arr));
            int []arr1 ={1,4,2,7,9,8,3,6};
            sort1(arr1);
            System.out.println(Arrays.toString(arr1));
        }
    
        /**
         * 希尔排序 针对有序序列在插入时采用交换法
         * @param arr
         */
        public static void sort(int []arr){
            //增量gap,并逐步缩小增量
           for(int gap=arr.length/2;gap>0;gap/=2){
               //从第gap个元素,逐个对其所在组进行直接插入排序操作
               for(int i=gap;i<arr.length;i++){
                   int j = i;
                   while(j-gap>=0 && arr[j]<arr[j-gap]){
                       //插入排序采用交换法
                       swap(arr,j,j-gap);
                       j-=gap;
                   }
               }
           }
        }
    
        /**
         * 希尔排序 针对有序序列在插入时采用移动法。
         * @param arr
         */
        public static void sort1(int []arr){
            //增量gap,并逐步缩小增量
            for(int gap=arr.length/2;gap>0;gap/=2){
                //从第gap个元素,逐个对其所在组进行直接插入排序操作
                for(int i=gap;i<arr.length;i++){
                    int j = i;
                    int temp = arr[j];
                    if(arr[j]<arr[j-gap]){
                        while(j-gap>=0 && temp<arr[j-gap]){
                            //移动法
                            arr[j] = arr[j-gap];
                            j-=gap;
                        }
                        arr[j] = temp;
                    }
                }
            }
        }
        /**
         * 交换数组元素
         * @param arr
         * @param a
         * @param b
         */
        public static void swap(int []arr,int a,int b){
            arr[a] = arr[a]+arr[b];
            arr[b] = arr[a]-arr[b];
            arr[a] = arr[a]-arr[b];
        }
    }
    

    3、复杂度

    希尔排序中对于增量序列的选择十分重要,直接影响到希尔排序的性能。我们上面选择的增量序列{n/2,(n/2)/2…1}(希尔增量),其最坏时间复杂度依然为O(n2),一些经过优化的增量序列如Hibbard经过复杂证明可使得最坏时间复杂度为O(n3/2)。

    展开全文
  • 希尔排序是特殊的插入排序算法, 按照百度百科的定义为: 希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”(Diminishing Increment Sort),是直接插入排序算法的一种更高效的改进版本。希尔排序是非...
  • 因为希尔排序的核心思想是插入排序,所以本篇将两篇排序一起记录本篇内容:插入排序希尔排序(一)插入排序算法思想:把n个待排序的元素看成一个有序表和一个无序表,开始时有序表中只有一个元素,无序表中有n-1个元素...
  • 主要为大家详细介绍了Java经典排序算法希尔排序,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 概念:希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序,算法的最后一步就是普通的插入排序,但是到了这...
  • 希尔排序 public class Sort { /** * 希尔排序 */ void shellSort(int k[],int n){ int i,j,temp; int gap=n; do { gap = gap/3 + 1; if(...
  • 希尔排序是首个O(n^2)的排序算法,他是对前面说到的插入排序的改进版。下面就来看看它究竟是怎么进行排序的吧。 希尔排序就是先定义一个增量,然后根据这个增量将几个元素分成一组,最终可能会得到很多个组,在组...
  • 希尔排序是希尔(DonaldShell) 于1959年提出的一种排序算法希尔排序也是一种插入排序,它是简单插入排序经过改进之后的-一个更高效的版本,也称为缩小增量排序。 ➢ 希尔排序基本思想 希尔排序是把记录按下标的一定...
  • java算法——希尔排序

    2018-06-13 22:21:56
    按下标的一定增量分组,对每组使用直接插入算法排序;随着增量 * 逐渐减少,每组包含的关键字越来越多,当增量减至1时,整个文件恰 * 好被分成一组,算法便终止。 * 8,9,1,7,2,3,5,4,6,0 * //初始增量 gap=...
  • 主要介绍了希尔排序算法与相关的Java代码实现,希尔排序的时间复杂度根据步长序列的不同而不同,需要的朋友可以参考下
  • title: 希尔排序算法(基于Java实现) tags: 希尔排序算法 希尔排序算法的原理与代码实现: 一、希尔排序算法的原理 因为在简单插入排序中可能会存在这样的问题,例如,我们将数组arr=[2, 3, 4, 5, 6, 1]进行排序,...
  • 希尔排序是冲破二次时间屏障的第一批算法之一。它是通过比较相距一定间隔的元素来工作,各趟比较所用的距离随着算法的进行而减小,直到最后一趟(比较相邻元素)为止。因此希尔排序也叫缩减增量排序。希尔排序使用一个...
  • Java 希尔排序算法

    2020-12-11 11:15:29
    上一章我们学习了 Java 插入排序算法,这一章,我们来学习插入排序算法,so,多了不说,继续老规矩,学习内容如下: 1、希尔排序的定义 2、希尔排序的思路 3、代码实现 1.希尔排序的定义 希尔排序的实质就是:分组...
  • 1.2.3希尔排序 希尔排序又叫缩小增量排序 基本思想:先取一个小于n的整数作为第一个增量,把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序;然后,取第二个增量...
  • 插入排序与希尔排序 一,插入排序 插入排序的原理‘ 插入排序的特点 插入排序的代码实现 (1),插入排序的原理 插入排序(InsertionSorting)的基本思想是:把n个待排序的元素看成为一个有序表和一个无序表,开始...
  • 主要介绍了Java 选择排序、插入排序希尔算法实例详解,需要的朋友可以参考下
  • java希尔排序代码实现

    千次阅读 2017-11-13 12:58:50
    希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个...
  • 总结了常用的八大排序算法:(交换式:1、冒泡,2、快排; 选择式:3、选择, 4、堆排; 插入式:5、插入, 6、希尔; 其他:7、归并, 8、基数排序)。 并包含了Java实现的源代码
  • 希尔排序Java代码实现

    千次阅读 2019-05-31 22:44:56
    希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序,同时该算法是冲破O(n2)的第一批算法之一。它与插入...
  • java 排序算法可视化 演示程序。 用java做的一个小的排序算法演示程序,用线程控制访问,共7个算法,包括冒泡,选择,希尔,插入,归并,堆,快排。。 算法排序
  • java代码希尔排序

    千次阅读 2019-03-05 20:52:40
    直接插入排序、希尔排序、折半插入排序 3、希尔排序的基本思想 希尔排序(shell sort)这个排序方法又称为缩小增量排序,是1959年D·L·Shell提出来的。该方法的基本思想是:先将整个待排元素序列分割成若干个子序列...
  • 希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”(Diminishing Increment Sort),是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。 ...
  • 排序算法-希尔排序

    2021-10-15 14:55:40
    文章目录 1、简单插入排序存在的问题 我们看简单的插入排序可能存在的问题...2、希尔排序算法介绍 希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为最小增量排序 3、希尔排序的基本

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,852
精华内容 5,140
关键字:

java希尔排序算法代码

java 订阅