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

    2012-04-16 15:40:52
    希尔排序 希尔排序希尔排序希尔排序希尔排序希尔排序希尔排序希尔排序
  • 希尔排序Java代码实现

    千次阅读 2019-05-31 22:44:56
    希尔排序 希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序,同时该算法是冲破O(n2)的第一批算法之一...

    希尔排序

    希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序,同时该算法是冲破O(n2)的第一批算法之一。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

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

    算法描述

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

    先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,具体算法描述:

    1. 选择一个增量序列 t1,t2,…,tk,其中 ti > tj,tk = 1;
    2. 按增量序列个数 k,对序列进行 k 趟排序;
    3. 每趟排序,根据对应的增量ti,将待排序列分割成若干长度为 m 的子序列,分别对各子表进行直接插入排序。仅增量因子为 1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。

    算法分析

    • 时间复杂度:O(nlogn)
    • 空间复杂度:O(1)
    • 稳定性:不稳定

    代码实现

    public class ShellSort {
        public static void shellSort(int[] arr) {
            // 空数组 或 只有一个元素的数组,则什么都不做。
            if (arr == null || arr.length <= 1) return;
            // 定义希尔增量。
            int gap = arr.length / 2;
            // gap缩小到0的时候就退出循环。
            while (gap != 0) {
                // 每组进行直接插入排序。
                for (int i = gap; i < arr.length; i++) {    // i 代表待插入元素的索引。
                    int value = arr[i];
                    int j = i - gap;    // j 代表i的上一个元素,相差一个增量gap。
    
                    // j < 0 时退出循环,说明 j 是最小的元素的索引值。
                    // 或者 arr[j] <= value 时退出循环,说明 j 是比value小的元素的索引值。
                    for (; j >= 0 && arr[j] > value; j -= gap) {
                        arr[j + gap] = arr[j];  // 把元素往后挪。
                    }
                    arr[j + gap] = value;
    
                }
                // 把每一趟排序的结果也输出一下。
                print(arr);
    
                // 缩小增量。
                gap /= 2;
            }
        }
    
        public static void main(String[] args) {
            int[] arr = {6, 9, 1, 4, 5, 8, 7, 0, 2, 3};
    
            System.out.print("排序前:  ");
            print(arr);
    
            shellSort(arr);
    
            System.out.print("排序后:  ");
            print(arr);
        }
    
        // 打印数组
        public static void print(int[] arr) {
            if (arr == null)    return;
    
            for(int i : arr) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
    }
    /*
    排序前:  6 9 1 4 5 8 7 0 2 3 
    6 7 0 2 3 8 9 1 4 5 
    0 1 3 2 4 5 6 7 9 8 
    0 1 2 3 4 5 6 7 8 9 
    排序后:  0 1 2 3 4 5 6 7 8 9 
    */

     

    展开全文
  • 最近在学习希尔排序的过程中,感觉有一点困惑,虽然他的核心思想容易理解,就是为了减少插入排序中顺序不一致时需要后移发生的交换次数。 希尔排序采用分组的方法解决了上述问题,通过不断的减小步长来达到逐步排序...

    最近在学习希尔排序的过程中,感觉有一点困惑,虽然他的核心思想容易理解,就是为了减少插入排序中顺序不一致时需要后移发生的交换次数。
    希尔排序采用分组的方法解决了上述问题,通过不断的减小步长来达到逐步排序的效果,当步长为1的时候,其实就是简单插入排序了。
    下面在代码中进行详解:

       public static int[] shell(int []arr) {
        for (int step = arr.length / 2; step > 0; step /= 2) {//定义步长,先取步长为数组长度的二分之一,逐步减小,最后为1
            int temp=0;//用来存储要插入的元素
            int index=0;//用来存储要插入元素的索引
            for (int i = step; i < arr.length; i++) {//插入排序的时候我们是从索引为1的元素开始,默认索引为0的元素有序
                //现在分成这么多组,就把索引为0到step-1的元素默认有序,从step的元素开始,因为我们默认这么多组的开头元素有序
                //步长为1的时候也是默认开头元素有序,只是就一个组罢了
                temp = arr[i];//记录要插入元素的值
                index=i;//记录要插入元素的索引,为什么要定义index来保存i呢?会不会多此一举
                while (index-step>0&&temp<arr[index-step]) {//如果要插入的元素大于本组的前一个元素,就把前一个元素后移
                    //并且找到最终要插入位置的索引
                    //这里应该先判断index-step是否大于0,因为如果先判断arr[index-step]可能会出现索引越界
                    arr[index] = arr[index - step];//后移
                    index-=step;//这里就解释了为什么要定义index了,因为index会不断变化,最终指向元素要插入的位置
                }
                arr[index]=temp;//在while中找到要插入的位置index了,此时将元素插入
            }
    
        }
        return  arr;
    }
    
    展开全文
  • 希尔排序java实现

    2020-12-21 18:58:33
    希尔排序定义三.实现四.时间复杂度五.空间复杂度六.参考 一.前提 1.为简单起见,讨论从小到大的整数排序 2.只讨论基于比较的排序(< = >有定义) 3.只讨论内部排序 4.稳定性:任意两个相等的数据,排序前后...

    一.前提

    1.为简单起见,讨论从小到大的整数排序
    2.只讨论基于比较的排序(< = >有定义)
    3.只讨论内部排序
    4.稳定性:任意两个相等的数据,排序前后相对位置不发生变化


    二.补充

    2.逆序对:对于下标i、j,如果i < j,而且a[i] > a[j]
    ,则称(i,j)或者(a[i],a[j])为逆序对

    在这里插入图片描述2.希尔排序:目标是克服插入排序每次只交换相邻两个元素的缺点
    3.插入排序



    三.希尔排序原理

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

    四.实现

    //希尔排序是依靠插入排序来实现的
    	public int[] Shell_Sort(int[] array){
    		int gap = array.length/2; //希尔增量,取数组的一半
    		//增量每次循环减半,最小为1
    		while(gap > 0){
    			//num是目前进行到的待排序分组的第二个元素
    			//比如{1,2,3,4,5,6},增量为3,表示分了三组[1,4][2,5][3,6]。
    			//所以我们要进行三次的插入排序,把这三组进行排序
    			//这里的分组是逻辑上的分组,物理上他们还是位于array数组内的,但我们把它们看作是不同的分组
    			//由此我们可以看到,如果是直接插入排序,对于4来说,他要和{1,2,3}进行比较
    			//而希尔排序,对于4来说,它只要和1进行比较,两个下标相差gap
    			//分组[1,4]的第二个元素映射到array数组中就是第gap个元素
    			for( int num = gap ; num < array.length  ; num++){
    				int j;
    				int temp = array[num];
    				for(j = num; j >= gap && temp < array[j-gap]; j -= gap)
    					 array[j] = array[j-gap];
    				array[j] = temp;
    			}
    			
    			gap /= 2;
    		}
    		
    		return array;
    		
    	}
    
    
    


    五.时间复杂度

    1.我们来看下它的时间复杂度的组成:
    (1)最外层的while循环T1(n) = O(logn)
    (2)里面的插入排序的时间复杂度

    • 最好情况:
      数组是顺序的,插入排序时间复杂度为 T2(n) = O(n)
      总的时间复杂度:T(n) = nlogn
    • 最坏情况:
      最坏情况与增量的选择有关
      设总共有x次循环,由于数据放的很巧妙,前x-1次循环数组完全没改变。导致最后一次插入排序,数组才改变且排序好
      emm不是很懂,看这个文章
      希尔排序&选择排序&时间复杂度分析
      总的时间复杂度:T(n) = n2
      在这里插入图片描述


    六.空间复杂度

    所有操作都是在一个数组内进行的,没有额外的添加空间
    S(n) = O(1)



    七.参考

    1.b站-【浙江大学】数据结构
    2. csdn-希尔排序&选择排序&时间复杂度分析

    展开全文
  • 希尔排序Java实现

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

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

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

    public class ShellSort {
    	public static void main(String[] args) {
    		int[] arr = {49, 38, 65, 97, 26, 13, 27, 49, 55, 4};
    		shellSort(arr);
    		System.out.println(Arrays.toString(arr));
    	}
    	
    	public static void shellSort(int[] arr){
    		{
    			int i, j, gap;
    			 // 求出步长(每次除以2)
    			for (gap = arr.length / 2; gap > 0; gap /= 2)
    				// 直接插入排序(分出了组,也就是步长能达到最后的所有数字)
    				for (i = 0; i < gap; i++){
    					// 加上上一个for,就是把所有元素与相差步长的数比较一遍
    					for (j = i + gap; j < arr.length; j += gap) 
    						// 当前的数小于上一个步长的数
    						if (arr[j] < arr[j - gap])
    						{
    							// 取出较小的值(右,当前的数)
    							int temp = arr[j];
    							// 取出较大的值的下标
    							int k = j - gap;
    							while (k >= 0 && arr[k] > temp)
    							{
    								arr[k + gap] = arr[k];
    								k -= gap;
    							}
    							arr[k + gap] = temp;
    						}
    				}
    		}
    	}public class ShellSort {
    	public static void main(String[] args) {
    		int[] arr = {49, 38, 65, 97, 26, 13, 27, 49, 55, 4};
    		shellSort(arr);
    		System.out.println(Arrays.toString(arr));
    	}
    	
    	public static void shellSort(int[] arr){
    		{
    			int i, j, gap;
    			 // 求出步长(每次除以2)
    			for (gap = arr.length / 2; gap > 0; gap /= 2)
    				// 直接插入排序(分出了组,也就是步长能达到最后的所有数字)
    				for (i = 0; i < gap; i++){
    					// 加上上一个for,就是把所有元素与相差步长的数比较一遍
    					for (j = i + gap; j < arr.length; j += gap) 
    						// 当前的数小于上一个步长的数
    						if (arr[j] < arr[j - gap])
    						{
    							// 取出较小的值(右,当前的数)
    							int temp = arr[j];
    							// 取出较大的值的下标
    							int k = j - gap;
    							while (k >= 0 && arr[k] > temp)
    							{
    								arr[k + gap] = arr[k];
    								k -= gap;
    							}
    							arr[k + gap] = temp;
    						}
    				}
    		}
    	}

     

    展开全文
  • 希尔排序 Java实现

    2020-03-18 20:04:14
    希尔排序基本思想: 在直接插入排序的基础上进行的优化. 先将整个待排序数据元素序列分割成若干个子序列分别进行直接插入排序,待整个序列中的数据元素“基本有序”时,再对全体数据元素构成的序列进行一次直接插入...
  • 希尔排序 希尔排序就是高级版的插入排序,还挺快的。 它首先是将一个数组构建成多个列,就想堆排序需要先构建成二叉树一样,但是这个列 是自己想的 虚拟的 不会实质性的去改变数组的结构。 然后循环每列,将每列的...
  • 希尔排序java)

    2019-04-10 01:03:51
    NULL 博文链接:https://128kj.iteye.com/blog/1662282
  • 排序---希尔排序Java

    2019-06-29 17:33:00
    希尔排序 插入排序的一种又称“缩小增量排序”,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量...
  • 希尔排序 Java

    2019-11-13 22:37:53
    希尔排序法又称缩小增量法。希尔排序法的基本思想是:先选定一个整数,把待排序文件中所有记录分成个组,所有 距离为的记录分在同一组内,并对每一组内的记录进行排序。然后,取重复上述分组和排序的工作。当到达=1时...
  • 希尔排序的思想比较巧妙,过程就不描述了,通过一个增量将原数据分组,分组后进行简单插入排序,使用增量的目的是为了快速移动元素,而不是一位一位的移动,因此是一种不稳定的排序方式。 这里不详述过程,只是做个...
  • 插入排序 时间复杂度:O(n²) 插入排序(Insertion Sort)是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常...
  • 希尔排序java实现)

    千次阅读 2018-07-22 18:28:19
    希尔排序介绍 希尔排序(Shell Sort)是插入排序的一种,它是针对直接插入排序算法的改进。该方法又称缩小增量排序,因DL.Shell于1959年提出而得名。 希尔排序实质上是一种分组插入方法。它的基本思想是:对于n个待...
  • 希尔排序 java实现

    2017-04-01 13:46:45
    /*希尔排序 跳跃分割,先基本有序,再通过直接插入排序使序列有序  * 与直接插入排序一样,需要一个额外的缓存空间  *复杂度分析 o(n^(3/2))  */ public class ShellSort { public static void main...
  • 希尔排序 java 实现

    千次阅读 2015-11-08 12:26:15
    希尔排序算法思想 它是对插入插入排序的改进 搜索维基百科可知 希尔排序,也称递减增量排序算法 假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ] ,我们分别以步长为5,3,1进行排序...
  • java代码之希尔排序

    千次阅读 2019-03-05 20:52:40
    直接插入排序、希尔排序、折半插入排序 3、希尔排序的基本思想 希尔排序(shell sort)这个排序方法又称为缩小增量排序,是1959年D·L·Shell提出来的。该方法的基本思想是:先将整个待排元素序列分割成若干个子序列...
  • import java.util.Arrays; /** * Created by Administrator on 2017/8/2. */ public class shellSort_insert { public static void main(String args[]) { int[] arr = { 6, 9, 1, 3, 1, 2, 2, 5, 6,
  • 由上图可看到希尔排序先约定一个间隔(图中是4),然后对0、4、8这个三个位置的数据进行插入排序,然后向右移一位对位置1、5、9进行插入排序按照此规律直到全部参与了排序。然后将间隔约定为4-1=3,然后继续进行如上...
  • Java实现希尔排序图解

    2020-06-09 14:01:28
    目录简单插入排序存在的问题希尔排序法介绍希尔排序法基本思想排序思想图解代码实现 简单插入排序存在的问题 假如数组arr={2,3,4,5,6,1},这时需要插入的数为1,这样的过程是 {2,3,4,5,6,6} {2,3,4,5,5,6} {2...
  • java实现希尔排序(思路与实现)

    万次阅读 多人点赞 2018-06-06 18:05:38
    希尔排序希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。 希尔排序是把记录按下标的一定...
  • 希尔排序 概述 希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”(Diminishing Increment Sort),是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年...
  • public class Test_希尔排序 { public static void main(String[] args) { int [] arr = {49, 38, 65, 97, 26, 13, 27, 49, 55}; shellSort(arr); for(int i : arr){ System.out.println(i); } } ...
  • 希尔排序 解决插入排序,位置靠后的元素需要对数组进行不断位移的问题 核心: 分组插入排序 关键词:步长、3个for循环(2个for一个while) 动图(移动法) 代码(交换法) public static void shellSort(int[] arr) {...
  • 希尔排序Java

    2019-08-30 15:09:01
    希尔排序法介绍 希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序。 希尔排序法基本思想 希尔排序是...

空空如也

空空如也

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

希尔排序java

java 订阅