【算法】希尔排序

目录

• • • • • [1. 说明](#1. 说明)
        • [2. 举个例子](#2. 举个例子)
        • [3. java代码示例](#3. java代码示例)
        • [4. java示例截图](#4. java示例截图)

1. 说明

• 1.希尔排序是直接插入排序的一种改进，其本质是一种分组插入排序
• 2.希尔排序采取了分组排序的方式
• 3.把待排序的数据元素序列按一定间隔进行分组，然后对每个分组进行直接插入排序
• 4.随着间隔的减小，一直到1，从而使整个序列变得有序
• 5.希尔排序适用于大多数数据元素有序的序列，由于排序期间，同一元素的顺序会经常移动，所以希尔排序不是稳定的排序方法

2. 举个例子

• 示例： [6, 2, 4, 3, 5, 1]
• 1.获取数组的长度6
• 2.计算间隔gap=6/2=3 （将数组分为3组，6和3比较，2和5比较，4和1比较）
• 3.【6和3比较】拿到索引为0的数6（array[j-gap]）与索引为3的数3（temp）进行比较，6>3即array[j-gap] > temp， 6 > 3，将索引为3的数改为6，得到数组[6, 2, 4, 6, 5, 1]，j=j-gap=3-3=0，0小于gap跳出while循环
• 4.将索引为0的数改为3，得到数组[3, 2, 4, 6, 5, 1]
• 5.【2和5比较】拿到索引为1的数2（array[j-gap]）与索引为4的数5（temp)进行比较，2<5则不进行while循环，将索引为4的数改为5（本身就是5，改了不影响）, 数组不做改变
• 6.【4和1比较】拿到索引为2的数4（array[j-gap]）与索引为5的数1（temp)进行比较，4>1即array[j-gap] > temp， 4 > 1，将索引为5的数改为4，得到数组[3, 2, 4, 6, 5, 4]，j=j-gap=5-3=2，2小于gap跳出while循环
• 7.将索引为2的数改为1，得到数组[3, 2, 1, 6, 5, 4]
• 8.计算间隔gap=3/2=1,当间隔为1时，数组中的数字基本有序，再进行插入排序
• 9.取索引为1的数2，比较索引为0的数3，2小于3，则将索引为1的数改为3,索引为0之前没有数了，得到数组[2, 3, 1, 6, 5, 4]
• 10.取索引为2的数1，比较索引为1的数3，1小于3，则将索引为2的数改为3，索引为1之前有索引为0的数2，1小于2，则将索引为1的数改为2，索引为0的数改为1 (大数往后挪），得到数组[1, 2, 3, 6, 5, 4]
• 11.取索引为3的数6，比较索引为2的数3，6大于3，继续
• 12.取索引为4的数5，比较索引为3的数6，5小于6，则将索引为4的数改为6，索引为3之前有索引为2的数3，5大于3，则将索引为3的数改为5，得到数组[1, 2, 3, 5, 6, 4]
• 13.取索引为5的数4，比较索引为4的数6，4小于6，则将索引为5的数改为6，索引为4之前有索引为3的数5，4小于5，则将索引为4的数改为5，得到数组[1, 2, 3, 5, 5, 6]；索引为3之前有索引为2的数3，4大于3，则将所因为3的数改为4，得到数组[1, 2, 3, 4, 5, 6]

3. java代码示例

package com.learning.algorithm.sort;

/**
 * 希尔排序
 * 示例： 6, 2, 4, 3, 5, 1
 * 1.获取数组的长度6
 * 2.计算间隔gap=6/2=3 （将数组分为3组，6和3比较，2和5比较，4和1比较）
 * 3.【6和3比较】拿到索引为0的数6（array[j-gap]）与索引为3的数3（temp）进行比较，6>3即array[j-gap] > temp， 6 > 3，将索引为3的数改为6，得到数组[6, 2, 4, 6, 5, 1]，j=j-gap=3-3=0，0小于gap跳出while循环
 * 4.将索引为0的数改为3，得到数组[3, 2, 4, 6, 5, 1]
 * 5.【2和5比较】拿到索引为1的数2（array[j-gap]）与索引为4的数5（temp)进行比较，2<5则不进行while循环，将索引为4的数改为5（本身就是5，改了不影响）, 数组不做改变
 * 6.【4和1比较】拿到索引为2的数4（array[j-gap]）与索引为5的数1（temp)进行比较，4>1即array[j-gap] > temp， 4 > 1，将索引为5的数改为4，得到数组[3, 2, 4, 6, 5, 4]，j=j-gap=5-3=2，2小于gap跳出while循环
 * 7.将索引为2的数改为1，得到数组[3, 2, 1, 6, 5, 4]
 * 8.计算间隔gap=3/2=1,当间隔为1时，数组中的数字基本有序，再进行插入排序
 * 9.取索引为1的数2，比较索引为0的数3，2小于3，则将索引为1的数改为3,索引为0之前没有数了，得到数组[2, 3, 1, 6, 5, 4]
 * 10.取索引为2的数1，比较索引为1的数3，1小于3，则将索引为2的数改为3，索引为1之前有索引为0的数2，1小于2，则将索引为1的数改为2，索引为0的数改为1 (大数往后挪），得到数组[1, 2, 3, 6, 5, 4]
 * 11.取索引为3的数6，比较索引为2的数3，6大于3，继续
 * 12.取索引为4的数5，比较索引为3的数6，5小于6，则将索引为4的数改为6，索引为3之前有索引为2的数3，5大于3，则将索引为3的数改为5，得到数组[1, 2, 3, 5, 6, 4]
 * 13.取索引为5的数4，比较索引为4的数6，4小于6，则将索引为5的数改为6，索引为4之前有索引为3的数5，4小于5，则将索引为4的数改为5，得到数组[1, 2, 3, 5, 5, 6]；索引为3之前有索引为2的数3，4大于3，则将所因为3的数改为4，得到数组[1, 2, 3, 4, 5, 6]
 */
public class ShellSort {
    public static void sort(int[] array) {  
        int len = array.length;  
        for (int gap = len / 2; gap > 0; gap /= 2) {  
            for (int i = gap; i < len; i++) {  
                int temp = array[i];  
                int j = i;
                int index = j - gap;
                while (j >= gap && array[index] > temp) {
                    array[j] = array[j - gap];
                    j -= gap;
                    index = j - gap;
                }  
                array[j] = temp;  
            }  
        }  
    }

    public static void print(int[] array) {
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
  
    public static void main(String[] args) {
        int array[] = {6, 2, 4, 3, 5, 1};
        sort(array);  
        print(array);
    }  
}

4. java示例截图