希尔排序
什么是希尔排序
希尔排序(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));
}