本文详细介绍了Java中希尔排序的基本思想、示意图、交换式和移位式的实现及运行结果，还涵盖了快速排序的原理、应用实例、代码实现和算法速度测试，通过实例解析了两种高效排序算法。
目录
希尔排序算法思路图解
介绍
希尔排序是希尔于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
基本思想
希尔排序是把记录下标的一定增量分组，对每组使用直接插入排序算法排序，随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
示意图
算法实现
交换式
package 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};
shellSort(arr);
}
//使用逐步推导的方式来编写希尔排序
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++) {
//遍历各组中所有的元素(共gap组，每组有2个元素)，步长5
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));
}
//希尔排序的第一轮排序
//因为第一轮排序，是将10个数据分成了5组
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]) {
temp=arr[j];
arr[j]=arr[j+5];
arr[j+5]=temp;
}
}
}
System.out.println("希尔排序1轮后="+Arrays.toString(arr));
//希尔排序的第2轮排序
//因为第2轮排序，是将10个数据分成了5/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]) {
temp=arr[j];
arr[j]=arr[j+2];
arr[j+2]=temp;
}
}
}
System.out.println("希尔排序2轮后="+Arrays.toString(arr));
//希尔排序的第3轮排序
//因为第3轮排序，是将10个数据分成了2/2=1组
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]) {
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
System.out.println("希尔排序3轮后="+Arrays.toString(arr));
}
}运行结果
移位式
package sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class ShellSort {
public static void main(String[] args) {
//创建要给80000个的随机的数组
int[] arr=new int[80000];
for (int i = 0; i <80000; i++) {
arr[i]=(int)(Math.random()*80000);//生成一个[0,8000000]数
}
System.out.println("排序前");
Date data1=new Date();
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str=simpleDateFormat.format(data1);
System.out.println("排序前的时间是:"+date1Str);
// int [] arr= {8,9,1,7,2,3,5,4,6,0};
shellSort(arr);
Date data2=new Date();
String date2Str=simpleDateFormat.format(data2);
System.out.println("排序后的时间是:"+date2Str);
// System.out.println("排序前的时间是="+date2Str);
}
//使用逐步推导的方式来编写希尔排序
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++) {
//遍历各组中所有的元素(共gap组，每组有2个元素)，步长5
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));
}
/* //希尔排序的第一轮排序
//因为第一轮排序，是将10个数据分成了5组
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]) {
temp=arr[j];
arr[j]=arr[j+5];
arr[j+5]=temp;
}
}
}
System.out.println("希尔排序1轮后="+Arrays.toString(arr));
//希尔排序的第2轮排序
//因为第2轮排序，是将10个数据分成了5/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]) {
temp=arr[j];
arr[j]=arr[j+2];
arr[j+2]=temp;
}
}
}
System.out.println("希尔排序2轮后="+Arrays.toString(arr));
//希尔排序的第3轮排序
//因为第3轮排序，是将10个数据分成了2/2=1组
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]) {
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
System.out.println("希尔排序3轮后="+Arrays.toString(arr));
}
//对交换式的希尔排序进行优化->移位法
public static void shellSort2(int[] arr) {
//增量gap,并逐步的缩小增量
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[i]<arr[j]-gap) {
while (j-gap>=0&&temp<arr[j-gap]) {
//移动
arr[j]=arr[j-gap];
j-=gap;
}
//当退出while后，就给temp找到插入的位置
arr[j]=temp;
}
}
}*/
}
}运行结果
快速排序
介绍
快速排序是对冒泡排序的一种改进。基本思想:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序数列。
应用实例
示意图
代码实现
package sort;
import java.util.Arrays;
public class QuickSort {
public static void main(String[] args) {
int [] arr= {-9,78,0,23,-567,70};
quickSort(arr,0,arr.length-1);
System.out.println("arr="+Arrays.toString(arr));
}
public static void quickSort(int[] arr,int left,int right) {
int l=left;//左下标
int r=right;//右下标
//pivot中轴值
int pivot=arr[(left+right)/2];
int temp=0;//临时变量，作为交换时使用
//while循环的目的是让比pivot 值小放到左边
//比pivot值大放到左边
while (l<r) {
//在pivot的左边一直找，找到大于等于pivot值，才退出
while(arr[1]<pivot) {
l+=1;
}
//在pivot的右边一直找，找到大于等于pivot值，才退出
while(arr[r]>pivot) {
r-=1;
}
//如果l>=r说明pivot的左右两的值，已经按照左边全部是
//小于等于pivot值，右边全部是大于等于pivot值
if (l>=r) {
break;
}
//交换
temp=arr[1];
arr[1]=arr[r];
arr[r]=temp;
//如果交换完后，发现这个arr[1]==pivot值相等--，前移
if (arr[1]==pivot) {
r-=1;
}
//如果交换完后，发现arr[r]==pivot值相等1++,后移
if (arr[r]==pivot) {
l+=1;
}
}
//如果l==r,必须l++,r--,否则为出现栈溢出
if (l==r) {
l+=r;
r-=1;
}
//向左递归
if (left<r) {
quickSort(arr, left, r);
}
//向右递归
if (right>1) {
quickSort(arr,1, right);
}
}
}算法速度测试
完整代码
package sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class QuickSort {
public static void main(String[] args) {
// int [] arr= {-9,78,0,23,-567,70};
//测试快排的执行速度
//创建要给80000个的随机的数值
int[] arr=new int[80000];
for (int i = 0; i <80000; i++) {
arr[i]=(int)(Math.random()*80000);//生成一个[0,8000000]数
}
System.out.println("排序前");
Date data1=new Date();
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str=simpleDateFormat.format(data1);
System.out.println("排序前的时间是:"+date1Str);
quickSort(arr,0,arr.length-1);
Date data2=new Date();
String date2Str=simpleDateFormat.format(data2);
System.out.println("排序后的时间是:"+date2Str);
System.out.println("arr="+Arrays.toString(arr));
}
public static void quickSort(int[] arr,int left,int right) {
int l=left;//左下标
int r=right;//右下标
//pivot中轴值
int pivot=arr[(left+right)/2];
int temp=0;//临时变量，作为交换时使用
//while循环的目的是让比pivot 值小放到左边
//比pivot值大放到左边
while (l<r) {
//在pivot的左边一直找，找到大于等于pivot值，才退出
while(arr[1]<pivot) {
l+=1;
}
//在pivot的右边一直找，找到大于等于pivot值，才退出
while(arr[r]>pivot) {
r-=1;
}
//如果l>=r说明pivot的左右两的值，已经按照左边全部是
//小于等于pivot值，右边全部是大于等于pivot值
if (l>=r) {
break;
}
//交换
temp=arr[1];
arr[1]=arr[r];
arr[r]=temp;
//如果交换完后，发现这个arr[1]==pivot值相等--，前移
if (arr[1]==pivot) {
r-=1;
}
//如果交换完后，发现arr[r]==pivot值相等1++,后移
if (arr[r]==pivot) {
l+=1;
}
}
//如果l==r,必须l++,r--,否则为出现栈溢出
if (l==r) {
l+=r;
r-=1;
}
//向左递归
if (left<r) {
quickSort(arr, left, r);
}
//向右递归
if (right>1) {
quickSort(arr,1, right);
}
}
}结果运行
2567
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
