Leetcode刷题系列（四）Binary Tree相关

Binary Tree的遍历

Binary Tree的遍历思想

　　Binary Tree的遍历一般有前序、中序、后序和层序遍历：

• 前序遍历：根->左子树->右子树
• 中序遍历：左子树->根->右子树
• 后序遍历：左子树->右子树->根

• 层序遍历：按层数来

  　　具体遍历就不行进举例了。

Binary Tree的遍历－使用递归

　　使用递归是二叉树遍历最为简单的一种方法，下面给出前序遍历的代码版本１：

public class Solution {
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        traverse(root, result);
        return result;
    }
    // 把root为跟的preorder加入result里面
    private void traverse(TreeNode root, ArrayList<Integer> result) {
        if (root == null) {
            return;
        }

        result.add(root.val);
        traverse(root.left, result);
        traverse(root.right, result);
    }
}

　　版本２（分治）：

public class Solution {
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        // null or leaf
        if (root == null) {
            return result;
        }

        // Divide
        ArrayList<Integer> left = preorderTraversal(root.left);
        ArrayList<Integer> right = preorderTraversal(root.right);

        // Conquer
        result.add(root.val);
        result.addAll(left);
        result.addAll(right);
        return result;
    }
}

　　版本２使用的是分治法，它与递归的最大不同之处在于它有返回值，这样可得到较小问题的答案来解决大问题，但是分治算法大多数情况下要比动态规划算法时间复杂度大，因为分治算法并没有记住较小问题的答案，再次使用较小问题的答案时需要重新进行计算。

　　上诉的算法可通用在中序和后序算法上，只需要将result.add的顺序按照所需遍历顺序进行改变即可。另外，层序遍历是无法使用递归实现的。
　　

Binary Tree的遍历－非递归（使用栈）

前序遍历（preorder）

　　二叉树前序遍历的非递归实现使用一个栈就可以轻松解决。先把根节点加入栈中，再把其左节点和右节点按顺序入栈，出栈的顺序即为遍历的顺序，这样就不给出代码了。

中序遍历（inorder）

　　中序遍历思想也较为简单，先去访问到最左边的节点，然后是根节点，借着转向右节点然后重复刚才的操作，关键代码：

    while (curt != null || !stack.empty()) {
        while (curt != null) {
            stack.add(curt);
            curt = curt.left;
        }
        curt = stack.peek();
        stack.pop();
        result.add(curt.val);
        curt = curt.right;
    }

后序遍历（postorder）

　　后序遍历也使用一个栈来解决，但是思路不及上面两种遍历简单清晰。关键代码：

while (!stack.empty()) {
    curr = stack.peek();
    if (prev == null || prev.left == curr || prev.right == curr) { 
        if (curr.left != null) {
            stack.push(curr.left);
        } else if (curr.right != null) {
            stack.push(curr.right);
        }
    } else if (curr.left == prev) { 
        if (curr.right != null) {
            stack.push(curr.right);
        }
    } else { 
        result.add(curr.val);
        stack.pop();
    }
    prev = curr;
}

　　因为后序遍历的顺序为：左子树->右子树->根，因此第一个if为访问到最左边，第二个if为左子树访问完毕需要回溯去访问右子树，第三个为右子树也访问完毕，可以访问根节点了。
　　需要注意的是节点是否为null的检查，这在任何遍历程序中都需要。

层序遍历（level order）

　　层序遍历不能使用递归来实现，但是非递归方法却很多。层序遍历按思想上来说本身就是一种广度优先搜索，因此使用广度优先搜索较为简单，可以使用一个队列或两个队列来实现，一个队列则与先序遍历相似，逐个添加然后按顺序出队列，两个队列的实现主要思想是一个装着之前的节点，另一个队列用来装新访问的节点（新一层）。这里给出使用一个队列的代码：

public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
    ArrayList result = new ArrayList();

    if (root == null) {
        return result;
    }

    Queue<TreeNode> queue = new LinkedList<TreeNode>();
    queue.offer(root);

    while (!queue.isEmpty()) {
        ArrayList<Integer> level = new ArrayList<Integer>();
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            TreeNode head = queue.poll();
            level.add(head.val);
            if (head.left != null) {
                queue.offer(head.left);
            }
            if (head.right != null) {
                queue.offer(head.right);
            }
        }
        result.add(level);
    }

    return result;
}

　　除了使用BFS的方法，还可使用DFS的方法，但这个就较为别扭了，还需要在遍历的时候加上访问的层次信息，这里就不给出代码了。

Binary Tree的分治法

　　前面给出过前序遍历二叉树的分治解法，分治法也可以用来解决一些关于二叉树的题。

Maximum Depth of Binary Tree

　　题目为求二叉树的最大深度，使用分治法可以很简单的解决该问题：

public int maxDepth(TreeNode root) {
    if (root == null) {
        return 0;
    }

    int left = maxDepth(root.left);
    int right = maxDepth(root.right);
    return Math.max(left, right) + 1;
}

Binary Tree Maximum Path Sum

　　题目为寻找一条路径使其路径和最大，路径可以在任一节点中开始和结束（路径和为两个节点之间所在路径上的节点权值之和）。我们使用一种额外的数据类型，包含两个整数值：

• singlePath: 从root往下走到任意点的最大路径，这条路径可以不包含任何点

• maxPath: 从树中任意到任意点的最大路径，这条路径至少包含一个点

  　　代码如下，最后结果返回maxPath即可。
  　　

 private ResultType helper(TreeNode root) {
        if (root == null) {
            return new ResultType(0, Integer.MIN_VALUE);
        }
        // Divide
        ResultType left = helper(root.left);
        ResultType right = helper(root.right);
        // Conquer
        int singlePath = Math.max(left.singlePath, right.singlePath) + root.val;
        singlePath = Math.max(singlePath, 0);
        int maxPath = Math.max(left.maxPath, right.maxPath);
        maxPath = Math.max(maxPath, left.singlePath + right.singlePath + root.val);
        return new ResultType(singlePath, maxPath);
    }

Lowest Common Ancestor

　　题目为寻找两个节点最近的公共祖先节点。此题也可以使用分治法：

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode node1, TreeNode node2) {
    if (root == null || root == node1 || root == node2) {
        return root;
    }

    // Divide
    TreeNode left = lowestCommonAncestor(root.left, node1, node2);
    TreeNode right = lowestCommonAncestor(root.right, node1, node2);

    // Conquer
    if (left != null && right != null) {
        return root;
    } 
    if (left != null) {
        return left;
    }
    if (right != null) {
        return right;
    }
    return null;
}

　　 在root为根的二叉树中找A,B的LCA:

• 如果找到了就返回这个LCA
• 如果只碰到A，就返回A
• 如果只碰到B，就返回B
• 如果都没有，就返回null