寫在前面：上午看了星爺的新喜劇之王，由於之前感覺評分不高導致並沒有上映就看的！看完覺得真的沒有感到有多差，起碼我是這樣認爲的！
- 輸入一棵二叉樹，判斷該二叉樹是否是平衡二叉樹
package tree;
import java.util.HashMap;
/**
* Create by IDEA
* User: zhangqi
* Date: 2019/3/28
* Desc: 輸入一棵二叉樹，判斷該二叉樹是否是平衡二叉樹
*/
public class BalanceTree {
/**
* 思路a：寫一個方法遞歸遍歷二叉樹左右結點的深度，並判斷深度差 如果大於1則不是平衡二叉樹
* @param root
* @return
*/
public boolean IsBalanced(TreeNode root) {
HashMap<Integer, Boolean> map = new HashMap<>();
map.put(1, true);
depth(root, map);
return map.get(1);
}
public int depth(TreeNode root, HashMap<Integer,Boolean> map){
if (root == null) return 0;
int left = depth(root.left,map);
int right = depth(root.right,map);
if(left-right>1 || right-left>1) map.put(1,false);
return Math.max(left, right) + 1;
}
}
- 輸入一棵二叉樹，求該樹的深度
package tree;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
/**
* Create by IDEA
* User: zhangqi
* Date: 2019/3/27
* Desc: 輸入一棵二叉樹，求該樹的深度
*/
public class TreeDepth {
/**
* 思路a：對二叉樹進行層序遍歷得出樹的深度
*
* @param root
* @return
*/
public int treeDepth(TreeNode root) {
HashMap<Integer, Boolean> map = new HashMap<>();
map.put(1, true);
if (root == null) return 0;
Queue<TreeNode> queue = new LinkedList<>();
int deep = 0;
int cur, width;
queue.offer(root);
while (!queue.isEmpty()) {
width = queue.size();
cur = 0;
while (cur < width) {
TreeNode node = queue.poll();
if (node.left != null) queue.offer(node.left);
if (node.right != null) queue.offer(node.right);
cur++;
}
deep++;
}
return deep;
}
/**
* 思路b：遞歸版本，不看答案很難想的出來
* @param root
* @return
*/
public int treeDepth2(TreeNode root) {
if (root == null) return 0;
int left = treeDepth2(root.left);
int right = treeDepth2(root.right);
return Math.max(left, right) + 1;
}
}
- 輸入一棵二叉搜索樹，將該二叉搜索樹轉換成一個排序的雙向鏈表。要求不能創建任何新的結點，只能調整樹中結點指針的指向
package tree;
import java.util.Stack;
/**
* Create by IDEA
* User: zhangqi
* Date: 2019/3/28
* Desc: 輸入一棵二叉搜索樹，將該二叉搜索樹轉換成一個排序的雙向鏈表。要求不能創建任何新的結點，只能調整樹中結點指針的指向。
*/
public class TreeToList {
/**
* 思路a：二叉搜索樹也就是二叉查找樹，左子樹小於右子樹，要求排序所以選擇中序遍歷
*
* @param root
* @return
*/
public TreeNode treeToList(TreeNode root) {
if (root == null) return null;
Stack<TreeNode> stack = new Stack<>();
TreeNode p = root;
TreeNode pre = null; //保存上一結點
boolean isFirst = true;
while (p != null || !stack.isEmpty()) {
while (p != null) {
stack.push(p);
p = p.left;
}
p = stack.pop();
if (isFirst) {
root = p; //將起點賦予中序遍歷的第一個
pre = p;
isFirst = false;
} else {
pre.right = p;
p.left = pre;
pre = p;
}
p = p.right;
}
return root;
}
/**
* 遞歸功法果真天下無敵，現階段我自認無法hold
* <p>
* 1.將左子樹構造成雙鏈表，並返回鏈表頭節點;
* 2.新增一個全局變量記錄左子樹的最後一個節點;
* 3.如果左子樹鏈表不爲空的話，將當前root追加到左子樹鏈表;
* 4.將右子樹構造成雙鏈表，並返回鏈表頭節點;
* 5.如果右子樹鏈表不爲空的話，將該鏈表追加到root節點之後;
* 6.根據左子樹鏈表是否爲空確定返回的節點。
*/
// 記錄子樹鏈表的最後一個節點，終結點只可能爲只含左子樹的非葉節點與葉節點
protected TreeNode leftLast = null;
public TreeNode Convert(TreeNode root) {
if (root == null)
return null;
if (root.left == null && root.right == null) {
leftLast = root;// 最後的一個節點可能爲最右側的葉節點
return root;
}
// 1.將左子樹構造成雙鏈表，並返回鏈表頭節點
TreeNode left = Convert(root.left);
// 3.如果左子樹鏈表不爲空的話，將當前root追加到左子樹鏈表
if (left != null) {
leftLast.right = root;
root.left = leftLast;
}
leftLast = root;// 當根節點只含左子樹時，則該根節點爲最後一個節點
// 4.將右子樹構造成雙鏈表，並返回鏈表頭節點
TreeNode right = Convert(root.right);
// 5.如果右子樹鏈表不爲空的話，將該鏈表追加到root節點之後
if (right != null) {
right.left = root;
root.right = right;
}
return left != null ? left : root;
}
}
- 從上往下打印出二叉樹的每個節點，同層節點從左至右打印
package tree;
import java.util.ArrayList;
/**
* Create by IDEA
* User: zhangqi
* Date: 2019/3/31
* Desc: 從上往下打印出二叉樹的每個節點，同層節點從左至右打印
*/
public class LevelOrderTree {
/**
* 思路a：利用隊列先進先出的特性
* @param root
* @return
*/
public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
ArrayList<Integer> list = new ArrayList<>();
ArrayList<TreeNode> queue = new ArrayList<>();
if (root == null) {
return list;
}
queue.add(root);
while (queue.size() != 0) {
TreeNode tree = queue.remove(0);
if (tree.left != null) {
queue.add(tree.left);
}
if (tree.right != null) {
queue.add(tree.right);
}
list.add(tree.val);
}
return list;
}
}
- 輸入一個整數數組，判斷該數組是不是某二叉搜索樹的後序遍歷的結果。如果是則輸出Yes,否則輸出No。假設輸入的數組的任意兩個數字都互不相同
package tree;
/**
* Create by IDEA
* User: zhangqi
* Date: 2019/3/31
* Desc: 輸入一個整數數組，判斷該數組是不是某二叉搜索樹的後序遍歷的結果。
* 如果是則輸出Yes,否則輸出No。假設輸入的數組的任意兩個數字都互不相同
*/
public class LastOrderTree {
public class Solution {
/**
* 思路a：後序遍歷左右根，遞歸比值大小
* @param s
* @return
*/
public boolean VerifySquenceOfBST(int[] s) {
if (s.length == 0) return false;
if (s.length == 1) return true;
return serch(s, 0, s.length - 1);
}
public boolean serch(int[] s, int start, int root) {
if (start >= root) return true;
int i = root;
while (i > start && s[i - 1] > s[root]) i--;
for (int j = start; j < i - 1; j++) {
if (s[j] > s[root]) return false;
}
return serch(s, start, i - 1) && serch(s, i, root - 1);
}
}
}
- 請實現一個函數，用來判斷一顆二叉樹是不是對稱的。注意，如果一個二叉樹同此二叉樹的鏡像是同樣的，定義其爲對稱的
package tree;
/**
* Create by IDEA
* User: zhangqi
* Date: 2019/3/31
* Desc: 請實現一個函數，用來判斷一顆二叉樹是不是對稱的。注意，如果一個二叉樹同此二叉樹的鏡像是同樣的，定義其爲對稱的
*/
public class SymmetryTree {
/**
* 思路a：還是遞歸，只能多練習多思考了
* @param root
* @return
*/
boolean isSymmetrical(TreeNode root) {
if (root == null) return true;
return s(root.left, root.right);
}
boolean s(TreeNode left, TreeNode right) {
if (left == null) return right == null;
if (right == null) return false;
if (left.val != right.val) return false;
return s(left.right, right.left) && s(left.left, right.right);
}
}
