力扣爆刷第141天之二叉树十连刷（翻转、对称、深度、平衡、路径）

力扣爆刷第141天之二叉树十连刷（翻转、对称、深度、平衡、路径）

一、226. 翻转二叉树

题目链接：https://leetcode.cn/problems/invert-binary-tree/description/
思路：直接前序遍历，然后在遍历的过程中交换左右子节点。

class Solution {
    public TreeNode invertTree(TreeNode root) {
        traverse(root);
        return root;
    }
    void traverse(TreeNode root) {
        if(root == null) return ;
        TreeNode t = root.left;
        root.left = root.right;
        root.right = t;
        traverse(root.left);
        traverse(root.right);
    }

}

二、101. 对称二叉树

题目链接：https://leetcode.cn/problems/symmetric-tree/description/
思路：将一个棵二叉树当做两颗二叉树来遍历，也就是在递归的函数参数中携带左右两颗子树，然后进行比较。

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return traverse(root.left, root.right);
    }

    boolean traverse(TreeNode node1, TreeNode node2) {
        if(node1 == null && node2 == null) return true;
        if(node1 == null || node2 == null) return false;
        if(node1.val != node2.val) return false;
        return traverse(node1.left, node2.right) && traverse(node1.right, node2.left);
    }
    
}

三、104. 二叉树的最大深度

题目链接：https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/
思路：后序遍历，返回左右子树的最大值即可，然后每返回一层就加1，即可得到最大深度。

class Solution {
    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;
    }
}

四、111. 二叉树的最小深度

题目链接：https://leetcode.cn/problems/minimum-depth-of-binary-tree/description/
思路：求最小深度，需要从上往下找，使用前序遍历，递归终点为叶子节点，到达叶子节点进行判断。

class Solution {
    int min = Integer.MAX_VALUE;
    public int minDepth(TreeNode root) {
        if(root == null) return 0;
        traverse(root, 1);
        return min;
    }

    void traverse(TreeNode root, int deep) {
        if(root == null) return;
        if(root.left == null && root.right == null) {
            min = Math.min(min, deep);
            return ;
        }
        traverse(root.left, deep+1);
        traverse(root.right, deep+1);
    }
}

五、222. 完全二叉树的节点个数

题目链接：https://leetcode.cn/problems/count-complete-tree-nodes/description/
思路：求完全二叉树的节点个数，思路很简单，就是利用完全二叉树的性质，可以根据深度计算个数，所以就前序遍历，每一个节点都判断是否是完全二叉树，是就不遍历了，不是再遍历。

class Solution {
    public int countNodes(TreeNode root) {
        if(root == null) return 0;
        int a = 0, b = 0;
        TreeNode p = root, q = root;
        while(p != null) {
            a++;
            p = p.left;
        }
        while(q != null) {
            b++;
            q = q.right;
        }
        if(a == b) return (int)Math.pow(2, a) - 1;
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}

六、110. 平衡二叉树

题目链接：https://leetcode.cn/problems/balanced-binary-tree/description/
思路：平衡二叉树是指左右子高度相差不超过1，所以直接按照求树的深度就可以解题，只要左右深度大于1，即不平衡。

class Solution {
    boolean flag = true;
    public boolean isBalanced(TreeNode root) {
        traverse(root);
        return flag;
    }

    int traverse(TreeNode root) {
        if(root == null) return 0;
        int left = traverse(root.left);
        int right = traverse(root.right);
        if(Math.abs(left - right) > 1) {
            flag = false;
        }
        return Math.max(left, right) + 1;
    }
}

七、257. 二叉树的所有路径

题目链接：https://leetcode.cn/problems/binary-tree-paths/description/
思路：求所有路径，这种题目在回溯中非常常见，所以本题也是在递归的过程中使用回溯，在叶子节点进行路径组装。

class Solution {
    List<String> result = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    public List<String> binaryTreePaths(TreeNode root) {
        traverse(root);
        return result;
    }
    void traverse(TreeNode root) {
        list.add(root.val);
        if(root.left == null && root.right == null) {
            StringBuilder sb = new StringBuilder();
            for(int i : list) {
                sb.append(i).append("->");
            }
            sb.delete(sb.length()-2, sb.length());
            result.add(sb.toString());
            return;
        }
        
        if(root.left != null) {
            traverse(root.left);
            list.remove(list.size()-1);
        }
        if(root.right != null) {
            traverse(root.right);
            list.remove(list.size()-1);
        }
    }
}

八、404. 左叶子之和

题目链接：https://leetcode.cn/problems/sum-of-left-leaves/description/
思路：求左叶子之和，求的是所有的左叶子的和，所以只需要做两件事情，一件是在叶子节点进行判断，另外一件是提供每个节点的信息，用于判断当前节点是否是叶子节点，这种信息需要从父节点传递，所以在递归函数的参数中。

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

    void traverse(TreeNode root, boolean flag) {
        if(root == null) return ;
        if(root.left == null && root.right == null && flag) {
            sum += root.val;
        }
        traverse(root.left, true);
        traverse(root.right, false);
    }
}

九、513. 找树左下角的值

题目链接：https://leetcode.cn/problems/find-bottom-left-tree-value/description/
思路：本题和上一题略有差异，上一题是求所有左叶子节点的和，要求的是左叶子节点，本题类似于树的左视图，但是是深度最深的哪一行的最左边的那个节点，它可能是左节点也可能是右节点。只需要前序遍历，利用深度，当深度第一次大于记录值时，说明是第一次到达下一层，而且采用的是前序遍历，到达的是下一层的最左边的叶子节点。

class Solution {
    int result = 0, max = 0;
    public int findBottomLeftValue(TreeNode root) {
        traverse(root, 1);
        return result;
    }
    void traverse(TreeNode root, int deep) {
        if(root == null) return ;
        if(root.left == null && root.right == null && deep > max) {
            max = deep;
            result = root.val;
        } 
        traverse(root.left, deep + 1);
        traverse(root.right, deep + 1);
    }
}

十、112. 路径总和

题目链接：https://leetcode.cn/problems/path-sum/description/
思路：求路径总和，类似于回溯的用法，就是在树的递归过程中使用回溯，如果是全局变量，需要手动回滚数据，如果是携带是函数参数列表则不需要。

class Solution {
    boolean flag = false;
    public boolean hasPathSum(TreeNode root, int targetSum) {
        traverse(root, targetSum, 0);
        return flag;
    }
    void traverse(TreeNode root, int targetSum, int sum) {
        if(root == null || flag) return;
        sum += root.val;
        if(root.left == null && root.right == null) {
            if(sum == targetSum) flag = true;
        }
        traverse(root.left, targetSum, sum);
        traverse(root.right, targetSum, sum);
    }
}