代码随想录Day 17

110.平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

单层递归的逻辑：如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？

分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。如果左子树或者右子树的高度已经返回-1，说明子树已经不是二叉平衡树了，那么直接返回-1.

递归法（后序遍历）

class Solution {
    public boolean isBalanced(TreeNode root) {
        if(balance(root) == -1){
            return false;
        }
        return true;

    }

    public int balance(TreeNode node){
        if(node == null){
            return 0;
        } 
        int leftHeight = balance(node.left);  //左
        if(leftHeight == -1){
            return -1;
        } 
        int rightHeight = balance(node.right);  //右
        if(rightHeight == -1){
            return -1; 
        } 
        if(Math.abs(rightHeight - leftHeight) > 1){ //中
            return -1;
        } 
        return Math.max(leftHeight,rightHeight) + 1;
    }
}

257. 二叉树的所有路径

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

递归法（前序遍历）

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> result = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        traversal(root, path, result);
        return result;
    }

    public void  traversal(TreeNode node, List<Integer> path, List<String> result){
        path.add(node.val); //中

        if(node.left == null && node.right == null){
            //左右孩子皆为空，说明到了叶子节点，就将这条路径记录到result集合里
            StringBuilder sb = new StringBuilder();
            for(int i = 0; i < path.size() - 1; i++){
                sb.append(path.get(i)).append("->");
            }
            sb.append(path.get(path.size() - 1));
            result.add(sb.toString()); //收集一个路径
        }
         // 递归和回溯是同时进行，所以要放在同一个花括号里
        if(node.left != null){ //左
            traversal(node.left, path, result);
            path.remove(path.size() - 1); //回溯
        }

        if(node.right != null){ //右
            traversal(node.right, path, result);
            path.remove(path.size() - 1); //回溯
        }
    }
}

迭代法（前序遍历）

非递归的方式，可以使用前序遍历的迭代方式来模拟遍历路径的过程。

一个栈保存遍历节点，另一个栈保存对应的遍历路径。Java中可以直接定义一个成员变量为object的栈Stack<Object> stack = new Stack<>();，那么只需要一个栈就可以。

代码如下：

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> result = new ArrayList<>(); //存放最终结果
        Stack<Object> stack = new Stack<>();
        if(root == null) return result;
        // 节点和路径同时入栈
        stack.push(root);
        stack.push(root.val + "");
        while(!stack.isEmpty()){
         	// 节点和路径同时出栈
            String path = (String) stack.pop();
            TreeNode node = (TreeNode) stack.pop();
            // 若找到叶子节点
            if(node.left == null && node.right == null){
                result.add(path);
            }

            if(node.right != null){ //右
                stack.push(node.right);
                stack.push(path + "->" + node.right.val);
            }

            if(node.left != null){ //左
                stack.push(node.left);
                stack.push(path + "->" + node.left.val);
            }

        }
        return result;
    }
}

404. 左叶子之和

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

左叶子的定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点。

求左叶子之和，我们不能判断本节点是不是左叶子节点，需要通过节点的父节点来判断其左孩子是不是左叶子了。

递归法（后序遍历）

递归法求解代码如下：

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if(root == null) return 0;
        int leftSum = sumOfLeftLeaves(root.left);
        if(root.left != null && root.left.left == null && root.left.right == null ){
            leftSum = root.left.val;
        }
        int rightSum = sumOfLeftLeaves(root.right);
        return leftSum + rightSum;
    }
}

迭代法（层序遍历）

本题迭代法使用前中后序列遍历都可以，层序遍历也可以，只需要在处理每个节点的时候判断就可以。

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if(root == null) return 0;
        Deque<TreeNode> deque = new LinkedList<>();
        int sum = 0;
        deque.offer(root);
        while(!deque.isEmpty()){
            int len = deque.size();
            while(len > 0){
                TreeNode node = deque.poll();
                if(node.left != null){ //左节点不为空
                    if(node.left.left == null && node.left.right == null){ //左叶子节点
                        sum += node.left.val; //统计值
                    }
                    deque.offer(node.left);
                }
                if(node.right != null){
                    deque.offer(node.right);
                }
                len--;
            }
        }
        return sum;
    }
}