精华内容
下载资源
问答
  • 希尔排序代码

    2015-10-06 22:05:00
    希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组,...
  • 希尔排序代码详解

    2020-08-04 00:59:03
    希尔排序一个重要性质: 后使用的增量排序不会影响之前使用的增量排序 也就是:h1-排序后,不会影响hk排序的成果,否则就是前功尽弃了。。后面排序摧毁了前面的劳动 以Shell建议的序列ht【N/2】和hk【hk+1/2】为例。 ...

    希尔排序一个重要性质:
    后使用的增量排序不会影响之前使用的增量排序
    也就是:h1-排序后,不会影响hk排序的成果,否则就是前功尽弃了。。后面排序摧毁了前面的劳动
    以Shell建议的序列ht【N/2】和hk【hk+1/2】为例。
    具体的代码实现如下:

    
    template<typename T>
    void shell_sort(T* array, unsigned int n) {
        unsigned int i, j, increment;
        T tmp;//shell建议的序列就是从n/2开始的,每次都n/=2,得到下一个序列,
        for (increment = n / 2; increment >= 1; increment /= 2) 
        {
            for (i = increment; i < n; i++)//第二个for
           {//i一定是从increment位置开始的,因为你要间隔increment比较元素,你至少都得往左边有元素能比较
            //所以你第一个i的位置减去increment后就是和第一个元素array[0]比较,接着i++,继续排序
                tmp = array[i];//第三个for,间隔increment个元素比较
                for (j = i; j >= increment && array[j - increment] > tmp;j-=increment) 
                {
                    array[j] = array[j - increatment];
                }
                array[j] = tmp;
            }
        }
    }
    

    对第一层for分析:
    根据shell序列定义,先取N/2为第一个使用的增量,然后(N/2)/2,循环条件就是使用的增量大于等于1
    这层for比较容易理解

    对第二层for分析:
    看图片吧,假如我增量是5,那么tmp就是从35开始,i++导致tmp的位置一值右移,因为你是间隔increment排序,所以间隔increment的数都是相当于使用了插入排序,只不过是间隔了increment个
    位置的排序而已
    图中排序执行 的先后顺序是右往左
    先是35和81比较
    然后17和94比较
    然后95和11比较
    。。。。。。。。
    然后58和12比较
    然后到41的时候可以比较3个元素了
    41和35比较,然后和81比较
    。。。。。
    剩下的基本都差不多了
    在这里插入图片描述
    第三层就太简单啦,直接就是间隔为增量的交换比较操作啦
    总结一句:希尔排序实质上是间隔为increment的插入排序,本质上完全一样,就是为了改善插入排序
    插入排序使用推荐条件是:
    ①排序数目少
    ②输入的数据已经大概是排好序的了,逆序对比较少

    综上,为了改善插入排序,先是对子数组的逆序对进行改善,然后降低了逆序对数,等到你增量是1的时候,基本是预排序,此时调用之前的插入排序,性能将得到很大提高!!

    导致希尔排序性能低下的因素

    你每个子数组我都是有序的,但是到增量是1的时候我逆序对还是很多,而且我前面消除逆序对的代码
    相当于白花费工夫
    例子如下
    在这里插入图片描述
    参考文章/视频:
    《浙江大学数据结构MOOC网课–陈越,何钦铭》
    《青岛大学数据结构MOOC–王卓》
    《数据结构与算法分析-C语言描述》

    展开全文
  • 【希尔排序】C++实现希尔排序代码

    千次阅读 2018-08-16 10:42:22
    void shellSort(int a[], int n) //a -- 待排序的数组, n -- 数组的长度 { int i,j,gap; // gap为步长,每次减为原来的一半。 for (gap = n / 2; gap > 0; gap /= 2) { // 共gap个组,对每一组都执行直接插入...
    #include<iostream>
    using namespace std;
    
    void print(int a[], int n)
    {  
        for(int j= 0; j<n; j++)
    	{  
               cout<<a[j] <<"  ";  
            }  
        cout<<endl;  
    }
    
    void shellSort(int a[], int n)  //a -- 待排序的数组, n -- 数组的长度
    {
        int i,j,gap;   // gap为步长,每次减为原来的一半。
        for (gap = n / 2; gap > 0; gap /= 2)
        {
            // 共gap个组,对每一组都执行直接插入排序
            for (i = 0 ;i < gap; i++)
            {
                for (j = i + gap; j < n; j += gap) 
                { 
                    // 如果a[j] < a[j-gap],则寻找a[j]位置,并将后面数据的位置都后移。
                    if (a[j] < a[j - gap])
                    {
                        int tmp = a[j];
                        int k = j - gap;
                        while (k >= 0 && a[k] > tmp)
                        {
                            a[k + gap] = a[k];
                            k -= gap;
                        }
                        a[k + gap] = tmp;
                    }
                }
            }
        }
    }
    
    int main()
    {  
        int a[10] = {8,1,9,7,2,4,5,6,10,3};  
        cout<<"初始序列:";  
        print(a,10);  
        shellSort(a,10);  
        cout<<"排序结果:";  
        print(a,10);  
        system("pause"); 
    } 

     

    展开全文
  • cpp代码-希尔排序代码

    2021-07-16 11:50:36
    cpp代码-希尔排序代码
  • java希尔排序代码实现

    千次阅读 2017-11-13 12:58:50
    希尔排序 希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。 希尔排序是把记录按下标的...

    希尔排序
    希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。
    排序过程
    希尔排序的基本思想是:将数组列在一个表中并对列分别进行插入排序,重复这过程,不过每次用更长的列(步长更长了,列数更少了)来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法,算法本身还是使用数组进行排序。
    例如,假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ],如果我们以步长为5开始进行排序,我们可以通过将这列表放在有5列的表中来更好地描述算法,这样他们就应该看起来是这样(竖着的元素是步长组成):

    13 14 94 33 82
    25 59 94 65 23
    45 27 73 25 39
    10

    然后我们对每列进行排序:

    10 14 73 25 23
    13 27 94 33 39
    25 59 94 65 82
    45

    将上述四行数字,依序接在一起时我们得到:[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。这时10已经移至正确位置了,然后再以3为步长进行排序:

    10 14 73
    25 23 13
    27 94 33
    39 25 59
    94 65 82
    45

    排序之后变为:

    10 14 13
    25 23 33
    27 25 59
    39 65 73
    45 94 82
    94

    最后以1步长进行排序(此时就是简单的插入排序了)
    这里写图片描述

    代码实现

    public class shell_sort{
        public static void ShellSort(int[] arr){
            int n=arr.length;
            int gap=n/2;
            while(gap>0){
                for(int j=gap;j<n&gap>0;j++){
                    int i=j;
                    while(i<n){
                        if(arr[i]<arr[i-gap]){
                            int temp=arr[i];
                            arr[i]=arr[i-gap];
                            arr[i-gap]=temp;
                            i+=1;
                        }
                        else
                            break;
                    }   
                }
                gap=gap/2;
    
            }
        }
            public static void main(String[] args){
            int a[]={38,65,97,76,13,27,49};
            ShellSort(a);
            for(int n:a)
                System.out.print(n+",");
        }
    
    }
    展开全文
  • 希尔排序的算法代码

    2020-09-05 13:51:16
    希尔排序也是一种插入排序方法,实际上是一种分组插入方法。
  • 附件提供的是C语言实现的希尔排序代码,同时提供了代码实现的结果
  • 1959年Shell发明,第一个突破O(n2)的排序算法,是直接插入排序的改进版。它与插入排序的不同之处在于,它会优先比较距离较远的元素。...下面是希尔排序代码演示,所有的注释都在代码里。 为了辅助理解

    1959年Shell发明,第一个突破O(n2)的排序算法,是直接插入排序的改进版。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
    希尔排序的大致思路是把数组的元素按照一定的间隔进行逻辑分组,分组后针对每一组进行插入排序。并且渐渐减小间隔,随着间隔的缩小,整个数组就变得越来越有序。这个间隔叫做希尔增量。
    希尔排序的时间复杂度难以测算,大概是O(n^(1.3—2))这么一个范围。
    希尔排序是一种不稳定的排序算法。
    在这里插入图片描述
    下面是希尔排序的代码演示,所有的注释都在代码里。
    为了辅助理解,我在文末加入了插入排序的代码和注释,建议两个排序配合着看,看上几遍基本就懂了

    public static void ShellSort(int[] array)
            {
               int n = array.Length;
                int inc;//希尔增量
                //这里采用朴素希尔增量,就是每次增量都是原来的一半,直到增量为1为止
                for (inc = n / 2; inc >= 1; inc = inc / 2)
                {//每一次循环都通过不断缩短增量达到排序的效果
                    //在一次循环内,inc的值是固定的
                    //下面的内容和插入排序的原理是一样的,只不过每个待排序元素的间隔是inc
                    for (int i = inc; i < n; i++)
                    {//i为什么是从inc开始,而不是从0开始?
                     //因为插入排序中把排序元素分为两组,A组为已排好序的,B组为未排好序要插入的
                     //A组开始时往往是第一个元素(0),那么B组的第一个元素就是整个待拍序列的第二个元素了(inc)
                        int temp = array[i];//temp存储要插入的值
                        int j;
                        for (j = i-inc; j >= 0 && array[j] > temp; j = j - inc)
                        {//j从i-inc开始往前遍历,每一步的距离是inc
                            array[j+inc] = array[j];如果当前遍历到的元素(这里说的遍历到的元素是(array[j])比待插入元素temp小,
                                                      //这个元素往后移动一位,后边的元素被元素覆盖
                                                      //一旦不满足条件,1.说明要么遍历到元素比temp小,这个时候所有比temp大的元素都后移完了
                                                      //2.遍历到头了,此时第一个元素就是要插入的地方
                        }
                        array[j+inc] = temp;
                                        //那么此时array[j+inc]也就是要插入的地方,把temp插入进去
                    }
                }
            }
    

    下边直接插入排序的代码:

    			//插入排序,时间复杂度为O(n²),且是稳定的排序算法
     public static void InsertSort(int[] array)
            {
                //将数组分为两组,一组是已经排好序的(我们称为A组)另一组是还没有排好序的(称为B组)
                //在数组的刚开始,我们把数组的第一个元素array[0]将入A组,剩下的放入B组
                //从数组的第二个元素开始,逐步与A组的元素相比较(从A组的后边往前边比较)
                for (int i = 1; i < array.Length; i++)
                {
                    int temp = array[i];//定义temp存储要插入的值
                    int j;
                    for (j = i-1; j>=0 && array[j]>temp; j--)//将temp逐步与A组的元素(array[j])相比较(从A组的后边往前边比较)
                    {
                        array[j + 1] = array[j];//如果A组中的值大于要比较的值,A组就整个数组往后移动一个位置
                        //这样的移动当然会覆盖A组后边的那个元素的值,
                        //但是别忘了A组后边的那个元素,是要插入的值原本的位置,
                        //所以往后移动只会覆盖这个位置,不会对整个数组产生影响
                    }
                    array[j + 1] = temp;
                    //退出上边的for循环有两种可能
                    //1.在A组中找到了一个比temp小的元素,那么temp就可以插入在这个元素的后边,即array[j+1]的位置
                    //2.全部遍历完毕,在A组中没有找到比这个temp更小的元素,此时应该把temp插入在A组的最前边(array[0])
                    //由于此时j退出循环时候的值为-1,array[j+1]为要插入的位置
                }
            }
    

    可以看出的是,希尔排序在第一个for循环之后的代码基本就和插入排序一样了,所谓的区别只是插排中的"1"变成了inc而已

    展开全文
  • 希尔排序C语言实现

    2014-02-18 21:50:16
    希尔排序的C语言实现完整代码,可在VC6平台上运行。
  • 希尔排序算法源代码

    2012-01-19 11:15:06
    希尔排序的源代码; 平台:CentOS release 5.4 (Final) 编译器:GCC 4.3.2
  • 上篇叙述了一下插入排序,希尔排序是建立在插入排序上的一种改进算法。 完整代码 public class Xier { public static void main(String[] args) { int[] arr = new int[100000]; for (int i = 0; i <arr....
  • 这一篇我们说一下希尔排序,当然了如果学习希尔排序 那么就要知道插入排序的原理,因为希尔排序算的上是插入排序的进化版 如果没有学习过插入排序 那么就给一个传送门! ...学习了插入排序我们就可以对希尔排序进行讲解...
  • 希尔排序详解与代码实现 1.简单介绍 希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序;它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序。 看希尔排序前,...
  • 代码: #include<iostream> #include<ctime> using namespace std; void Individual(int A[], int size) { srand((unsigned)time(NULL)); for (int i = 0; i < size; i++) A[i] = rand() % 100; ...
  • 希尔排序代码实现

    2016-06-08 22:52:24
    public class ShellSort { public static void main(String[] args) { /*使用折半插入法进行排序*/ int array[]=new int[]{9,8,7,6,5,4,3,2,1}; //把待排序的数存放在数组中 int n=array.length;
  • 程序实现希尔排序,C语言入门程序,适合C语言课程入门的小练习。 程序实现希尔排序,C语言入门程序,适合C语言课程入门的小练习。 程序实现希尔排序,C语言入门程序,适合C语言课程入门的小练习。
  • 希尔排序Java代码实现

    千次阅读 2019-05-31 22:44:56
    希尔排序 希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序,同时该算法是冲破O(n2)的第一批算法之一...
  • 希尔排序: 算法思想:先将待排序列表分割成若干个形如L[i,i+d,i+2d,...i+kd]的特殊子表,分别进行直接插入排序,当整个表中元素已呈"基本有序"时,再对全体记录进行一次直接插入排序。 希尔排序过程(王道数据结构...
  • java代码希尔排序

    千次阅读 2019-03-05 20:52:40
    直接插入排序、希尔排序、折半插入排序 3、希尔排序的基本思想 希尔排序(shell sort)这个排序方法又称为缩小增量排序,是1959年D·L·Shell提出来的。该方法的基本思想是:先将整个待排元素序列分割成若干个子序列...
  • 三:希尔排序python代码实现 (一):实现一 (二):实现二 四:算法分析 (一):时间复杂度 (二):希尔排序演示 一:希尔排序介绍 (一):希尔排序概念 希尔排序(Shell Sort)是插入排序的一种。也称...
  • 希尔排序(ShellSort) 概念介绍 希尔排序(ShellSort): 是插入排序的变种,又称缩小增量排序(Diminishing Increment Sort), 是直接插入排序算法的一种更高效的改进版本。 希尔排序是非稳定排序算法。该方法因 D.L....
  • 一、代码 #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define MAXSIZE 20 typedef int Status; void shellSort(int data[],int dataArrLenght); void shellSort(int data[]...
  • 插入排序,希尔排序,C程序代码,经过运行,决定可用
  • 希尔排序基本思想: 要想理解希尔排序,首先需要理解插入排序,关于插入排序的原理,我的另一篇博客已经阐述,有兴趣的朋友可以参考一下。 分析过插入排序后,我们发现了插入排序的一个弊端,就是在插入过程中,我们...
  • 希尔排序(图解+代码

    千次阅读 2018-09-07 18:15:35
    希尔排序 如图: 我们来看下希尔排序的基本步骤,在此我们选择增量gap=length/2,缩小增量继续以gap = gap/2的方式,这种增量选择我们可以用一个序列来表示,{n/2,(n/2)/2...1},称为增量序列。 图中有10个数,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,921
精华内容 11,968
关键字:

希尔排序代码