基础知识
递归
基本概念及调用规则
简单的说：递归就是方法自己调用自己，每次调用时传入不同的变量.递归有助于编程者解决复杂的问题，同时可以让代码变得简洁。
递归调用规则：
- 当程序执行到一个方法时，就会开辟一个独立地空间（栈空间）
- 方法的局部变量是独立地，不会相互影响。
- 如果方法中使用的是引用类型变量（比如数组），就会共享该引用类型的数据。
- 递归必须向退出递归的条件逼近，否则就是无限递归。
- 当一个方法执行完毕，或者遇到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时，整个文件恰被分成一组，算法便终止。
1209
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
