- 07. 重建二叉树
- 26. 树的子结构
- 27. 二叉树的镜像
- 32 - I. 从上到下打印二叉树
- Offer 34. 二叉树中和为某一值的路径
- 55 - I. 二叉树的深度
- 55 - II. 平衡二叉树
- 32 - II. 从上到下打印二叉树 II
- 32 - III. 从上到下打印二叉树 III
- 37. 序列化二叉树
- 28. 对称的二叉树
- 33. 二叉搜索树的后序遍历序列
- 36. 二叉搜索树与双向链表
class Solution {
public TreeNode buildTree(int[] preorder, int[] inorder) {
int n = preorder.length;
if (n == 0) {
return null;
}
int rootVal = preorder[0], rootIndex = 0;
for (int i = 0; i < n; i++) {
if (inorder[i] == rootVal) {
rootIndex = i;
break;
}
}
TreeNode root = new TreeNode(rootVal);
root.left = buildTree(Arrays.copyOfRange(preorder, 1, 1 + rootIndex),
Arrays.copyOfRange(inorder, 0, rootIndex));
root.right = buildTree(Arrays.copyOfRange(preorder, 1 + rootIndex, n),
Arrays.copyOfRange(inorder, rootIndex + 1, n));
return root;
}
}class Solution {
public TreeNode buildTree(int[] preorder, int[] inorder) {
if (preorder == null || preorder.length == 0) {
return null;
}
TreeNode root = new TreeNode(preorder[0]);
int length = preorder.length;
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
int inorderIndex = 0;
for (int i = 1; i < length; i++) {
int preorderVal = preorder[i];
TreeNode node = stack.peek();
if (node.val != inorder[inorderIndex]) {
node.left = new TreeNode(preorderVal);
stack.push(node.left);
} else {
while (!stack.isEmpty() && stack.peek().val == inorder[inorderIndex]) {
node = stack.pop();
inorderIndex++;
}
node.right = new TreeNode(preorderVal);
stack.push(node.right);
}
}
return root;
}
}class Solution {
public boolean isSubStructure(TreeNode A, TreeNode B) {
if (A == null || B == null) {
return false;
}
return isEquals(A, B) || isSubStructure(A.left, B) || isSubStructure(A.right, B);
}
private boolean isEquals(TreeNode nodeA, TreeNode nodeB) {
if (nodeB == null) {
return true;
}
if (nodeA == null || nodeA.val != nodeB.val) {
return false;
}
return isEquals(nodeA.left, nodeB.left) && isEquals(nodeA.right, nodeB.right);
}
}class Solution {
public TreeNode mirrorTree(TreeNode root) {
if (root == null) {
return null;
}
TreeNode rootLeft = mirrorTree(root.right);
TreeNode rootRight = mirrorTree(root.left);
root.left = rootLeft;
root.right = rootRight;
return root;
}
}class Solution {
public TreeNode mirrorTree(TreeNode root) {
if (root == null) {
return null;
}
Stack<TreeNode> stack = new Stack<>();
stack.add(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
if (node.left != null) {
stack.add(node.left);
}
if (node.right != null) {
stack.add(node.right);
}
TreeNode temp = node.left;
node.left = node.right;
node.right = temp;
}
return root;
}
}class Solution {
public int[] levelOrder(TreeNode root) {
if (root == null) {
return new int[0];
}
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
List<Integer> list = new ArrayList<>();
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
list.add(node.val);
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
}
int[] result = new int[list.size()];
int index = 0;
for (int i : list) {
result[index++] = i;
}
return result;
}
}class Solution {
List<List<Integer>> result = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> pathSum(TreeNode root, int sum) {
path(root, sum);
return result;
}
private void path(TreeNode root, int sum) {
if (root == null) {
return;
}
path.add(root.val);
int target = sum - root.val;
if (target == 0 && root.left == null && root.right == null) {
result.add(new ArrayList(path));
}
path(root.left, target);
path(root.right, target);
path.remove(path.size() - 1);
}
}class Solution {
public int maxDepth(TreeNode root) {
if (root == null) {
return 0;
}
return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}
}class Solution {
public int maxDepth(TreeNode root) {
if (root == null) {
return 0;
}
int result = 0;
Deque<TreeNode> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
result++;
int n = queue.size();
for (int i = 0; i < n; i++) {
TreeNode node = queue.poll();
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
}
}
return result;
}
}class Solution {
public boolean isBalanced(TreeNode root) {
if (root == null) {
return true;
}
Deque<TreeNode> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
int offset = Math.abs(maxDepth(node.left) - maxDepth(node.right));
if (offset > 1) {
return false;
}
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
}
return true;
}
private int maxDepth(TreeNode root) {
if (root == null) {
return 0;
}
return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}
}class Solution {
public boolean isBalanced(TreeNode root) {
if (root == null) {
return true;
}
return Math.abs(maxDepth(root.left) - maxDepth(root.right)) <= 1 && isBalanced(root.left) && isBalanced(
root.right);
}
private int maxDepth(TreeNode root) {
if (root == null) {
return 0;
}
return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}
}class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<>();
if (root == null) {
return result;
}
Deque<TreeNode> deque = new LinkedList<>();
deque.add(root);
while (!deque.isEmpty()) {
int l = deque.size();
List<Integer> list = new ArrayList<>();
for (int i = 0; i < l; i++) {
TreeNode node = deque.poll();
list.add(node.val);
if (node.left != null) {
deque.add(node.left);
}
if (node.right != null) {
deque.add(node.right);
}
}
result.add(list);
}
return result;
}
}class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> res = new ArrayList<>();
if (root == null) {
return res;
}
Deque<TreeNode> deque = new LinkedList<>();
deque.add(root);
while (!deque.isEmpty()) {
int l = deque.size();
List<Integer> list = new ArrayList<>(l);
for (int i = 0; i < l; i++) {
TreeNode node = deque.poll();
list.add(node.val);
if (node.left != null) {
deque.add(node.left);
}
if (node.right != null) {
deque.add(node.right);
}
}
if (res.size() % 2 == 1) {
Collections.reverse(list);
}
res.add(list);
}
return res;
}
}public class Codec {
// Encodes a tree to a single string.
public String serialize(TreeNode root) {
if (root == null) {
return "[]";
}
Deque<TreeNode> deque = new LinkedList<>();
deque.add(root);
StringBuilder builder = new StringBuilder("[");
while (!deque.isEmpty()) {
TreeNode node = deque.poll();
if (node != null) {
builder.append(node.val).append(",");
deque.add(node.left);
deque.add(node.right);
} else {
builder.append("null,");
}
}
builder.deleteCharAt(builder.length() - 1);
builder.append("]");
return builder.toString();
}
// Decodes your encoded data to tree.
public TreeNode deserialize(String data) {
if ("[]".equals(data)) {
return null;
}
String[] vals = data.substring(1, data.length() - 1).split(",");
TreeNode root = new TreeNode(Integer.parseInt(vals[0]));
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
int i = 1;
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
if (!vals[i].equals("null")) {
node.left = new TreeNode(Integer.parseInt(vals[i]));
queue.add(node.left);
}
i++;
if (!vals[i].equals("null")) {
node.right = new TreeNode(Integer.parseInt(vals[i]));
queue.add(node.right);
}
i++;
}
return root;
}
}class Solution {
public boolean isSymmetric(TreeNode root) {
if (root == null) {
return true;
}
return helper(root.left, root.right);
}
private boolean helper(TreeNode root1, TreeNode root2) {
if (root1 == null && root2 == null) {
return true;
}
if (root1 == null || root2 == null) {
return false;
}
if (root1.val != root2.val) {
return false;
}
return helper(root1.left, root2.right) && helper(root1.right, root2.left);
}
}class Solution {
public boolean isSymmetric(TreeNode root) {
if (root == null) {
return true;
}
Deque<TreeNode> queue = new LinkedList<>();
queue.addFirst(root.left);
queue.addLast(root.right);
while (!queue.isEmpty()) {
TreeNode first = queue.removeFirst();
TreeNode last = queue.removeLast();
if (first == null && last == null) {
continue;
}
if (first == null || last == null) {
return false;
}
if (first.val != last.val) {
return false;
}
queue.addFirst(first.right);
queue.addFirst(first.left);
queue.addLast(last.left);
queue.addLast(last.right);
}
return true;
}
}class Solution {
public boolean verifyPostorder(int[] postorder) {
return helper(postorder, 0, postorder.length - 1);
}
private boolean helper(int[] order, int i, int j) {
if (i >= j) {
return true;
}
int p = i;
while (order[p] < order[j]) {
p++;
}
int m = p;
while (order[p] > order[j]) {
p++;
}
return p == j && helper(order, i, m - 1) && helper(order, m, j - 1);
}
}class Solution {
public Node treeToDoublyList(Node root) {
if (root == null) {
return root;
}
List<Node> list = new ArrayList<>();
helper(list, root);
Node head = list.get(0);
Node pre = head;
for (int i = 1; i < list.size(); i++) {
Node node = list.get(i);
pre.right = node;
node.left = pre;
pre = pre.right;
}
pre.right = head;
head.left = pre;
return head;
}
private void helper(List<Node> list, Node root) {
if (root == null) {
return;
}
if (root.left != null) {
helper(list, root.left);
}
list.add(root);
if (root.right != null) {
helper(list, root.right);
}
}
}class Solution {
List<Integer> list = new ArrayList<>();
public int kthLargest(TreeNode root, int k) {
helper(root);
return list.get(list.size() - k);
}
private void helper(TreeNode root) {
if (root == null) {
return;
}
helper(root.left);
list.add(root.val);
helper(root.right);
}
}class Solution {
int result = 0, count = 1;
public int kthLargest(TreeNode root, int k) {
helper(root, k);
return result;
}
private void helper(TreeNode root, int k) {
if (root == null) {
return;
}
helper(root.right, k);
if (count++ == k) {
result = root.val;
return;
}
helper(root.left, k);
}
}class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == null) {
return null;
}
while (root != null) {
if (p.val < root.val && q.val < root.val) {
root = root.left;
} else if (p.val > root.val && q.val > root.val) {
root = root.right;
} else {
break;
}
}
return root;
}
}class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == null) {
return null;
}
if (p.val < root.val && q.val < root.val) {
return lowestCommonAncestor(root.left, p, q);
}
if (p.val > root.val && q.val > root.val) {
return lowestCommonAncestor(root.right, p, q);
}
return root;
}
}class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if(root == null || root == p || root == q) return root;
TreeNode left = lowestCommonAncestor(root.left, p, q);
TreeNode right = lowestCommonAncestor(root.right, p, q);
if(left == null && right == null) return null; // 1.
if(left == null) return right; // 3.
if(right == null) return left; // 4.
return root; // 2. if(left != null and right != null)
}
}