排序算法-希尔算法（工具类）

希尔排序

什么是希尔排序

希尔排序（Shell Sort）是插入排序的一种，它是针对直接插入排序（insertion Sort）的算法的改进。又称为缩小增量排序。

它的基本思想是将待排序的数组元素按下标的一定增量分组，对每组使用直接插入排序算法排序，随着增量逐渐减少，每组包含的元素越来越多，当增量减至1时，整个数组恰被分成一组，算法便终止。

升序排序

@Test
public void testShellSort() {
    int[] a = {34, 23, 78, 45, 12, 35, 78, 90, 25, 39};
    System.out.println("排序前"+Arrays.toString(a));
    int aLength = a.length;
    //定义数组元素之间比较的间隔
    int interval = aLength / 2;
    while (interval > 0) {
        for (int i = interval; i < aLength; i++) {
            //将当前元素数据赋值给变量
            int stemp = a[i];
            //获取间隔对应元素的索引
            int preIndex = i - interval;
            /**
             * a[preIndex] > stemp
             * 间隔对应的连个元素进行比较
             * 如果间隔对应的前元素比后元素大，则赋值调换位置
             */
            while (preIndex >= 0 && a[preIndex] > stemp) {
                //赋值调换位置，前索引的元素赋值到后索引的位置
                a[preIndex + interval] = a[preIndex];

                preIndex -= interval;//相当于preIndex = preIndex - interval;
            }
            a[preIndex + interval] = stemp;
        }
        //缩小元素对比间隔值
        interval /= 2;
    }
    System.out.println("排序后"+Arrays.toString(a));
}

结果

解析

降序排序

@Test
public void testShellSort() {
    int[] a = {34, 23, 78, 45, 12, 35, 78, 90, 25, 39};
    System.out.println("排序前"+Arrays.toString(a));
    int aLength = a.length;
    //定义数组元素之间比较的间隔
    int interval = aLength / 2;
    while (interval > 0) {
        for (int i = interval; i < aLength; i++) {
            //将当前元素数据赋值给变量
            int stemp = a[i];
            //获取间隔对应元素的索引
            int preIndex = i - interval;
            /**
             * a[preIndex] > stemp
             * 间隔对应的连个元素进行比较
             * 如果间隔对应的前元素比后元素大，则赋值调换位置
             */
            while (preIndex >= 0 && a[preIndex] < stemp) {
                //赋值调换位置，前索引的元素赋值到后索引的位置
                a[preIndex + interval] = a[preIndex];

                preIndex -= interval;//相当于preIndex = preIndex - interval;
            }
            a[preIndex + interval] = stemp;
        }
        //缩小元素件对比间隔值
        interval /= 2;
    }
    System.out.println("排序后"+Arrays.toString(a));
}

结果

工具类

package com.sin.demo.utli;

/**
 * @author sin
 * @date 2022/11/1
 * @apiNote
 */
public class ShellSortUtils {
    /**
     * byte类型数组升序排序
     * @param array
     * @return
     */
    public byte[] ascengSort(byte[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                byte stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] > stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * short类型数组升序排序
     * @param array
     * @return
     */
    public short[] ascengSort(short[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                short stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] > stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * int类型数组升序排序
     * @param array
     * @return
     */
    public int[] ascengSort(int[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                int stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] > stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * long类型数组升序排序
     * @param array
     * @return
     */
    public long[] ascengSort(long[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                long stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] > stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * float类型数组升序排序
     * @param array
     * @return
     */
    public float[] ascengSort(float[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                float stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] > stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * char类型数组升序排序
     * @param array
     * @return
     */
    public double[] ascengSort(double[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                double stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] > stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * char类型数组升序排序
     * @param array
     * @return
     */
    public char[] ascengSort(char[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                char stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] > stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }

    /**
     * byte类型数组降序排序
     * @param array
     * @return
     */
    public byte[] dropSort(byte[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                byte stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] < stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * short类型数组降序排序
     * @param array
     * @return
     */
    public short[] dropSort(short[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                short stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] < stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * int类型数组降序排序
     * @param array
     * @return
     */
    public int[] dropSort(int[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                int stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] < stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * long类型数组降序排序
     * @param array
     * @return
     */
    public long[] dropSort(long[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                long stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] < stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * float类型数组降序排序
     * @param array
     * @return
     */
    public float[] dropSort(float[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                float stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] < stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * double类型数组降序排序
     * @param array
     * @return
     */
    public double[] dropSort(double[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                double stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] < stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
    /**
     * char类型数组降序排序
     * @param array
     * @return
     */
    public char[] dropSort(char[] array) {
        int arrayLength = array.length;

        int interval = arrayLength / 2;
        while (interval > 0) {
            for (int i = interval; i < arrayLength; i++) {
                char stemp = array[i];

                int preIndex = i - interval;
                while (preIndex >= 0 && array[preIndex] < stemp) {
                    array[preIndex + interval] = array[preIndex];

                    preIndex -= interval;
                }
                array[preIndex + interval] = stemp;
            }
            interval /= 2;
        }
        return array;
    }
}

//实例化工具类
ShellSortUtils shellSortUtils = new ShellSortUtils();

int类型升序排序

@Test
public void testShellSort() {
    int[] a = {34, 23, 78, 45, 12, 35, 78, 90, 25, 39};
    System.out.println("排序前"+Arrays.toString(a));
    shellSortUtils.ascengSort(a);
    System.out.println("排序后"+Arrays.toString(a));


}

结果

int类型降序排序

@Test
public void testShellSort() {
    int[] a = {34, 23, 78, 45, 12, 35, 78, 90, 25, 39};
    System.out.println("排序前"+Arrays.toString(a));
    shellSortUtils.dropSort(a);
    System.out.println("排序后"+Arrays.toString(a));
}

结果