排序算法-希尔算法(工具类)

希尔排序

什么是希尔排序

希尔排序(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));
}
结果

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陆卿之

你的鼓励将是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值