1.排序算法简介
排序也称为排序算法。排序是将一组数据依据指定的顺序进行排列的过程。
2.常见的排序算法分类如下图：
稳定性口诀：
选泡插，快归堆希桶计基，不稳稳稳不稳稳，不稳不稳稳稳稳
3.希尔排序：
1.引入：
在简单插入排序中可能存在一些问题。例如：
数组arr={2,3,4,5,6,1}，排序时需要插入的数1是最小的，就需要先把6后移，再把5后移，4后移，3后移，2后移。
于是可以得出一个结论：当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响。
由于我们在考虑算法时要考虑最坏情况，那么最坏情况下这个影响就比较大了。
2.希尔排序介绍
希尔排序是希尔于1959年提出的一种排序算法，它也是一种插入排序，是简单那插入排序经过改进之后的一种更高效版本，也称为缩小增量排序。
3.希尔排序思想
把记录按下标的一定增量分组，（先将其分为数组长度的一半，然后再把一半继续分为一半，依此类推）对每一组使用直接插入排序算法排序，随着增量逐渐变小，每组包含的关键词越来越多，当增量减至1时，整个文件恰好被分为一组，算法便终止。
4.动态图解
5.静态图解
比如原始数组中数据颜色相同的为一组
8，9，1，7，2，3，5，4，6，0
初始增量gap=length/2=5。这里的length就是数组元素个数
那么8就对着3，9对着5，1对着4，7对着6，2对着0，整个数组被分为5组，[8,3],[9,5],[1,4],[7,6],[2,0]。就是下图这样。你就想嘛，第一步是，跨越半个数组与你心连心。
然后对这5组分别进行直接插入排序。这样比较之后间隔为半个数组的比较小的元素已经换到数组中的前半部分了，后面的就是相隔半个数组的比较大的元素了。
接下来缩小增量gap=5/2=2,[3,1,0,9,7]与[5,6,8,4,2]。这两组直接插入排序后，[3,1,0,9,7]排好是[0,1,3,7,9],[5,6,8,4,2]排好后是[2,4,5,6,8]，整个的数组成了[0,2,1,4,3,5,7,6,9,8]。整个数组是下面这样的
接下来再缩小增量gap=2/2=1，此时整个数组是一组，已经趋于有序了。进行插入排序的话比较之后要移也就移一位，轻松许多，而不是一个小数要与众多大数比较，它只需要与跟自己差距只有一点点的元素比较。
希尔排序时，对于有序序列在插入时可以采用交换法，也可以采用移动法，我们分别对使用这两种方法的代码进行测试。
6.希尔排序中使用交换法的代码
1.推导：
第一轮：从数组的后一半开始到数组结束，与数组前面间隔5的元素一个个比较，后一半的更大就换到前面去。
//第一轮，即gap为数组长度的一半，即5
for (int i = 5; i < arr.length; i++) {
for (int j = i - 5; j >= 0; j -= 5) {
if (arr[j] > arr[j + 5]) {
temp = arr[j];
arr[j] = arr[j + 5];
arr[j + 5] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
输出结果为每一次比较交换一组后的情况。这里就是8和3比较，9和5比较，1和4比较，7和6比较，2和0比较。
所以第一轮结束后，这5组的都比较完了，比较的是gap为5的。
第二轮：
for (int i = 2; i < arr.length; i++) {
for (int j = i - 2; j >= 0; j -= 2) {
if (arr[j] > arr[j + 2]) {
temp = arr[j];
arr[j] = arr[j + 2];
arr[j + 2] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
System.out.println("第二轮结束："+Arrays.toString(arr));
输出结果：
第三轮：
//第三轮
for (int i = 1; i < arr.length; i++) {
for (int j = i - 1; j >= 0; j -= 1) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
System.out.println("第三轮结束：" + Arrays.toString(arr));
输出结果：
2.用循环取gap，合并起来的代码：
public static void shellSort(int[] arr) {
int temp = 0;
int count=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("第"+(++count)+"轮排序结果：" + Arrays.toString(arr));
}
}
输出结果：
3.完整代码：
package com.xjj.sort;
import java.util.Arrays;
public class ShellSort {
public static void main(String[] args) {
int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
shellSort2(arr);
}
//推导
public static void shellSort1(int[] arr) {
int temp = 0;
//第一轮，即gap为数组长度的一半，即5
for (int i = 5; i < arr.length; i++) {
for (int j = i - 5; j >= 0; j -= 5) {
if (arr[j] > arr[j + 5]) {
temp = arr[j];
arr[j] = arr[j + 5];
arr[j + 5] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
System.out.println("第一轮结束：" + Arrays.toString(arr));
//第二轮，gap为数组长度一半的一半，即2
for (int i = 2; i < arr.length; i++) {
for (int j = i - 2; j >= 0; j -= 2) {
if (arr[j] > arr[j + 2]) {
temp = arr[j];
arr[j] = arr[j + 2];
arr[j + 2] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
System.out.println("第二轮结束：" + Arrays.toString(arr));
//第三轮
for (int i = 1; i < arr.length; i++) {
for (int j = i - 1; j >= 0; j -= 1) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
System.out.println("第三轮结束：" + Arrays.toString(arr));
//那么可以将gap设为变量，就可以在循环中改变值，5，2，1这样的
}
//下面是直接变成gap变量来的
public static void shellSort2(int[] arr) {
int temp = 0;
int count=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("第"+(++count)+"轮排序结果：" + Arrays.toString(arr));
}
}
}运行结果：
4.运行时间
插入段记录时间的代码。排序前记一次时间，排序后记一次时间。
然后输出元素的代码就先注释掉。
4.1代码：
package com.xjj.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class ShellSort {
public static void main(String[] args) {
// int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
// shellSort2(arr);
int arr2[]=new int[80000];
for(int i=0;i<80000;i++){
arr2[i]=(int)(Math.random()*80000);
}
Date date1=new Date();
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str=simpleDateFormat.format(date1);
System.out.println("排序前的时间为："+date1Str);
shellSort2(arr2);
Date date2=new Date();
String date2Str=simpleDateFormat.format(date2);
System.out.println("排序后的时间为："+date2Str);
}
//推导
public static void shellSort1(int[] arr) {
int temp = 0;
//第一轮，即gap为数组长度的一半，即5
for (int i = 5; i < arr.length; i++) {
for (int j = i - 5; j >= 0; j -= 5) {
if (arr[j] > arr[j + 5]) {
temp = arr[j];
arr[j] = arr[j + 5];
arr[j + 5] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
System.out.println("第一轮结束：" + Arrays.toString(arr));
//第二轮，gap为数组长度一半的一半，即2
for (int i = 2; i < arr.length; i++) {
for (int j = i - 2; j >= 0; j -= 2) {
if (arr[j] > arr[j + 2]) {
temp = arr[j];
arr[j] = arr[j + 2];
arr[j + 2] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
System.out.println("第二轮结束：" + Arrays.toString(arr));
//第三轮
for (int i = 1; i < arr.length; i++) {
for (int j = i - 1; j >= 0; j -= 1) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
System.out.println("第三轮结束：" + Arrays.toString(arr));
//那么可以将gap设为变量，就可以在循环中改变值，5，2，1这样的
}
//下面是直接变成gap变量来的
public static void shellSort2(int[] arr) {
int temp = 0;
int count=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("第"+(++count)+"轮排序结果：" + Arrays.toString(arr));
}
}
}
4.2运行结果：
80000个元素，希尔排序交换法运行时间4秒。还挺慢的，不如直接的插入排序。
7.希尔排序中使用移位法的代码
1.方法代码：
//将交换法改成移位法
public static void shellSort3(int[] arr) {
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
//从第gap个元素开始逐个对其所在的组进行直接插入排序
for (int i = gap; i < arr.length; i++) {
int j = i;//保存待插入的下标
int temp = arr[j];//保存待插入的值
if (arr[j] < arr[j - gap]) {
while (j - gap >= 0 && temp < arr[j - gap]) {
//移动，j-gap移动到j
arr[j] = arr[j - gap];
j -= gap;
}
//退出循环后找到了插入位置
arr[j] = temp;
}
}
}
}可以去和前面的插入排序的代码对比一下
插入排序里是insertIndex=i-1;insertVal=arr[i]
这里是j=i;temp=arr[j]也就是temp=arr[i]
这里的j-gap就好像插入排序里的insertIndex
2.运行时间
插入段记录时间的代码。排序前记一次时间，排序后记一次时间。
2.1代码：
package com.xjj.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class ShellSort {
public static void main(String[] args) {
// int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
// shellSort2(arr);
int arr2[] = new int[80000];
for (int i = 0; i < 80000; i++) {
arr2[i] = (int) (Math.random() * 80000);
}
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间为：" + date1Str);
// shellSort2(arr2);
shellSort3(arr2);
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间为：" + date2Str);
}
//将交换法改成移位法
public static void shellSort3(int[] arr) {
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
//从第gap个元素开始逐个对其所在的组进行直接插入排序
for (int i = gap; i < arr.length; i++) {
int j = i;//保存待插入的下标
int temp = arr[j];//保存待插入的值
if (arr[j] < arr[j - gap]) {
while (j - gap >= 0 && temp < arr[j - gap]) {
//移动，j-gap移动到j
arr[j] = arr[j - gap];
j -= gap;
}
//退出循环后找到了插入位置
arr[j] = temp;
}
}
}
}
}
2.2运行结果：
80000个元素，希尔排序移位法运行时间1秒内非常快了。
希尔排序好快。希尔排序缩小增量。
加油加油^_^
1033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
