目录
第五章递归
5.1 递归的概念
简单的来说：递归就是方法自己调用自己，每次调用时传入不同的变量。递归有助于编程者解决复杂的问题，同时可以让代码变得简洁。
5.2 递归调用机制的讲解
package recursion;
public class RecursionTest {
public static void main(String[] args) {
//通过打印问题，回顾递归调用机制
test(4);
}
public static void test(int n){
if(n > 2){
test(n -1);
}
System.out.println("n=" + n);
}
}
递归调用规则：
1. 当程序执行到一个方法时，就会开辟一个独立的空间(栈)
2. 每个空间的数据(局部变量)，是独立的.
5.3 递归能解决什么样的问题
1)各种数学问题如:8皇后问题,汉诺塔,阶乘问题,迷宫问题,球和篮子的问题(google编程大赛)
2)各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等.
3)将用栈解决的问题-->第归代码比较简洁
5.4 递归需要遵守的重要规则
1)执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
2)方法的局部变量是独立的，不会相互影响,比如n变量
3)如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.
4)递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了:)
5)当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕
5.5 递归-迷宫问题
5.5.1迷宫问题
5.5.2 代码实现
package recursion;
public class MiGong {
public static void main(String[] args) {
//先创建一个二维数组，模拟迷宫
//地图
int[][] map = new int[8][7];
//使用1表示墙
//上下全部置为1
for (int i = 0; i < 7; i++) {
map[0][i] = 1;
map[7][i] = 1;
}
//左右置为1
for (int i = 0; i < 8; i++) {
map[i][0] = 1;
map[i][6] = 1;
}
//设置挡板 1 表示
map[3][1] = 1;
map[3][2] = 1;
// map[1][2] = 1;
// map[2][2] = 1;
//输出地图
System.out.println("地图的情况");
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
System.out.print(map[i][j]+ " ");
}
System.out.println();
}
//使用递归回溯给小球找路
setWay(map,1,1);
//输出新的地图小球走过，并标识的递归
System.out.println("输出新的地图小球走过，并标识的递归");
System.out.println("地图的情况");
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
System.out.print(map[i][j]+ " ");
}
System.out.println();
}
}
//使用递归回溯来给小球找路
//说明
//1.map 表示地图
//2.i，j 表示从地图哪个位置开始出发(1,1)
//3.如果小球能到map[6][5] 位置，则说明通路找到，
//4.约定：当map[i][j] 0表示该点当前没有走过 1为墙；2表示通路可以走；3 表示该点已经走过，但是走不通
//5.在你走迷宫时，需要确定一个策略（方法）下->右->上->左,如果该点走不通，再回溯
/**
*
* @param map 表示地图
* @param i 从哪个位置开始找
* @param j
* @return 如果找到通路，就返回true，否则返回false
*/
public static boolean setWay(int[][] map, int i,int j){
if(map[6][5] == 2){ //通路已经找到ok
return true;
}else {
if(map[i][j] == 0){ //如果当前这个点还没有走过
//安装策略 下->右->上->左
map[i][j] = 2;// 假定该点可以走通
if(setWay(map,i+1,j)){ // 向下走
return true;
}else if(setWay(map,i,j+1)){// 向右走
return true;
}else if(setWay(map,i-1,j)){// 向上走
return true;
}else if(setWay(map,i,j-1)){// 向左走
return true;
}else {
//说明该点走不通，是死路
map[i][j] = 3;
return false;
}
}else { // 如果map[i][j] !=0,可能是1，2，3
return false;
}
}
}
//修改找路的策略
}
输出结果
5.5.3对迷宫问题的讨论
1)小球得到的路径，和程序员设置的找路策略有关即：找路的上下左右的顺序相关
2)再得到小球路径时，可以先使用(下右上左)，再改成(上右下左)，看看路径是不是有变化
3)测试回溯现象
4)思考:如何求出最短路径?思路-》代码实现.
修改策略 上->右->下->左
//修改找路的策略，改成 上->右->下->左
public static boolean setWay2(int[][] map, int i,int j){
if(map[6][5] == 2){ //通路已经找到ok
return true;
}else {
if(map[i][j] == 0){ //如果当前这个点还没有走过
//安装策略 下->右->上->左
map[i][j] = 2;// 假定该点可以走通
if(setWay2(map,i-1,j)){ // 向上走
return true;
}else if(setWay2(map,i,j+1)){// 向右走
return true;
}else if(setWay2(map,i+1,j)){// 向下走
return true;
}else if(setWay2(map,i,j-1)){// 向左走
return true;
}else {
//说明该点走不通，是死路
map[i][j] = 3;
return false;
}
}else { // 如果map[i][j] !=0,可能是1，2，3
return false;
}
}
}
输出
5.6 递归-八皇后问题（回溯算法）
5.6.1 八皇后问题介绍
八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法(92)
5.6.2八皇后问题算法思路分析
1)第一个皇后先放第一行第一列
2)第二个皇后放在第二行第一列、然后判断是否OK，如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
3)继续第三个皇后，还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解
4)当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到.
5)然后回头继续第一个皇后放第二列，后面继续循环执行1,2,3,4的步骤
6)示意图:
说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题.arr[8]={0,4,7,5,2,6,1,3}//对应arr下标表示第几行，即第几个皇后，arr[i]=val,val表示第i+1个皇后，放在第i+1行的第val+1列
代码如下
package recursion;
import static sun.misc.Version.print;
public class Queue8 {
//定义一个max共有多少个皇后
int max = 8;
//定义数组array，保存皇后放置位置的结果，比如arr[8]={0,4,7,5,2,6,1,3}
int[] array = new int[max];
static int count = 0;
public static void main(String[] args) {
//测试一把，8皇后是否正确
Queue8 queue8 = new Queue8();
queue8.check(0);
System.out.printf("一共有%d解法",count);
}
//编写一个方法，放置在第n个皇后
//特别注意：check 是每一次递归时，进入到check中都有 for(int i = 0;i < max;i++ )，因此会有回溯
private void check(int n){
if(n == max){ // n = 8，其实8个皇后就已经放好
print();
return;
}
//依次放入皇后，判断是否冲突
for(int i = 0;i < max;i++ ){
//先把当前这个皇后n，放倒该行的第1列
array[n] = i;
//判断当后置第n个 皇后到i列时，是否冲突
if(judge(n)){ // 不冲突
//接着放n+1个皇后，开始递归
check(n+1);
}
//如果冲突，就继续执行 array[n] = i;即讲第n个皇后，放置在本行 后移一个位置
}
}
//查看当我们放置第n个皇后，就去检测该皇后是否和前面已经摆放的皇后冲突
/**
*
* @param n 表示第n个皇后
* @return
*/
private boolean judge(int n){
for (int i = 0; i < n; i++) {
//说明
//1.array[i] == array[n] 表示判断 第n个皇后是否和前面的n-1皇后在同一列
//2.Math.abs(n-i) == Math.abs(array[n] - array[i] 表示判断第n个皇后是否和第i皇后是否在同一斜线
//n = 1 放置第2列1 n = 1 array[1] = 1
// Math.abs(1-0) == 1 Math.abs(array[n] - array[i] = Math.abs(1-0) = 1
//3.判断是否同在一行，没有必要，n在递增
if(array[i] == array[n] || Math.abs(n-i) == Math.abs(array[n] - array[i])){
return false;
}
}
return true;
}
//写一个方法，可以将皇后摆放的位置输出
public void print(){
count++;
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+"");
}
System.out.println();
}
}
第六章 排序算法
6.1 排序算法的介绍
排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程。
6.2 排序的分类：
1) 内部排序: 指将需要处理的所有数据都加载到内部存储器(内存)中进行排序。
2) 外部排序法： 数据量过大，无法全部加载到内存中，需要借助外部存储(文件等)进行排序。
3) 常见的排序算法分类(见下图):
6.3 算法的时间复杂度
6.3.1度量一个程序(算法)执行时间的两种方法
1) 事后统计的方法 这种方法可行, 但是有两个问题：一是要想对设计的算法的运行性能进行评测，需要实际运行该程序；二是所 得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式，要在同一台计算机的相同状态下运行，才能比较那个算法速度更快。
2) 事前估算的方法 通过分析某个算法的时间复杂度来判断哪个算法更优
6.3.2时间频度
基本介绍
时间频度：一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间 就多。一个算法中的语句执行次数称为语句频度或时间频度。记为 T(n)。[举例说明]
举例说明-基本案例
举例说明-忽略常数项
结论:
1)2n+20 和 2n 随着n 变大，执行曲线无限接近, 20可以忽略
2)3n+10 和 3n 随着n 变大，执行曲线无限接近, 10可以忽略
举例说明-忽略低次项
结论:
1)2n^2+3n+10 和 2n^2 随着n 变大, 执行曲线无限接近, 可以忽略 3n+10
2)n^2+5n+20 和 n^2 随着n 变大,执行曲线无限接近, 可以忽略 5n+20
举例说明-忽略系数
结论:
1)随着n值变大，5n^2+7n 和 3n^2 + 2n ，执行曲线重合, 说明 这种情况下, 5和3可以忽略。
2)而n^3+5n 和 6n^3+4n ，执行曲线分离，说明多少次方式关键。
6.3.3时间复杂度
1)一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。
2)T(n) 不同，但时间复杂度可能相同。 如：T(n)=n²+7n+6 与 T(n)=3n²+2n+2 它们的T(n) 不同，但时间复杂度相同，都为O(n²)。
3)计算时间复杂度的方法：
•用常数1代替运行时间中的所有加法常数 T(n)=n²+7n+6 => T(n)=n²+7n+1
•修改后的运行次数函数中，只保留最高阶项 T(n)=n²+7n+1 => T(n) = n²
•去除最高阶项的系数 T(n) = n² => T(n) = n² => O(n²)
6.3.4常见的时间复杂度
说明：
随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低
•从图中可见，我们应该尽可能避免使用指数阶的算法
1)常数阶O(1)
无论代码执行了多少行，只要是没有循环等复杂结构，那这个代码的时间复杂度就都是O(1)
上述代码在执行的时候，它消耗的时候并不随着某个变量的增长而增长，那么无论这类代码有多长，即使有几万几十万行，都可以用O(1)来表示它的时间复杂度。
2)对数阶O(log2n)
3)线性阶O(n)
说明：这段代码，for循环里面的代码会执行n遍，因此它消耗的时间是随着n的变化而变化的，因此这类代码都可以用O(n)来表示它的时间复杂度
4)线性对数阶O(nlogN)
说明：线性对数阶O(nlogN) 其实非常容易理解，将时间复杂度为O(logn)的代码循环N遍的话，那么它的时间复杂度就是 n * O(logN)，也就是了O(nlogN)
5)平方阶O(n²)
说明：平方阶O(n²) 就更容易理解了，如果把 O(n) 的代码再嵌套循环一遍，它的时间复杂度就是 O(n²)，这段代码其实就是嵌套了2层n循环，它的时间复杂度就是 O(n*n)，即 O(n²) 如果将其中一层循环的n改成m，那它的时间复杂度就变成了 O(m*n)
6)立方阶O(n³)、K次方阶O(n^k)
说明：参考上面的O(n²) 去理解就好了，O(n³)相当于三层n循环，其它的类似
6.3.5 平均时间复杂度和最坏时间复杂度
1)平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下，该算法的运行时间。
2)最坏情况下的时间复杂度称最坏时间复杂度。一般讨论的时间复杂度均是最坏情况下的时间复杂度。 这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限，这就保证了算法的运行时间不会比最坏情况更长。
3)平均时间复杂度和最坏时间复杂度是否一致，和算法有关(如图:)。
6.3.6 算法的空间复杂度简介
1)类似于时间复杂度的讨论，一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间，它也是问题规模n的函数。
2)空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如快速排序和归并排序算法就属于这种情况
3)在做算法分析时，主要讨论的是时间复杂度。从用户使用体验上看，更看重的程序执行的速度。一些缓存产品(redis, memcache)和算法(基数排序)本质就是用空间换时间.
6.4 冒泡排序
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。(这里说的优化，可以在冒泡排序写好后，在进行)
6.4.1 冒泡排序应用实例
我们举一个具体的案例来说明冒泡法。我们将五个无序的数：3, 9, -1, 10, -2 使用冒泡排序法将其排成一个从小到大的有序数列。
原始数组：3, 9, -1, 10, 20
第一趟排序
(1) 3, 9, -1, 10, 20 // 如果相邻的元素逆序就交换
(2) 3, -1, 9, 10, 20
(3) 3, -1, 9, 10, 20
(4) 3, -1, 9, 10, 20
第二趟排序
(1) -1, 3, 9, 10, 20 //交换
(2) -1, 3, 9, 10, 20
(3) -1, 3, 9, 10, 20
第三趟排序
(1) -1, 3, 9, 10, 20
(2) -1, 3, 9, 10, 20
第四趟排序
(1) -1, 3, 9, 10, 20
小结冒泡排序规则
(1) 一共进行 数组的大小-1 次 大的循环
(2)每一趟排序的次数在逐渐的减少
(3) 如果我们发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序。这个就是优化
冒泡排序的代码
package sort;
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args) {
int arr[] = {3, 9, -1, 10, -2} ;
//冒泡排序的时间复杂度 O(n^2)
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < args.length - i; j++) {
// 如果前面的数比后面的数大，则交换
if(arr[j] > arr[j+1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.println("第"+(i+1)+"趟排序后的数组");
System.out.println(Arrays.toString(arr));
}
}
}
输出结果
优化后的代码
package sort;
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args) {
int arr[] = {3, 9, -1, 10, 20} ;
//冒泡排序的时间复杂度 O(n^2)
int temp = 0; //临时变量
boolean flag = false;//表示变量，表示是否进行过交换
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
// 如果前面的数比后面的数大，则交换
if(arr[j] > arr[j+1]){
flag = true;
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.println("第"+(i+1)+"趟排序后的数组");
System.out.println(Arrays.toString(arr));
if(!flag){// 在一趟排序中，一次交换都没有发生过
break;
}else {
flag = false;// 重置flag，进行下次判断
}
}
}
}
输出结果
测试一下80000个数据的数组使用冒泡排序所用的时间
package sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class BubbleSort {
public static void main(String[] args) {
// int arr[] = {3, 9, -1, 10, 20} ;
//
// System.out.println("排序前");
// System.out.println(Arrays.toString(arr));
//测试一下冒泡排序的速度 O(n^2)，给80000个数据，测试
//创建一个80000个数的随机数组
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random()*8000000);//生成一个[0,8000000）数
}
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间是="+date1Str);
//测试冒泡排序
bubbleSort(arr);
// System.out.println("排序后");
//System.out.println(Arrays.toString(arr));
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间是="+date2Str);
}
//把前面的冒泡排序算法，封装成一个方法
public static void bubbleSort(int[] arr){
//冒泡排序的时间复杂度 O(n^2)
int temp = 0; //临时变量
boolean flag = false;//表示变量，表示是否进行过交换
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
// 如果前面的数比后面的数大，则交换
if(arr[j] > arr[j+1]){
flag = true;
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
// System.out.println("第"+(i+1)+"趟排序后的数组");
// System.out.println(Arrays.toString(arr));
if(!flag){// 在一趟排序中，一次交换都没有发生过
break;
}else {
flag = false;// 重置flag，进行下次判断
}
}
}
}
输出显示
6.5 选择排序
选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规
定交换位置后达到排序的目的。
6.5.1 选择排序思想
选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
6.5.2 选择排序思路分析图
6.5.3 选择排序应用实例:
6.5.4 选择排序代码
package sort;
import java.util.Arrays;
public class SelectSort {
public static void main(String[] args) {
int[] arr = {101,34,119,1,-1,90,123};
System.out.println("排序前");
selectSort(arr);
System.out.println(Arrays.toString(arr));
System.out.println("排序后");
selectSort(arr);
System.out.println(Arrays.toString(arr));
}
//选择排序 时间复杂度是O(n^2)
public static void selectSort(int[] arr){
// 使用循环
for (int i = 0; i < arr.length; i++) {
//第1轮
int minIndex = i;
int min = arr[i];
for (int j = i + 1; j < arr.length; j++) {
if(min > arr[j]){ //说明假定的最小值，并不是最小
min = arr[j]; //重置min
minIndex = j; //重置minIndex
}
}
//将最小值，放在arr[0],即交换
if(minIndex != i){
arr[minIndex] = arr[i];
arr[i] = min;
}
// System.out.println("第"+(i+1)+"一轮后~~");
// System.out.println(Arrays.toString(arr));//1,34,119,101
}
//原始的数组： 101,34,119,1
//第一轮
//第一轮排序： 1,34,119,101
//算法 先简单--》再复杂
/*
//第1轮
int minIndex = 0;
int min = arr[0];
for (int j = 0 + 1; j < arr.length; j++) {
if(min > arr[j]){ //说明假定的最小值，并不是最小
min = arr[j]; //重置min
minIndex = j; //重置minIndex
}
}
//将最小值，放在arr[0],即交换
if(minIndex != 0){
arr[minIndex] = arr[0];
arr[0] = min;
}
System.out.println("第一轮后~~");
System.out.println(Arrays.toString(arr));//1,34,119,101
*/
}
}
输出效果
所需时间
6.6 插入排序
6.6.1 插入排序法思想:
插入排序（Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
6.6.2 插入排序思路图:
6.6.3 插入排序法应用实例:
有一群小牛, 考试成绩分别是 101, 34, 119, 1 请从小到大排序
1、分步做的代码
package sort;
import java.util.Arrays;
public class InsertSort {
public static void main(String[] args) {
int arr[] = {101, 34, 119, 1 };
insertSort(arr);
}
//插入排序
public static void insertSort(int[] arr){
//采用逐步推导
//第1轮:{101,34,119,1} => {34,101,119,1}
//{101,34,119,1}=>{101,101,119,1}
//定义待插入的数
int insertVal = arr[1];
int insertIndex = 1 - 1;//即arr[1]的前面这个数的下标
//给insertVal 找到插入的位置
//说明
//1. insertIndex >=0 保证在给insertVal 找插入的位置，不越界
//2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入的位置
//3. 就需要将arr[insertIndex] 后移
while (insertIndex >=0 && insertVal < arr[insertIndex]){
arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
insertIndex--;
}
//当退出while循环时，说明插入的位置找到，insetIndex + 1
//举例：
arr[insertIndex + 1] = insertVal;
System.out.println("第1轮插入");
System.out.println(Arrays.toString(arr));
//第2轮
insertVal = arr[2];
insertIndex = 2 - 1;
while (insertIndex >=0 && insertVal < arr[insertIndex]){
arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
insertIndex--;
}
arr[insertIndex + 1] = insertVal;
System.out.println("第2轮插入");
System.out.println(Arrays.toString(arr));
//第3轮
insertVal = arr[3];
insertIndex = 3 - 1;
while (insertIndex >=0 && insertVal < arr[insertIndex]){
arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
insertIndex--;
}
arr[insertIndex + 1] = insertVal;
System.out.println("第3轮插入");
System.out.println(Arrays.toString(arr));
}
}
效果演示
2、 简化方法
//插入排序
public static void insertSort(int[] arr){
//使用for循环来把代码简化
for (int i = 1;i< arr.length;i++){
//采用逐步推导
//第1轮:{101,34,119,1} => {34,101,119,1}
//{101,34,119,1}=>{101,101,119,1}
//定义待插入的数
int insertVal = arr[i];
int insertIndex = i - 1;//即arr[1]的前面这个数的下标
//给insertVal 找到插入的位置
//说明
//1. insertIndex >=0 保证在给insertVal 找插入的位置，不越界
//2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入的位置
//3. 就需要将arr[insertIndex] 后移
while (insertIndex >=0 && insertVal < arr[insertIndex]){
arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
insertIndex--;
}
//当退出while循环时，说明插入的位置找到，insetIndex + 1
//举例：
arr[insertIndex + 1] = insertVal;
System.out.println("第"+i+"轮插入");
System.out.println(Arrays.toString(arr));
}
}换数组数据
测试效果
3、 测试所需时间
效果展示
4、代码优化
最后显示所需1秒 效率得到提高
6.6 希尔排序
希尔排序法介绍
希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
希尔排序法基本思想
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止
希尔排序法应用实例:
有一群小牛, 考试成绩分别是 {8,9,1,7,2,3,5,4,6,0} 请从小到大排序. 请分别使用
代码实现
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;
//希尔排序的第1轮排序
//因为第1轮排序，将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 = 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 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组，每组有个元素) 步长为gap
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));
}结果
完整代码
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组，每组有个元素) 步长为gap
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));
}
/**
//希尔排序的第1轮排序
//因为第1轮排序，将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 = 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));
*/
}
}
166
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
