【LeetCode】257. Binary Tree Paths 解题报告

---

转载请注明出处：http://blog.csdn.net/crazy1235/article/details/51474128

---

Subject

出处：https://leetcode.com/problems/binary-tree-paths/

Given a binary tree, return all root-to-leaf paths.

For example, given the following binary tree:

   1
 /   \
2     3
 \
  5
All root-to-leaf paths are:

["1->2->5", "1->3"]

---

Explain

该题目是求一颗二叉树的所有路径（从根结点到每个叶子结点）。

返回所有路径组成的List集合。

---

Solution

solution 1

最容易想到的方法就是递归。
深度优先遍历 — DFS。

public List<String> resultList = new ArrayList<String>();

    /**
     * 递归方式
     * 
     * <br />
     * 
     * Run Time : 4ms
     * 
     * @param root
     * @return
     */
    public List<String> binaryTreePaths(TreeNode root) {
        if (root == null) {
            return resultList;
        }
        List<String> singleResult = new ArrayList<>();

        getTreePath(root, singleResult);
        return resultList;
    }

    /**
     * DFS
     * 
     * @param resultList
     * @param node
     * @param singleResult
     */
    private void getTreePath(TreeNode node, List<String> singleResult) {
        singleResult.add(node.val + "");
        if (node.left == null && node.right == null) {
            resultList.add(getPath(singleResult));
        }
        if (node.left != null) {
            getTreePath(node.left, new ArrayList<>(singleResult));
        }
        if (node.right != null) {
            getTreePath(node.right, new ArrayList<>(singleResult));
        }
    }

恩，这是最容易想到的方法。

我还想到了用栈来解决，但是没写出来，囧~~~

---

solution 2

方法二，与方法一类似。

参考 : https://leetcode.com/discuss/85025/sharing-my-recursive-java-solution

public List<String> binaryTreePaths2(TreeNode root) {
        if (root == null) {
            return resultList;
        }
        findPaths(root, root.val + "");
        return resultList;
    }

    private void findPaths(TreeNode node, String path) {
        if (node.left == null && node.right == null) {
            resultList.add(path);
        }
        if (node.left != null) {
            findPaths(node.left, path + "->" + node.left.val);
        }
        if (node.right != null) {
            findPaths(node.right, path + "->" + node.right.val);
        }
    }

也是通过递归解决。

不过单条路径不需要通过一个List集合来存储，直接通过字符串构造出来。

---

solution 3

在方法二的基础上，将String改为StringBuilder效率更高一些。

该方法利用了StringBuilder类的setLength()方法。

so clever ~

public List<String> binaryTreePaths3(TreeNode root) {
        findPath(root, new StringBuilder());
        return resultList;
    }

    private void findPath(TreeNode node, StringBuilder sb) {
        if (node == null) {
            return;
        }
        int len = sb.length();
        sb.append(node.val);
        if (node.left == null && node.right == null) {
            resultList.add(sb.toString());
        } else {
            sb.append("->");
            findPath(node.left, sb);
            findPath(node.right, sb);
        }
        sb.setLength(len);// 截取 ！！！
    }

该方法在LeetCode平台上测试运行时间是2ms。

---

solution 4

通过栈的方式来做。
哈哈哈。

栈

参考 : https://leetcode.com/discuss/83013/my-java-non-recursion-solution-using-stack-and-wrapper

public List<String> binaryTreePaths4(TreeNode root) {
        if (root == null) {
            return resultList;
        }

        Stack<Wrapper> stack = new Stack<>();
        stack.add(new Wrapper(root, root.val + ""));
        Wrapper wrapper = null;
        while (!stack.isEmpty()) {
            wrapper = stack.pop();
            if (wrapper.node.left == null && wrapper.node.right == null) {
                resultList.add(wrapper.path);
            }
            if (wrapper.node.left != null) {
                stack.add(new Wrapper(wrapper.node.left, wrapper.path + "->"
                        + wrapper.node.left.val));
            }
            if (wrapper.node.right != null) {
                stack.add(new Wrapper(wrapper.node.right, wrapper.path + "->"
                        + wrapper.node.right.val));
            }
        }

        return resultList;
    }

private static class Wrapper {
        TreeNode node;
        String path;

        public Wrapper() {

        }

        public Wrapper(TreeNode node) {
            this.node = node;
        }

        public Wrapper(TreeNode node, String path) {
            this.node = node;
            this.path = path;
        }
    }

需要一个类进行包装，里面存储当前结点，和访问到此结点的路径。

如果纯看代码看不懂，直接断点跟踪一下明白了。

该方法Run Time 是 5ms

---

solution 5

既然DFS可以实现，估计BFS也可以的。

恩。是可以的~~

参考 ： https://leetcode.com/discuss/67749/bfs-with-two-queue-java-solution

    /**
     * BFS
     * with two Queue
     * @param root
     * @return
     */
    public List<String> binaryTreePaths5(TreeNode root) {
        if (root == null) {
            return resultList;
        }
        Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
        Queue<String> pathQueue = new LinkedList<>();
        nodeQueue.offer(root);
        pathQueue.offer(root.val + "");
        while (!nodeQueue.isEmpty()) {
            TreeNode currNode = nodeQueue.poll();
            String item = pathQueue.poll();
            if (currNode.left == null && currNode.right == null) {
                resultList.add(item);
            }
            if (currNode.left != null) {
                nodeQueue.offer(currNode.left);
                pathQueue.offer(item + "->" + currNode.left.val);
            }
            if (currNode.right != null) {
                nodeQueue.offer(currNode.right);
                pathQueue.offer(item + "->" + currNode.right.val);
            }
        }

        return resultList;
    }

通过两个队列：
一个存储结点
一个存储访问到此节点的路径
单条路径结束的判断条件依旧是当前结点是叶子结点。

该方法Run Time 耗时是 4ms。

---

solution 6

该方法的思想依旧是递归操作。

不过不需要额外创建一个函数去递归调用。
直接递归调用提供的函数即可。

参考：https://leetcode.com/discuss/55451/clean-solution-accepted-without-helper-recursive-function

public List<String> binaryTreePaths6(TreeNode root) {
        List<String> pathsList = new ArrayList<String>();

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

        if (root.left == null && root.right == null) {
            pathsList.add(root.val + "");
            return pathsList;
        }

        for (String path : binaryTreePaths6(root.left)) {
            pathsList.add(root.val + "->" + path);
        }

        for (String path : binaryTreePaths6(root.right)) {
            pathsList.add(root.val + "->" + path);
        }

        return pathsList;
    }

yes.
该方法Run Time 是 3ms。

---

源码请移步：github.

https://github.com/crazy1235/BaseJavaProject/blob/master/BaseJavaProject/src/com/jacksen/java/leetcode/BinaryTreePaths.java

---

bingo~~