1)二维数组的静态初始化：
int[][] arr = new int[][] { {1,2,3}, {4,5}, {6,7}}
2)杨辉三角：
/**
* 需求：计算并模拟杨辉三角
* 如：
* 1
* 1 1
* 1 2 1
* 1 3 3 1
*/
public class PascalTriangle {
// 打算模拟的行数
public static int row = 10;
public static void main(String[] args) {
int[][] arr = new int[row][];
for(int i = 0; i < arr.length; i++) {
int len = i + 1;
arr[i] = new int[len];
for(int j = 0; j < len; j++) {
if(j == 0 || j == i) {
arr[i][j] = 1; // head and tail number
} else {
arr[i][j] = arr[i-1][j] // middle number
+ arr[i-1][j-1];
}
}
}
// 验证数值模拟的正确性
// for(int[] ele : arr) {
// System.out.println(java.util.Arrays.toString(ele));
// }
// 打印杨辉三角
printPascalTriangle(arr);
}
/**
* 需求：按照原始形式打印杨辉三角
* 如： 1
* 1 1
* 1 2 1
* 1 3 3 1
* 1 4 6 4 1
*/
public static void printPascalTriangle(int[][] arr) {
if(arr == null || arr.length == 0) return;
int rows = arr.length;
for(int i = 0; i < arr.length; i++) {
if(arr[i] == null || arr[i].length == 0) return;
int left = row - i;
while(true) {
if(left-- == 0) break;
System.out.print("\t");
}
for(int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j]);
System.out.print("\t\t");
}
System.out.println("\n");
}
}
}
3)汉诺塔：
private void hannuo(int n, char from,
char to, char depend) {
if(n==1) {
move(n, from, to);
} else {
hannuo(n-1, from, depend, to);
move(n, from, to);
hannuo(n-1, depend, to, from);
}
}
private void move(int n, char from, char to) {
System.out.println(……);
}
4) for each循环的陷阱：对于基本类型的数组，在循环内部无法改变数组内容，但是对于引用（对象）数组或多维数组，循环内部是可以修改原始内容的。
5）排序算法：
1.选择排序：直接选择与堆排序
2.交换排序：冒泡排序、快速排序
3.插入排序：直接插入、二分法排序、Shell排序
4.归并排序
6）冒泡排序的思考模型(Bubble Sort)：
这是最简单的排序法，基本思路：
对未排序的各元素从头到尾依次比较相邻的两个元素大小关系，若大于则交换位置，经过第一轮比较排序后可得出最大值，然后使用同样的方法把剩下的元素逐个比较即可。
可以看出若有N个元素，那么一共要进行N-1轮比较，第M轮要进行N-M次比较。（若6个元素，要进行6-1轮比较，第一轮比较6-1次，第三轮比较6-3次）。
7）选择排序(Selection Sort)：
基本思路：选择某个索引位置的元素，然后和后面元素依次比较，若大于则交换位置，经过第一轮比较排序后可得出最小值，然后使用同样的方法把剩下的元素逐个比较即可。
可以看出选择排序，第一轮会选出最小值，第二轮会选出第二小的值，直到最后。
第一轮从arr[0]和后面元素相比较，第二轮从arr[1]和后面的元素相比较，依次类推。N个数要进行N-1轮。选择排序每一轮只进行一次交换，相对于冒泡排序效率高一些。
8）搜索方法：
1）顺序搜素：效率低
2）二分法搜索：效率高，但只能在有序序列中进行搜索