希尔排序
简单插入排序存在的问题
我们看简单的插入排序可能存在的问题.
数组 arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是：
{2,3,4,5,6,6}
{2,3,4,5,5,6}
{2,3,4,4,5,6}
{2,3,3,4,5,6}
{2,2,3,4,5,6}
{1,2,3,4,5,6}
结论: 当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响
希尔排序法介绍
希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
希尔排序法基本思想
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止
希尔排序算法的示意图
希尔排序算法的示意图
希尔排序示意图
希尔排序法应用实例:
有一群小牛, 考试成绩分别是 {8,9,1,7,2,3,5,4,6,0} 请从小到大排序. 请分别使用
希尔排序时， 对有序序列在插入时采用交换法, 并测试排序速度.
希尔排序时， 对有序序列在插入时采用移动法, 并测试排序速度
代码实现 交换法
package cn.icanci.datastructure.sort;
import java.util.Arrays;
/**
* @Author: icanci
* @ProjectName: AlgorithmAndDataStructure
* @PackageName: cn.icanci.datastructure.sort
* @Date: Created in 2020/3/7 9:17
* @ClassAction: 希尔排序
*/
public class ShellSort {
public static void main(String[] args) {
int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
System.out.println("排序之前");
System.out.println(Arrays.toString(arr));
System.out.println("排序之后");
// shellSort(arr);
shellSortEnd(arr);
}
public static void shellSortEnd(int[] arr) {
int temp = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
for (int i = gap; i < arr.length; i++) {
for (int j = i - gap; j >= 0; j -= gap) {
//如果当前元素大于加上步长之后的元素 就交换
if (arr[j] > arr[j + gap]) {
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
}
}
}
}
System.out.println(Arrays.toString(arr));
}
public static void shellSort(int[] arr) {
//逐步推倒
//希尔排序的第一轮
//因为第一轮排序是将是个数据分成五组
for (int i = 5; i < arr.length; i++) {
//遍历各组中所有的元素 5组每组2个元素 步长 5
for (int j = i - 5; j >= 0; j -= 5) {
//如果当前元素大于加上步长之后的元素 就交换
if (arr[j] > arr[j + 5]) {
int temp = arr[j];
arr[j] = arr[j + 5];
arr[j + 5] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
//因为第2轮排序是将是个数据分成2组
for (int i = 2; i < arr.length; i++) {
//遍历各组中所有的元素 5组每组2个元素 步长 5
for (int j = i - 2; j >= 0; j -= 2) {
//如果当前元素大于加上步长之后的元素 就交换
if (arr[j] > arr[j + 2]) {
int temp = arr[j];
arr[j] = arr[j + 2];
arr[j + 2] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
//因为第3轮排序是将是个数据分成2组
for (int i = 1; i < arr.length; i++) {
//遍历各组中所有的元素 5组每组2个元素 步长 5
for (int j = i - 1; j >= 0; j -= 1) {
//如果当前元素大于加上步长之后的元素 就交换
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
测试
排序之前
[8, 9, 1, 7, 2, 3, 5, 4, 6, 0]
排序之后
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
测试8000速度
封装创建数组的方法
package cn.icanci.datastructure.utils;
/**
* @Author: icanci
* @ProjectName: AlgorithmAndDataStructure
* @PackageName: cn.icanci.datastructure.utils
* @Date: Created in 2020/3/7 9:37
* @ClassAction: 得到指定数目的数组
*/
public class GetNumberArray {
public static int[] getNumberArray(int needNumber) {
int[] arr = new int[needNumber];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) (Math.random() * needNumber * 10);
}
return arr;
}
}
package cn.icanci.datastructure.sort;
import cn.icanci.datastructure.utils.GetNumberArray;
import java.util.Arrays;
/**
* @Author: icanci
* @ProjectName: AlgorithmAndDataStructure
* @PackageName: cn.icanci.datastructure.sort
* @Date: Created in 2020/3/7 9:17
* @ClassAction: 希尔排序
*/
public class ShellSort {
public static void main(String[] args) {
// int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
System.out.println("排序之前");
int[] numberArray = GetNumberArray.getNumberArray(80000);
// System.out.println(Arrays.toString(arr));
System.out.println("排序之后");
// shellSort(arr);
long start = System.currentTimeMillis();
shellSortEnd(numberArray);
System.out.println(System.currentTimeMillis() - start + ":ms");
}
public static void shellSortEnd(int[] arr) {
int temp = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
for (int i = gap; i < arr.length; i++) {
for (int j = i - gap; j >= 0; j -= gap) {
//如果当前元素大于加上步长之后的元素 就交换
if (arr[j] > arr[j + gap]) {
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
}
}
}
}
// System.out.println(Arrays.toString(arr));
}
}
打印结果
排序之前
排序之后
9154:ms
代码实现 移位法
package cn.icanci.datastructure.sort;
import cn.icanci.datastructure.utils.GetNumberArray;
import java.util.Arrays;
/**
* @Author: icanci
* @ProjectName: AlgorithmAndDataStructure
* @PackageName: cn.icanci.datastructure.sort
* @Date: Created in 2020/3/7 9:17
* @ClassAction: 希尔排序
*/
public class ShellSort {
public static void main(String[] args) {
// int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
System.out.println("排序之前");
int[] numberArray = GetNumberArray.getNumberArray(80000);
// System.out.println(Arrays.toString(arr));
System.out.println("排序之后");
// shellSort(arr);
long start = System.currentTimeMillis();
// shellSortEnd(numberArray);
shellSortEndNew(numberArray);
System.out.println(System.currentTimeMillis() - start + ":ms");
}
//对希尔排序进行改进
public static void shellSortEndNew(int[] arr) {
int temp = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
for (int i = gap; i < arr.length; i++) {
int j = i;
temp = arr[j];
if (arr[j] < arr[j - gap]) {
while (j - gap > 0 && temp < arr[j - gap]) {
//移动
arr[j] =arr[j-gap];
j-=gap;
}
//退出循环就找到了位置
arr[j] = temp;
}
}
}
}
}
测试80000数据
排序之前
排序之后
16:ms
