基础知识
递归
基本概念及调用规则
简单的说:递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂的问题,同时可以让代码变得简洁。
递归调用规则:
- 当程序执行到一个方法时,就会开辟一个独立地空间(栈空间)
- 方法的局部变量是独立地,不会相互影响。
- 如果方法中使用的是引用类型变量(比如数组),就会共享该引用类型的数据。
- 递归必须向退出递归的条件逼近,否则就是无限递归。
- 当一个方法执行完毕,或者遇到return,就会返回,遵守谁调用,就将结果返回给谁,同时当方法执行完毕或者返回时,该方法也就执行完毕。
递归在虚拟机中的执行示意图
//Demo
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);
}
}
递归-迷宫问题
说明
- 小球得到的路径,和程序员设置的找路策略有关。即:找路的上下左右的顺序相关
- 再得到小球路径时,可以先使用(下右上左),再改成(上右下左),看看路径是不是有变化。
- 测试回溯现象
- 思考:如何求出最短路径?
代码实例
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 = 1; i < 8; i++) {
map[i][0] = 1;
map[i][6] = 1;
}
//设置挡板
map[3][1] = 1;
map[3][2] = 1;
//输出地图
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
System.out.print(map[i][j] + " ");
}
System.out.println();
}
System.out.println();
//使用递归回溯给小球找路
setWay(map, 1, 1);
//输出地图路线;
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) {
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 {
return false;
}
} else {
return false;
}
}
}
}
八皇后问题
说明
八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例。该问题是国际西洋棋手马克思·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即:任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。
思路分析
- 第一个皇后先放到第一行第一列
- 第二个皇后放在第二行第二列、然后判断是否OK,如果不OK,继续放在第二列、第三列、依次把所有列都放完,找到一个合适。
- 继续第三个皇后,还是第一列,第二列… 直到第8个皇后也能放在一个不冲突的位置,算是找到一个正确解
- 当得到一个正确解时,在栈回退到上一个栈时,就会开始回溯,即将第一个皇后,放到第一列的所有正确解,全部得到。
- 然后回头继续第一个皇后放第二列,后面继续循环执行1,2,3的步骤
说明: 理论上应该创建一个二维数组来表示棋盘,但是实际上可以通过算法,用一个一维数组即可解决问题。arr[8]={0,4,7,5,2,6,1,3}//对应arr下标 表示第几行,即第几个皇后,arr[i]=val,val表示第i+1个皇后,放在第i+1行的第val+1列
代码实例
public class Queue8 {
//定义一个max表示共有多少个皇后;
int max = 8;
//定义数组array,保存皇后放置位置的结果,比如arr={0,4,7,5,2,6,1,3}
int[] array = new int[max];
public static void main(String[] args) {
Queue8 queue = new Queue8();
queue.check(0);
}
//编写一个方法,放置第n个皇后
//特别注意:check 是每一次递归时,进入到check中都有 for(int i=0;i<max;i++),因此会有回溯
private void check(int n) {
if (n == max) { //n==8,其实8个皇后就已经放好(0~7)
print();
return;
}
//依次放入皇后,并判断是否冲突
for (int i = 0; i < max; i++) {
//先把当前这个皇后 第n个皇后放到该行的第1列.
array[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个皇后在同一斜线
if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
return false;
}
}
return true;
}
//写一个方法,可以将皇后摆放的位置打印出来
private void print() {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
}
算法的时间复杂度
度量是一个程序(算法)执行时间的两种方法
- 事后统计的方法
这种方法可行,但是有两个问题:一是要想对设计的算法的运行性能进行评测,需要实际运行该程序;二是所得时间的统计量依赖于计算机的硬件、软件等环境因素,这种方式,要在同一计算机的相同状态下运行,才能比较哪个算法速度更快。- 事前估算的方法
通过分析某个算法的时间复杂度来判断哪个算法更优
时间频度
基本介绍
时间频度: 一个算法花费的时间与算法中语句的执行次数成正比例,哪个算法中语句执行次数多,它花费时间就多,一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)
时间复杂度
- 一般情况下,算法中的基本操作语句的重复执行次数是问题规模n的某个函数,用T(n)表示,若有某个辅助函数f(n),使得当n趋近于无穷大时,T(n)/f(n) 的极限值为不等于零的常数,则称f(n) 是T(n) 的同数量级函数。记作T(n)=O(f(n)),称O(f(n))为算法的渐进时间复杂度,简称时间复杂度。
- T(n) 不同,但时间复杂度可能相同。如:T(n)=n²+7n+6与T(n)=3n²+2n+2它们的T(n)不同,但时间复杂度相同,都为O(n²)。
- 计算时间复杂度的方法:
- 用常数1代替运行时间中的所有加法常数
- 修改后的运行次数函数中,只保留最高阶项
- 去除最高阶项的系数
常见的时间复杂度
- 常数阶O(1)
- 对数阶O(log2n)
- 线性阶O(n)
- 线性对数阶O(nlog2n)
- 平方阶O(n²)
- 立方阶O(n³)
- k次方阶O(n^k)
- 指数阶O(2^n)
说明:
常见的算法时间复杂度由小到大依次为:O(1)<O(log2n)<O(n)<O(nlog2n)<O(n²)<O(n³)<O(n^k) <O(2^n) 随着问题规模n的不断增大,上述时间复杂度不断增大,算法的执行效率越低。
排序算法
排序算法的介绍
排序是将一组数据,依指定的顺序进行排列的过程。
排序的分类:
- 内部排序:指将需要处理的所有数据都加载到内部存储器中进行排序。
- 外部排序法:数据量过大,无法全部加载到内存中,需要借助外部存储进行排序。
- 常见的排序算法分类:
冒泡排序
容易理解,不做过多叙述
代码实例
public class BubbleSort {
public static void main(String[] args) {
int arr[] = {3, 9, -1, 10, -2};
int[] ints = bubbleSort(arr);
print(ints);
}
public static int[] bubbleSort(int[] arr) {
int temp;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
选择排序
选择排序属于内部排序算法,是从欲排序的数据中,按指定的规则选出某一元素,再依规定交换位置后达到排序的目的。
代码实例
public class SelectSort {
public static void main(String[] args) {
int arr[] = {3, 9, 10, -2, -3};
int[] ints = selectSort(arr);
print(ints);
}
public static int[] selectSort(int[] arr) {
int temp;
for (int i = 0; i < arr.length - 1; i++) {
int index = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[index] > arr[j]) {
index = j;
}
}
temp = arr[index];
arr[index] = arr[i];
arr[i] = temp;
}
return arr;
}
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
插入排序
插入排序属于内部排序法,是对于欲排序的元素以插入的方式寻找该元素的适当位置,以达到排序的目的。
实例代码
public class InsertSort {
public static void main(String[] args) {
int arr[] = {-3,-5,-6,3, 9, 10, -2, -3};
int[] ints = insertSort(arr);
print(ints);
}
public static int[] insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int Index = i - 1;
int temp = arr[i];
while (Index >= 0 && arr[Index] > temp) {
arr[Index + 1] = arr[Index];
Index--;
}
arr[Index + 1] = temp;
}
return arr;
}
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
希尔排序
希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。