题目目录

  110.平衡二叉树

  257.二叉树的所有路径

  404.左叶子之和

解题过程

1、110.平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

思路： 后序遍历比较高度。

递归法

class Solution {
    public boolean isBalanced(TreeNode root) {
        return getHeight(root) != -1;
    }

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

迭代法

class Solution {
   /**
     * 迭代法，效率较低，计算高度时会重复遍历
     * 时间复杂度：O(n^2)
     */
    public boolean isBalanced(TreeNode root) {
        if (root == null) {
            return true;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pre = null;
        while (root!= null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            TreeNode inNode = stack.peek();
            // 右结点为null或已经遍历过
            if (inNode.right == null || inNode.right == pre) {
                // 比较左右子树的高度差，输出
                if (Math.abs(getHeight(inNode.left) - getHeight(inNode.right)) > 1) {
                    return false;
                }
                stack.pop();
                pre = inNode;
                root = null;// 当前结点下，没有要遍历的结点了
            } else {
                root = inNode.right;// 右结点还没遍历，遍历右结点
            }
        }
        return true;
    }

    /**
     * 层序遍历，求结点的高度
     */
    public int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offer(root);
        int depth = 0;
        while (!deque.isEmpty()) {
            int size = deque.size();
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode poll = deque.poll();
                if (poll.left != null) {
                    deque.offer(poll.left);
                }
                if (poll.right != null) {
                    deque.offer(poll.right);
                }
            }
        }
        return depth;
    }
}

优化迭代法

class Solution {
   /**
     * 优化迭代法，针对暴力迭代法的getHeight方法做优化，利用TreeNode.val来保存当前结点的高度，这样就不会有重复遍历
     * 获取高度算法时间复杂度可以降到O(1)，总的时间复杂度降为O(n)。
     * 时间复杂度：O(n)
     */
    public boolean isBalanced(TreeNode root) {
        if (root == null) {
            return true;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pre = null;
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            TreeNode inNode = stack.peek();
            // 右结点为null或已经遍历过
            if (inNode.right == null || inNode.right == pre) {
                // 输出
                if (Math.abs(getHeight(inNode.left) - getHeight(inNode.right)) > 1) {
                    return false;
                }
                stack.pop();
                pre = inNode;
                root = null;// 当前结点下，没有要遍历的结点了
            } else {
                root = inNode.right;// 右结点还没遍历，遍历右结点
            }
        }
        return true;
    }

    /**
     * 求结点的高度
     */
    public int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = root.left != null ? root.left.val : 0;
        int rightHeight = root.right != null ? root.right.val : 0;
        int height = Math.max(leftHeight, rightHeight) + 1;
        root.val = height;// 用TreeNode.val来保存当前结点的高度
        return height;
    }
}

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

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

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

思路： 回溯法，注意记录路径间的箭头->。

递归法

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        //最终返回的结果
        List<String> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        //一条路径
        List<Integer> path = new ArrayList<>();
        traversal(root, res, path);
        return res;
    }

    public void traversal(TreeNode root, List<String> res, List<Integer> path) {
        path.add(root.val);
        //当前节点为叶子节点，记录一条结果
        if (root.left == null && root.right == null) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < path.size() - 1; i++) {
                sb.append(path.get(i));
                sb.append("->");
            }
            sb.append(path.get(path.size() - 1));
            res.add(sb.toString());
            return;
        }
        //处理左孩子
        if (root.left != null) {
            traversal(root.left, res, path);
            path.remove(path.size() - 1);
        }
        //处理右孩子
        if (root.right != null) {
            traversal(root.right, res, path);
            path.remove(path.size() - 1);
        }
    }
}

迭代法

//栈实现
 class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        //最终返回的结果
        List<String> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        //用栈实现
        Stack<Object> stack = new Stack<>();
        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) {
                res.add(path);
            }
            if (node.left != null) {
                stack.push(node.left);
                stack.push(path + "->" + node.left.val);
            }
            if (node.right != null) {
                stack.push(node.right);
                stack.push(path + "->" + node.right.val);
            }
        }
        return res;
    }
}

//队列实现
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        //最终返回的结果
        List<String> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        //用队列实现
        Queue<Object> queue = new LinkedList<>();
        queue.offer(root);
        queue.offer(root.val + "");
        while (!queue.isEmpty()) {
            //节点和路径都弹出
            TreeNode node = (TreeNode) queue.poll();
            String path = (String) queue.poll();
            //叶子节点
            if (node.left == null && node.right == null) {
                res.add(path);
            }
            if (node.left != null) {
                queue.offer(node.left);
                queue.offer(path + "->" + node.left.val);
            }
            if (node.right != null) {
                queue.offer(node.right);
                queue.offer(path + "->" + node.right.val);
            }
        }
        return res;
    }
}

3、404.左叶子之和

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

思路： 左叶子的定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点，因此必须要通过节点的父节点来判断其左孩子是不是左叶子。

递归法

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        //边界条件
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            return 0;
        }
        int leftValue = sumOfLeftLeaves(root.left);
        int rightValue = sumOfLeftLeaves(root.right);
        int value = 0;
        if (root.left != null && root.left.left == null && root.left.right == null) {
            value = root.left.val;
        }
        int sum = value + leftValue + rightValue;
        return sum;
    }
}

迭代法

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) return 0;
        Stack<TreeNode> stack = new Stack<> ();
        stack.add(root);
        int result = 0;
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            if (node.left != null && node.left.left == null && node.left.right == null) {
                result += node.left.val;
            }
            if (node.right != null) stack.add(node.right);
            if (node.left != null) stack.add(node.left);
        }
        return result;
    }
}

层序遍历法

// 层序遍历迭代法
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        int sum = 0;
        if (root == null) return 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size -- > 0) {
                TreeNode node = queue.poll();
                if (node.left != null) { // 左节点不为空
                    queue.offer(node.left);
                    if (node.left.left == null && node.left.right == null){ // 左叶子节点
                        sum += node.left.val;
                    }
                }
                if (node.right != null) queue.offer(node.right);
            }
        }
        return sum;
    }
}

总结

今天依旧是回溯和递归的经典应用。