数据结构刷题（十三）：101对称二叉树、104二叉树最大深度、111二叉树最小深度

1.对称二叉树

题目链接

思路：递归； 普通队列

注意：需要对false的情况进行讨论，

1.左节点为空，右节点不为空，不对称，return false

2.左不为空，右为空，不对称 return false

3.左右都为空，对称，返回true

4.左右都不为空，比较节点数值，不相同就return false

5.

• 比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。

• 比较内侧是否对称，传入左节点的右孩子，右节点的左孩子。

• 如果左右都对称就返回true ，有一侧不对称就返回false 。

解法一（递归）：

public boolean isSymmetric1(TreeNode root) {
    return compare(root.left, root.right);
}

private boolean compare(TreeNode left, TreeNode right) {
    // 均为null的情况
    if (left == null && right == null)
        return true;
    // 1.2.4情况的汇总
    else if (left == null || right == null || left.val != right.val)
        return false;
    // 第5种情况讨论
    boolean compareOut = compare(left.left, right.right);
    boolean compareIn = compare(left.right, right.left);
    return compareIn && compareOut;
}

解法二（队列）：

public boolean isSymmetric(TreeNode root) {
    Queue<TreeNode> deque = new LinkedList<>();
    deque.offer(root.left);
    deque.offer(root.right);
    while (!deque.isEmpty()) {
        TreeNode leftNode = deque.poll();
        TreeNode rightNode = deque.poll();
        if (leftNode == null && rightNode == null) {
            continue;
        }
        if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
            return false;
        }
        // 这里顺序需要注意，先比较外侧
        deque.offer(leftNode.left);
        deque.offer(rightNode.right);
        
        deque.offer(leftNode.right);
        deque.offer(rightNode.left);
    }
    return true;
}

2.二叉树最大深度

题目链接

思路：层序遍历； 后序遍历递归

注意：这里直接套用层序遍历的模板就行

解法一（层序遍历）：

public int maxDepth(TreeNode root){
    if (root == null)
        return 0;
    // 层序遍历
    Queue<TreeNode> que = new LinkedList<>();
    que.offer(root);
    int num = 0;
    while (!que.isEmpty()) {
        int len = que.size();
        num++;
        while (len --> 0) {
            TreeNode tmpNode = que.poll();
            if (tmpNode.left != null)
                que.offer(tmpNode.left);
            if (tmpNode.right != null)
                que.offer(tmpNode.right);
        }
    }
    return num;
}

解法二（后序遍历递归）

public int maxDepth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int leftDepth = maxDepth1(root.left);
    int rightDepth = maxDepth1(root.right);
    return Math.max(leftDepth, rightDepth) + 1;
}

3.二叉树最小深度

题目链接

思路：依然是层序遍历；后序遍历递归

注意：

1.当层序遍历到叶结点时，直接返回num值，因为此时是第一次遍历到叶结点，必然是最小深度

2.

解法一（层序遍历）：

public int minDepth(TreeNode root){
    if (root == null)
        return 0;
    // 层序遍历
    Queue<TreeNode> que = new LinkedList<>();
    que.offer(root);
    int num = 0;
    while (!que.isEmpty()) {
        int len = que.size();
        num++;
        while (len --> 0) {
            TreeNode tmpNode = que.poll();
            if (tmpNode.left == null && tmpNode.right == null)
                return num;
            if (tmpNode.left != null)
                que.offer(tmpNode.left);
            if (tmpNode.right != null)
                que.offer(tmpNode.right);
        }
    }
    return num;
}

解法二（后序遍历递归）：

public int minDepth(TreeNode root) {
    if (root == null)
        return 0;
    int leftDepth = minDepth1(root.left);
    int rightDepth = minDepth1(root.right);
    // 如果左子树为空，右子树不为空，说明最小深度是 1 + 右子树的深度
    if (root.left == null)
        return 1 + rightDepth;
    if (root.right == null)
        return 1 + leftDepth;
    return Math.min(leftDepth , rightDepth) + 1;
}