精华内容
下载资源
问答
  • 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));

    }

    展开全文
  • 希尔排序是特殊的插入排序算法, 按照百度百科的定义为: 希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”(Diminishing Increment Sort),是直接插入排序算法的一种更高效的改进版本。希尔排序是非...

    希尔排序是特殊的插入排序算法, 按照百度百科的定义为:

    希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”(Diminishing Increment Sort),是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。

     

    基本思想:先取一个小于n的整数d1作为第一个增量,把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序;然后,取第二个增量d2<d1重复上述的分组和排序,直至所取的增量

      

    =1(

      

    <

      

    …<d2<d1),即所有记录放在同一组中进行直接插入排序为止。

     

     

    个人对希尔排序的实现代码java

    /**
     * 类Selection.java的实现描述:希尔排序(插入排序的优化版本)
     * 
     * @author wangyangchao 2019年3月23日 下午1:11:20
     */
    public class SellInsertationSort extends AbstractArithmeticLogicTemplate {
    
        @Override
        public void sort(Comparable[] a) {
            long start = System.currentTimeMillis();
            int len = a.length;
            int step = len;
            for (;;) {
                step = step / 2;
                for (int i = 0; i < len; i += step) {
                    for (int j = i; j > 0 && less(a[j], a[j - step]); j -= step) {
                        this.exch(a, j, j - step);
                    }
                }
                if (step == 1) {
                    break;
                }
            }
            System.out.println("cost" + (System.currentTimeMillis() - start));
        }
    
        public static void main(String[] args) {
            SellInsertationSort shellInsertSort = new SellInsertationSort();
            Comparable[] a = new Integer[10000];
            for (int i = 0; i < 10000; i++) {
                a[i] = new Random().nextInt(1000000);
            }
    
            //        shellInsertSort.show(a);
            shellInsertSort.sort(a);
            //        shellInsertSort.show(a);
        }
    
    }
    展开全文
  • 1.插入排序存在问题数组 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...2. 希尔排序介绍希尔排序是希尔(Donald Shell)于1959...

    1.插入排序存在问题

    数组 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. 希尔排序介绍

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

    3. 基本思想

    希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;

    随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止

    4. 图解

    d11f34647756e8bd77535d251b4e1ef1.png

    5123eb271cad92ed458df10db02a8ee1.png

    5. 代码实现

    1)java实现(后面有优化)

    //希尔排序时,对有序序列在插入时采用交换法

    public static void shellSort(int[] arr) {int temp = 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]) {

    temp=arr[j];

    arr[j]= arr[j +gap];

    arr[j+ gap] =temp;

    }

    }

    }

    }

    }

    2)逐步推导

    8f900a89c6347c561fdf2122f13be562.png

    961ddebeb323a10fe0623af514929fc1.png

    //希尔排序的第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]) {

    temp=arr[j];

    arr[j]= arr[j + 5];

    arr[j+ 5] =temp;

    }

    }

    }

    System.out.println("希尔排序1轮后=" + 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]) {

    temp=arr[j];

    arr[j]= arr[j + 2];

    arr[j+ 2] =temp;

    }

    }

    }

    System.out.println("希尔排序2轮后=" + 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 -= 1) {//如果当前元素大于加上步长后的那个元素,说明交换

    if (arr[j] > arr[j + 1]) {

    temp=arr[j];

    arr[j]= arr[j + 1];

    arr[j+ 1] =temp;

    }

    }

    }

    System.out.println("希尔排序3轮后=" + Arrays.toString(arr));//

    View Code

    3)对交换式的希尔排序进行优化—>移位法

    (先找位置再插入,而不是无脑交换位置,极大地减少了时间消耗)

    //对交换式的希尔排序进行优化->移位法

    public static void shellSort2(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;

    }//当退出while后,就给temp找到插入的位置

    arr[j] =temp;

    }

    }

    }

    }

    4)时间测试

    public static voidmain(String[] args) {//int[] arr = { 8, 9, 1, 7, 2, 3, 5, 4, 6, 0 };//创建要给80000个的随机的数组

    int[] arr = new int[8000000];for (int i = 0; i < 8000000; i++) {

    arr[i]= (int) (Math.random() * 8000000); //生成一个[0, 8000000) 数

    }

    System.out.println("排序前");

    Date data1= newDate();

    SimpleDateFormat simpleDateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    String date1Str=simpleDateFormat.format(data1);

    System.out.println("排序前的时间是=" +date1Str);//shellSort(arr);//交换式

    shellSort2(arr);//移位方式

    Date data2= newDate();

    String date2Str=simpleDateFormat.format(data2);

    System.out.println("排序前的时间是=" +date2Str);//System.out.println(Arrays.toString(arr));

    }

    展开全文
  • 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)。

    展开全文
  • Java 希尔排序算法

    2020-12-11 11:15:29
    上一章我们学习了 Java 插入排序算法,这一章,我们来学习插入排序算法,so,多了不说,继续老规矩,学习内容如下: 1、希尔排序的定义 2、希尔排序的思路 3、代码实现 1.希尔排序的定义 希尔排序的实质就是:分组...
  • 希尔排序是直接插入排序的一种更高效的改进版本。它把记录按下标的一定增量进行分组,然后对每组使用直接插入排序;随着增量逐渐减少每组中包含的元素越来越多,也越来越有序,当增量减到为1时,整个序列就是一组,...
  • 希尔排序算法Java实现

    2021-03-01 07:17:49
    希尔排序(Shell Sort)是插入排序的一种,它是针对直接插入排序算法的改进。该方法又称缩小增量排序,因DL.Shell于1959年提出而得名。希尔排序实质上是一种分组插入方法。它的基本思想是:对于n个待排序的数列,取一...
  • 主要介绍了java 算法希尔排序详解及实现代码的相关资料,需要的朋友可以参考下
  • JAVA希尔排序算法交换和移动(含详细拆分代码讲解)基本内容插入排序的基本思想一、代码的拆分讲解(逐步推导)希尔排序的代码 基本内容 希尔排序也是一种插入排序,他是简单插入排序经过改进之后的一个高效的...
  • 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...
  • 主要介绍了使用Java实现希尔排序算法的简单示例,希尔排序可以被看作是插入排序的一种更高效的改进版本,需要的朋友可以参考下
  • package net.qh.test.sort; import java.util.ArrayList; import java.util.Calendar; import java.util.List; /** * Created by Administrator on 2016/03/01. */ public class Shell { ...
  • java希尔排序算法

    千次阅读 2014-07-27 12:51:49
    java希尔排序算法 代码下载地址:http://www.zuidaima.com/share/1550463279090688.htm
  • 主要为大家详细介绍了Java经典排序算法希尔排序,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 因为希尔排序的核心思想是插入排序,所以本篇将两篇排序一起记录本篇内容:插入排序希尔排序(一)插入排序算法思想:把n个待排序的元素看成一个有序表和一个无序表,开始时有序表中只有一个元素,无序表中有n-1个元素...
  • 希尔排序是冲破二次时间屏障的第一批算法之一。它是通过比较相距一定间隔的元素来工作,各趟比较所用的距离随着算法的进行而减小,直到最后一趟(比较相邻元素)为止。因此希尔排序也叫缩减增量排序。希尔排序使用一个...
  • java算法——希尔排序

    2018-06-13 22:21:56
    按下标的一定增量分组,对每组使用直接插入算法排序;随着增量 * 逐渐减少,每组包含的关键字越来越多,当增量减至1时,整个文件恰 * 好被分成一组,算法便终止。 * 8,9,1,7,2,3,5,4,6,0 * //初始增量 gap=...
  • 希尔排序是插入排序的一种,又称“缩小增量排序”,是插入排序算法的一种更高效的改进版本。 前面学习插入排序的时候,我们会发现一个很不友好的事儿,如果已排序的分组元素为{2,5,7,9,10},未排序的分组 元素为{1,8...
  • 概念:希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序,算法的最后一步就是普通的插入排序,但是到了这...
  • java实现希尔排序(思路与实现)

    万次阅读 多人点赞 2018-06-06 18:05:38
    希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。希尔排序过程希尔排序的基本思想是:将...
  • Java实现希尔排序算法

    2021-02-23 20:11:45
    排序算法 在本教程中,您将学习shell排序的工作方式。此外,您还将找到使用C,C ++,Java和Python进行shell排序的工作示例。 壳排序是一种算法,该算法首先对彼此分开的元素进行排序,然后依次减小要...
  • 主要介绍了浅析java 希尔排序(Shell)算法的原理以及示例,需要的朋友可以参考下
  • 希尔排序是首个O(n^2)的排序算法,他是对前面说到的插入排序的改进版。下面就来看看它究竟是怎么进行排序的吧。 希尔排序就是先定义一个增量,然后根据这个增量将几个元素分成一组,最终可能会得到很多个组,在组...
  • java实现希尔排序

    2019-08-21 00:08:55
    希尔排序算法描述: 将一个数据序列分成若干组,每组由若干相隔一段距离(称为增量delta)的元素组成,在一个组内采用直接插入排序算法进行排序。 增量delta初值通常为数据序列长度的一半,以后每趟增量减半,最后...
  • 主要介绍了Java排序算法总结之希尔排序,较为详细的分析了希尔排序的原理与java的实现技巧,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,971
精华内容 8,388
关键字:

java希尔排序算法

java 订阅