Day 16 | 104.MaximumDepth of BinaryTree| 111.MinimumDepth of BinaryTree| 222.CountComplete TreeNodes

王锴KKKKKKyle

已于 2022-12-25 03:06:16 修改

阅读量337

点赞数

分类专栏： LeetCode 文章标签： leetcode

于 2022-12-24 13:05:34 首次发布

本文链接：https://blog.csdn.net/kyle313606922/article/details/128415322

版权

LeetCode 专栏收录该内容

52 篇文章 0 订阅

订阅专栏

LeetCode 104. Maximum Depth of Binary Tree

Question Link

Solution:
1、Recursion（get depth）

class Solution {
    int max = 0;
    public int maxDepth(TreeNode root) {
        getDepth(root, 0);
        return max;
    }

    void getDepth(TreeNode node, int depth){
        if(node == null) return;
        depth++;
        max = max < depth ? depth : max;
        getDepth(node.left, depth);
        getDepth(node.right, depth);
    }
}

2、Recursion（get height）

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

}

The height of the root node is the max depth of a binary tree. So in this question, we get the max depth by using postorder traversal to calculate the height of the root node

3、Iterative Method（lever order）

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null)
            return 0;
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 0;
        while(!queue.isEmpty()){
            int size = queue.size();
            depth++;
            while(size > 0){
                TreeNode node = queue.poll();
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
                size--;
            }
        }
        return depth;
    }
}

LeetCode 111. Minimum Depth of Binary Tree

Question Link
Solution:
1、Recursion（get height）

class Solution {
    public int minDepth(TreeNode root) {
        return getDepth(root);
    }

    int getDepth(TreeNode node){
        if(node == null) return 0;
        if(node.left == null && node.right != null)
            return getDepth(node.right) + 1;
        if(node.left != null && node.right == null)
            return getDepth(node.left) + 1;
        if(node.left == null && node.right == null)
            return 1;

        return Math.min(getDepth(node.left), getDepth(node.right)) + 1;
    }
}

If the left subtree is null and the right subtree is not null. The minimum depth is the depth of the right subtree + 1.
If the right subtree is null and the left subtree is not null. The minimum depth is the depth of the left subtree + 1.
If both left and right subtrees are not null, return the minimum depth of the left and right subtrees + 1.

2、Iterative（lever order）

class Solution {
    public int minDepth(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++;
            while(size > 0){
                TreeNode node = deque.poll();
                if(node.left == null && node.right == null)
                    return depth;
                if(node.left != null) deque.offer(node.left);
                if(node.right != null) deque.offer(node.right);
                size--;
            }
        }
        return depth;
    }
}

When traversal, if both the left and right child nodes are null, return depth directly. Because the traversal order is from top to bottom, this is the minimum depth.

LeetCode 222. Count Complete Tree Nodes

Question Link
Solution:
1、Recursion

class Solution {
    public int countNodes(TreeNode root) {
        if(root == null)
            return 0;
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}

2、Iterative（lever order）

class Solution {
    public int countNodes(TreeNode root) {
        if(root == null)
            return 0;
        Deque<TreeNode> deque = new LinkedList<>();
        deque.add(root);
        int count = 0;
        while(!deque.isEmpty()){
            int size = deque.size();           
            while(size > 0){
                TreeNode node = deque.poll();
                count++;
                if(node.left != null) deque.offer(node.left);
                if(node.right != null) deque.offer(node.right);
                size--;
            }
        }
        return count;
    }
}

3、Complete Tree Solution

class Solution {
    public int countNodes(TreeNode root) {
        if(root == null)
            return 0;
        TreeNode left = root.left;
        TreeNode right = root.right;
        int leftDepth = 0, rightDepth = 0;
        // Calculate the depth of left subtree
        while(left != null) {
            left = left.left;
            leftDepth++;
        }
        // Calculate the depth of right subtree
        while(right != null){
            right = right.right;
            rightDepth++;
        }
        if(leftDepth == rightDepth)
            return (2 << leftDepth)-1;

        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}