［LeetCode］Minimum Depth of Binary Tree

最新推荐文章于 2023-12-15 03:22:29 发布

Lesley dude

最新推荐文章于 2023-12-15 03:22:29 发布

阅读量435

点赞数

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

本文链接：https://blog.csdn.net/aFeiOnePiece/article/details/46998565

版权

leetCode 专栏收录该内容

102 篇文章 0 订阅

订阅专栏

深搜的代码比较简洁：

注意一点，如果node只存在一个 subtree，则返回该subtree的深度。

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

宽搜时间更短（338ms，而上面的深搜是388ms）

解题思路：

1，宽度搜索，先找到一个左右子树均为空的 node，即返回当时的 depth

2，边界条件：root ＝＝ null

3，记录depth，记录 rightMost 节点，以此来记录depth

// 对Java语言的认识

// 1，queue的add操作，

// 2，queue的isEmpty() 方法

public class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) return 0;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);

        TreeNode rightMost = root;
        int depth = 1;
        while(!queue.isEmpty()){
            TreeNode peek = queue.poll();
            if (peek.left == null && peek.right == null) break;
            if (peek.left != null) queue.add(peek.left);
            if (peek.right != null) queue.add(peek.right);

            if (peek == rightMost){
                depth += 1;
                rightMost = peek.right != null ? peek.right : peek.left;
            }
        }
        return depth;
    }
}

－－－－－－－－－－－－－－－－第一遍C++解法－－－－－－－－－－－－－－－

解题思路：

宽度搜索。

边界条件：root 为NULL

前条件：queue，root->val = 1(深度)，push(root)

不变式：只要queue不空，取front，把它的左右子树push进queue（在这个逻辑之前，要判断 “结束条件”是否满足）

结束条件：如果front的左右子树均为NULL，找到了最浅的一片树叶，返回其val，就是树的深度

// 编译错误

Line 22: ‘class std::queue<TreeNode*>’ has no member named ‘top’

Queue没有top，只有front和back. top是Stack的方法;

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == NULL){
            return 0;
        }

        queue<TreeNode *> bst;
        root->val = 1;
        bst.push(root);

        while(!bst.empty()){
            TreeNode *node = bst.front();
            bst.pop();
            if ( node->left == NULL && node->right == NULL){
                return node->val;
            }else{
                if (node->left != NULL){
                    TreeNode * leftchild = node->left;
                    leftchild->val = node->val + 1;
                    bst.push(leftchild);
                }
                if (node->right != NULL){
                    TreeNode *rightChild = node->right;
                    rightChild->val = node->val + 1;
                    bst.push(rightChild);
                }
            }
        }
        return 0;
    }
};