算法题解之二叉树与分治法

Different Ways to Add Parentheses

加括号的不同方式

思路：分治地求出一个运算符的左边部分和右边部分的结果，将它们两两组合运算。优化的方式是用一个hash表记录所有字串的中间结果，避免重复计算。

public class Solution {
    Map<String, List<Integer>> map = new HashMap<String, List<Integer>>();
    public List<Integer> diffWaysToCompute(String input) {
        if (map.containsKey(input)) {
            return map.get(input);
        }
        
        List<Integer> res = new ArrayList<Integer>();
        if (!(input.contains("+") || input.contains("-") || input.contains("*"))) {
            res.add(Integer.parseInt(input));
            map.put(input, res);
            return res;
        }
        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            if (c == '+' || c == '-' || c == '*') {
                String p1 = input.substring(0, i);
                String p2 = input.substring(i + 1, input.length());
                List<Integer> res1 = diffWaysToCompute(p1);
                List<Integer> res2 = diffWaysToCompute(p2);
                
                for (int n1 : res1) {
                    for (int n2 : res2) {
                        if (c == '+') {
                            res.add(n1 + n2);
                        } else if (c == '-') {
                            res.add(n1 - n2);
                        } else if (c == '*') {
                            res.add(n1 * n2);
                        }
                    }
                }
            }
        }
        map.put(input, res);
        return res;
    }
}

 

Invert Binary Tree

反转二叉树

思路1：虽然很简单但是听说homebrew的作者因为没做出这题被谷歌fuck off 了。。所以还是做下吧。。

public class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        TreeNode left = root.left;
        TreeNode right = root.right;
        root.left = invertTree(right);
        root.right = invertTree(left);
        return root;
    }
}

思路2：非递归版。用队列做bfs，把每个节点的左右儿子互换。

public class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.offer(root);
        while (!q.isEmpty()) {
            TreeNode cur = q.poll();
            TreeNode left = cur.left;
            TreeNode right = cur.right;
            cur.left = right;
            cur.right = left;
            if (left != null) {
                q.offer(left);
            }
            if (right != null) {
                q.offer(right);
            }
        }
        return root;
    }
}

Kth Smallest Element in a BST

二叉树的第k小元素

思路：熟悉二叉树中序遍历的非递归版，这道题就很好做。首先找到最小元素，一定是沿着左子树走到头，然后找次小元素，如果最小节点有右子树，则相当于找右子树的最小元素，如果没有则次小元素为最小元素的父亲。之后的k个元素都这么找。

public class Solution {
    public int kthSmallest(TreeNode root, int k) {
        Stack<TreeNode> s= new Stack<TreeNode>();
        TreeNode cur = root;
        while (cur != null) {
            s.push(cur);
            cur = cur.left;
        }
        
        cur = s.pop();
        for (int i = 2; i <= k; i++) {
            if (cur.right != null) {
                cur = cur.right;
                while (cur != null) {
                    s.push(cur);
                    cur = cur.left;
                }
            }
            cur = s.pop();
        }
        return cur.val;
    }
    
}

Lowest Common Ancestor of a Binary Search Tree

二叉查找树的最近公共祖先

思路：与二叉树LCA一样，都是讨论两个节点都在左子树，都在右子树，分别在两边这三种情况。

public class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || p == null || q == 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;
        
    }
}