2022.03.16 力扣257，404，513

follow：代码随想录

解析：
本道题使用回溯的思想：即当遇到了一个左叶节点时，证明该条路走通，但是仍需再次回到该左叶节点的父节点，遍历右节点；这里就用到了回溯的思想，每遇到了一个节点，先遍历左节点，再回到该节点，再遍历右节点。

解答：

class Solution {
    //用于保存最终的结果集
    List res = new ArrayList<>();
    //用于保存当前遍历的路线
    List path = new ArrayList();
    public List binaryTreePaths(TreeNode root) {
        if(root == null) return res;
        traversal(root);
        return res;
    }
    
    public void traversal(TreeNode node){
        //遍历到根节点，该路径结束
        if(node.left == null && node.right == null){
            String newPath = "";
            for(int i : path){
                newPath = newPath + i + "->";
            }
            newPath += node.val;
            res.add(newPath);
        }
        //前序遍历：先添加中间节点
        path.add(node.val);
        //添加左节点，左节点进行递归
        if(node.left != null){
            traversal(node.left);
            //进行回溯
            path.remove(path.size() - 1);
        }
        //加入右节点
        if(node.right != null){
            traversal(node.right);
            //进行回溯
            path.remove(path.size() - 1);
        }
    }
}

迭代法：

class Solution {
    public List binaryTreePaths(TreeNode root) {
        //迭代法 
        List res = new ArrayList<>();
        //用于保存节点
        Deque nodeQueue = new linkedList<>();
        //用于保存路径,路径与节点是一一对应的
        Deque pathQueue = new linkedList<>();
        nodeQueue.offerFirst(root);
        pathQueue.offerFirst(Integer.toString(root.val));
        while(!nodeQueue.isEmpty()){
            TreeNode node = nodeQueue.removeFirst();
            String path = pathQueue.removeFirst();
            if(node.left == null && node.right == null){
                res.add(path);
                continue;
            }
            //前序遍历，先左后右
            if(node.right != null){
                nodeQueue.offerFirst(node.right);
                pathQueue.offerFirst(path + "->" + node.right.val);
            }
            if(node.left != null){
                nodeQueue.offerFirst(node.left);
                pathQueue.offerFirst(path + "->" + node.left.val);
            }
        }
        return res;
    }
}

题目描述：
给定二叉树的根节点 root ，返回所有左叶子之和。

输出：18 = 9 + 3 + 5 + 1
解答：
迭代法：

 public int sumOfLeftLeaves(TreeNode root) {
        Deque queue = new linkedList<>();
        if(root != null) queue.offerLast(root);
        int sum = 0;
        while(!queue.isEmpty()){
            TreeNode node = queue.removeFirst();
            if(node.left != null){
                if(node.left.left == null && node.left.right == null) sum += node.left.val;
                queue.offerLast(node.left);
            }
            if(node.right != null) queue.offerLast(node.right);
        }
        return sum;
    }

递归法：

class Solution {
    int sum = 0;
    public int sumOfLeftLeaves(TreeNode root) {
        if(root == null) return sum;
        sumOfSubTree(root,false);
        return sum;
    }

    public void sumOfSubTree(TreeNode node, boolean flag){
        if(node.left == null && node.right == null && flag == true){
            sum += node.val;
        }
        if(node.left != null){
            sumOfSubTree(node.left, true);
        } 
        if(node.right != null){
            sumOfSubTree(node.right, false);
        }
    }
}

题目描述：
给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。
解答：

public int findBottomLeftValue(TreeNode root) {
        Deque queue = new linkedList<>();
        queue.offerLast(root);
        TreeNode temp = null;
        while(!queue.isEmpty()){
            int len = queue.size();
            temp = queue.peekFirst();
            while(len > 0){
               TreeNode node = queue.removeFirst();
               if(node.left != null) queue.offerLast(node.left);
               if(node.right != null) queue.offerLast(node.right);
               len--;
            }
        }
        return temp.val;
    }