1.二維數組中查找
2.替換空格
3.從尾到頭打印鏈表
4.重建二叉樹
5.用兩個棧實現隊列
6.旋轉數組的最小數字
7.斐波那契數列
8.跳臺階
9.變態跳臺階
10.矩形覆蓋
1.二維數組中查找
在一個二維數組中，每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函數，輸入這樣的一個二維數組和一個整數，判斷數組中是否含有該整數
方法一，從左下開始遍歷，大就往右，小就往上
public static boolean Find(int target, int [][] array) {
int len=array.length-1;
int i=0;
while((len>=0)&&(i<array[0].length)){
if(array[len][i]==target)
return true;
else if(array[len][i]>target)
len--;
else if(array[len][i]<target)
i++;
}
return false;
}
方法二 二分法 把每一行看成有序遞增的數組，利用二分查找，通過遍歷每一行得到答案。
public static boolean Find(int target, int [][] array) {
for(int i=0;i<array.length;i++){
int low=0;
int high=array[i].length-1;
while(low<=high){
int mid=(low+high)/2;
if(target>array[i][mid])
low=mid+1;
else if(target<array[i][mid])
high=mid-1;
else
return true;
}
}
return false;
@Test
public void test(){
int arrays[][]={{1,4,7,9},{2,7,8,11},{4,8,12,19}};
if(Find(12,arrays))
System.out.println("數據含有這樣的整數");
else
System.out.println("沒有這樣的整數");
}
3.從尾到頭打印鏈表
輸入一個鏈表，從尾到頭打印鏈表每個節點的值。
利用棧存儲，后進先出特性
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList list=new ArrayList<Integer>();
Stack<Integer> stack=new Stack<>();
while(listNode!=null){
stack.push(listNode.val);
listNode=listNode.next;
}
while(!stack.isEmpty()){
list.add(stack.pop());
}
return list;
}
4.重建二叉樹
輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重復的數字。例如輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列{4,7,2,1,5,3,8,6}，則重建二叉樹并返回。
1、確定樹的根節點。樹根是當前樹中所有元素在前序遍歷中最先出現的元素。
2、求解樹的子樹。找出根節點在中序遍歷中的位置，根左邊的所有元素就是左子樹，根右邊的所有元素就是右子樹。若根節點左邊或右邊為空，則該方向子樹為空；若根節點左邊和右邊都為空，則根節點已經為葉子節點。
3、遞歸求解樹。將左子樹和右子樹分別看成一棵二叉樹，重復1、2、3步，直到所有的節點完成定位。
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
public TreeNode reConstructBinaryTree(int[] pre,int[] in){
if(pre.length==0||in.length==0)
return null;
TreeNode node=new TreeNode(pre[0]);
for(int i=0;i<in.length;i++){
if(pre[0]==in[i]){
node.left=reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i+1),Arrays.copyOfRange(in, 0, i));
node.right=reConstructBinaryTree(Arrays.copyOfRange(pre, i+1, pre.length), Arrays.copyOfRange(in, i+1, in.length));
}
}
return node;
}
方便理解再舉個例子：
前序遍歷: GDAFEMHZ
中序遍歷: ADEFGHMZ
第一步，根據前序遍歷的特點，我們知道根結點為G
第二步，觀察中序遍歷ADEFGHMZ。其中root節點G左側的ADEF必然是root的左子樹，G右側的HMZ必然是root的右子樹。
第三步，觀察左子樹ADEF，左子樹的中的根節點必然是大樹的root的leftchild。在前序遍歷中，大樹的root的leftchild位于root之后，所以左子樹的根節點為D。
第四步，同樣的道理，root的右子樹節點HMZ中的根節點也可以通過前序遍歷求得。在前序遍歷中，一定是先把root和root的所有左子樹節點遍歷完之后才會遍歷右子樹，并且遍歷的左子樹的第一個節點就是左子樹的根節點。同理，遍歷的右子樹的第一個節點就是右子樹的根節點。
第五步，觀察發現，上面的過程是遞歸的。先找到當前樹的根節點，然后劃分為左子樹，右子樹，然后進入左子樹重復上面的過程，然后進入右子樹重復上面的過程。最后就可以還原一棵樹了。該步遞歸的過程可以簡潔表達如下：
1 確定根,確定左子樹，確定右子樹。
2 在左子樹中遞歸。
3 在右子樹中遞歸。
4 打印當前根。
5.用兩個棧實現隊列
用兩個棧來實現一個隊列，完成隊列的Push和Pop操作。 隊列中的元素為int類型。
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node) {
stack1.push(node);
}
public int pop() {
if(stack1.empty()&&stack2.empty())
throw new RuntimeException("queue is empty");
if(stack2.empty()){
while(!stack1.empty()){
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
6.旋轉數字的最小數字
把一個數組最開始的若干個元素搬到數組的末尾，我們稱之為數組的旋轉。 輸入一個非遞減排序的數組的一個旋轉，輸出旋轉數組的最小元素。 例如數組{3,4,5,1,2}為{1,2,3,4,5}的一個旋轉，該數組的最小值為1。 NOTE：給出的所有元素都大于0，若數組大小為0，請返回0。
采用二分法解答這個問題，
mid = low + (high - low)/2
需要考慮三種情況：
(1)array[mid] > array[high]:
出現這種情況的array類似[3,4,5,6,0,1,2]，此時最小數字一定在mid的右邊。
low = mid + 1
(2)array[mid] == array[high]:
出現這種情況的array類似 [1,0,1,1,1] 或者[1,1,1,0,1]，此時最小數字不好判斷在mid左邊
還是右邊,這時只好一個一個試 ，
high = high - 1
(3)array[mid] < array[high]:
出現這種情況的array類似[2,2,3,4,5,6,6],此時最小數字一定就是array[mid]或者在mid的左
邊。因為右邊必然都是遞增的。
high = mid
注意這里有個坑：如果待查詢的范圍最后只剩兩個數，那么mid 一定會指向下標靠前的數字
比如 array = [4,6]
array[low] = 4 ;array[mid] = 4 ; array[high] = 6 ;
如果high = mid - 1，就會產生錯誤， 因此high = mid
但情形(1)中low = mid + 1就不會錯誤
public int minNumberInRotateArray(int [] array) {
if(array.length==0)
return 0;
int low=0;int high=array.length-1;
while(low<high){
int mid=low+(high-low)/2;
if(array[mid]>array[high]){
low=mid+1;
}else if(array[mid]==array[high]){
high=high-1;
}else{
high=mid;
}
}
return array[low];
}
7.斐波那契數列
大家都知道斐波那契數列，現在要求輸入一個整數n，請你輸出斐波那契數列的第n項。
n<=39
public int Fibonacci(int n) {
if(n==1)
return 1;
if(n==2)
return 1;
if(n>2)
return Fibonacci(n-1)+Fibonacci(n-2);
return 0;
}
8.跳臺階
一只青蛙一次可以跳上1級臺階，也可以跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
兩種跳法，1階或者2階，那么
假定第一次跳的是一階，那么剩下的是n-1個臺階，跳法是f(n-1);
假定第一次跳的是2階，那么剩下的是n-2個臺階，跳法是f(n-2).
可以得出總跳法為: f(n) = f(n-1) + f(n-2) 。通過實際的情況可以得出：一階f(1) = 1 ,兩階f(2) = 2。得出的是一個斐波那契數列：
| 1, (n=1)
f(n) = | 2, (n=2)
| f(n-1)+f(n-2) ,(n>2,n為整數)
// 2 ---> 11,2 2
// 3 ---> 12,21,111 3
// 4 ---> 112,121,211,1111,22
// 5 ---> 1112,1121,1211,2111,221,122,212,11111 8
if(target<=0)
return -1;
if(target==1)
return 1;
if(target==2)
return 2;
return JumpFloor(target-1)+JumpFloor(target-2);
public int JumpFloor2(int target) {
if(target==1)
return 1;
if(target==2)
return 2;
int first=1,second=2,third=0;
for(int i=3;i<=target;i++){
third=first+second;
first=second;
second=third;
}
return third;
}
9.變態跳臺階
一只青蛙一次可以跳上1級臺階，也可以跳上2級……它也可以跳上n級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
關于本題，前提是n個臺階會有一次n階的跳法。分析如下:
f(1) = 1
f(2) = f(2-1) + f(2-2) //f(2-2) 表示2階一次跳2階的次數。
f(3) = f(3-1) + f(3-2) + f(3-3)
...
f(n) = f(n-1) + f(n-2) + f(n-3) + ... + f(n-(n-1)) + f(n-n)
1.這里的f(n) 代表的是n個臺階有一次1,2,...n階的 跳法數。
2.n = 1時，只有1種跳法，f(1) = 1
3. n = 2時，會有兩個跳得方式，一次1階或者2階，這回歸到了問題（1），f(2) = f(2-1) + f(2-2)
4.n = 3時，會有三種跳得方式，1階、2階、3階，那么就是第一次跳出1階后面剩下：f(3-1);第一次跳出2階，剩下f(3-2)；第一次3階，那么剩下f(3-3)
因此結論是f(3) = f(3-1)+f(3-2)+f(3-3)
5. n = n時，會有n中跳的方式，1階、2階...n階，得出結論：
f(n) = f(n-1)+f(n-2)+...+f(n-(n-1)) + f(n-n) => f(0) + f(1) + f(2) + f(3) + ... + f(n-1)
6. 由以上已經是一種結論，但是為了簡單，我們可以繼續簡化：
f(n-1) = f(0) + f(1)+f(2)+f(3) + ... + f((n-1)-1) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2)
f(n) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2) + f(n-1) = f(n-1) + f(n-1)
可以得出：
f(n) = 2*f(n-1)
7. 得出最終結論,在n階臺階，一次有1、2、...n階的跳的方式時，總得跳法為：
| 1 ,(n=0 )
f(n) = | 1 ,(n=1 )
| 2*f(n-1),(n>=2)
public int JumpFloorII(int target) {
/*
* 1 -- >1 1
* 2 --> 11,2 2
* 3 -->12,21,111,3 4
* 4 -->1111,121,112,211,22,13,31,4 8
*/
if(target<=0){
return -1;
}else if(target==1){
return 1;
}else {
return 2*JumpFloorII(target-1);
}
}
10.矩形覆蓋
我們可以用2*1的小矩形橫著或者豎著去覆蓋更大的矩形。請問用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形，總共有多少種方法？
斐波那契數列
2*n的大矩形，和n個2*1的小矩形
其中target*2為大矩陣的大小
有以下幾種情形：
1.target <= 0 大矩形為<= 2*0,直接return 1；
2.target = 1大矩形為2*1，只有一種擺放方法，return1；
3.target = 2 大矩形為2*2，有兩種擺放方法，return2；
4.target = n 分為兩步考慮：
第一次擺放一塊 2 *1 的小矩陣，則擺放方法總共為f(target - 1)
第一次擺放一塊12的小矩陣，則擺放方法總共為f(target-2)
因為，擺放了一塊12的小矩陣（用√√表示），對應下方的1*2（用××表示）擺放方法就確定了，所以為f(targte-2)
public int RectCover(int target){
if(target<1)
return 0;
if(target*2==2)
return 1;
if(target*2==4)
return 2;
return RectCover(target-1)+RectCover(target-2);
}
