LeetCode 257. Binary Tree Paths

问题描述

• Given a binary tree, return all root-to-leaf paths.
• Example :
  
• 地址

问题分析

• DFS + 回溯的经典问题：
  
  • DFS + 回溯（推荐）
  • 用两个栈来模拟DFS(先序遍历)的过程，其实也可以用一个栈，只要把节点和路径包装成一个类即可。
  • 用两个队列实现BFS,虽然能过OJ，但是不能保证路径的顺序是从左至右的。因为BFS一旦到达叶子节点便计入了一条路径，而不是BFS那种从左到右的结果。

经验教训

• 掌握DFS + 回溯
• 掌握 两个栈来模拟DFS(先序遍历)的过程
• StringBuilder 的使用

代码实现

• DFS + 回溯（推荐）

    public List<String> binaryTreePaths(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<String> res = new ArrayList<>();
        StringBuilder sb = new StringBuilder();
        findPath(root, sb, res);
        return res;
    }

    public void findPath(TreeNode root, StringBuilder sb, List<String> res) {
        int length = sb.length();
        if (root.left == null && root.right == null) {
            sb.append(root.val);
            res.add(sb.toString());
        }else{
            sb.append(root.val).append("->");
            if (root.left != null) {
                findPath(root.left, sb, res);
                //加入原sb为 abc, 由于回溯的存在，dfs之后依旧是abc
            }
            if (root.right != null) {
                findPath(root.right, sb, res);
            }
        }
        //回溯
        sb.setLength(length);
    }

• 栈来模拟DFS

    public List<String> binaryTreePaths(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<String> res = new ArrayList<>();
        LinkedList<StringBuilder> pathQueue = new LinkedList<>();
        LinkedList<TreeNode> nodeQueue = new LinkedList<>();
        nodeQueue.add(root);
        pathQueue.add(new StringBuilder(""));
        while (! nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.remove();
            StringBuilder path = pathQueue.remove();
            if (node.left == null && node.right == null) {
                path.append(node.val);
                res.add(path.toString());
                continue;
            }
            if (node.left != null) {
                StringBuilder pathLeft = new StringBuilder(path);
                pathLeft.append(node.val).append("->");
                nodeQueue.add(node.left);
                pathQueue.add(pathLeft);
            }
            if (node.right != null) {
                StringBuilder pathRight = new StringBuilder(path);
                pathRight.append(node.val).append("->");
                nodeQueue.add(node.right);
                pathQueue.add(pathRight);
            }
        }
        return res;
    }

• BFS

    public List<String> binaryTreePaths(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<String> res = new ArrayList<>();
        Stack<TreeNode> nodeStack = new Stack<>();
        Stack<StringBuilder> pathStack = new Stack<>();
        nodeStack.push(root);
        pathStack.push(new StringBuilder(""));
        while (! nodeStack.isEmpty()) {
            TreeNode node = nodeStack.pop();
            StringBuilder path = pathStack.pop();
            if (node.left == null && node.right == null) {
                path.append(node.val);
                res.add(path.toString());
                continue;
            }
            if (node.right != null) {
                StringBuilder pathRight = new StringBuilder(path);
                pathRight.append(node.val).append("->");
                nodeStack.push(node.right);
                pathStack.push(pathRight);
            }
            if (node.left != null) {
                StringBuilder pathLeft = new StringBuilder(path);
                pathLeft.append(node.val).append("->");
                nodeStack.push(node.left);
                pathStack.push(pathLeft);
            }
        }
        return res;
    }