二叉树——257. 二叉树的所有路径（递归+迭代）

257. 二叉树的所有路径

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

叶子节点 是指没有子节点的节点。

 

解题之前，想先吐槽点别的，为什么这么简单一道题，我会写这么久？为什么很多题之前都写过，但是见到之后就不会写了？为什么不能沉下心去认真的干一件事情？答案只有一个，我是个废物，我压根不适合写代码，我为什么要学这个，或者说我到底会什么？24岁一事无成的废物。

解题思路：递归+迭代 

递归

就是之前的回溯，没什么好写的。只不过要知道是采用前序遍历，因为每个节点我们都要加入path路径当中。代码和提交结果如下：

 public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        List<Integer> paths = new ArrayList<>();
        traversal(root, paths, res);
        return res;
    }

    private void traversal(TreeNode root, List<Integer> paths, List<String> res) {
        paths.add(root.val);
        // 叶子结点
        if (root.left == null && root.right == null) {
            // 输出
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < paths.size() - 1; i++) {
                sb.append(paths.get(i)).append("->");
            }
            sb.append(paths.get(paths.size() - 1));
            res.add(sb.toString());
            return;
        }
        if (root.left != null) {
            traversal(root.left, paths, res);
            paths.remove(paths.size() - 1);// 回溯
        }
        if (root.right != null) {
            traversal(root.right, paths, res);
            paths.remove(paths.size() - 1);// 回溯
        }
    }

 迭代

采用前序遍历的办法，只不过需要添加另一个Stack 用来存储路径，代码和提交结果如下：

//迭代法
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList();
        Stack<TreeNode> stack = new Stack();
        Stack<String> paths = new Stack();
        if(root == null){
            return res;
        } 
        stack.push(root);
        paths.push(""+ root.val);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            String path = paths.pop();
            if(node.left == null && node.right == null){
                res.add(path);
            }
            if(node.right != null){
                stack.push(node.right);
                paths.push(path + "->"+node.right.val);
            }
            if(node.left != null){
                stack.push(node.left);
                paths.push(path + "->"+ node.left.val);
            }
        }
        return res;
    }

总结：这个题迭代法的效率是要明显低于递归的，但是我为啥要学迭代呢？我也不知道，凑活看吧