Minimum Depth of Binary Tree,Maximum Depth of Binary Tree

最新推荐文章于 2020-02-19 02:21:51 发布

转载最新推荐文章于 2020-02-19 02:21:51 发布 · 326 阅读

leetcode 专栏收录该内容

220 篇文章

订阅专栏

本文探讨了使用深度学习与算法优化技术解决二叉树相关问题的方法，包括最小深度与最大深度的计算。通过递归与层序遍历策略，实现了高效求解。详细介绍了两种解决方案，旨在提升对二叉树结构的理解与操作能力。

LeetCode:Minimum Depth of Binary Tree

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

算法1：dfs递归的求解。分别求左右子树的最小深度，然后返回左右子树的最小深度中较小者+1

class Solution {
public:
    int minDepth(TreeNode *root) {
        if(root == NULL)return 0;
        int minleft = minDepth(root->left);
        int minright = minDepth(root->right);
        if(minleft == 0)
            return minright + 1;
        else if(minright == 0)
            return minleft + 1;
        else return min(minleft, minright) + 1;
    }
};

算法2 ：层序遍历二叉树，找到最先遍历到的叶子的层数就是树的最小高度

/**
 * Definition for binary tree
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode *root) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
         //层序遍历，碰到第一个叶子节点就停止,NULL作为每一层节点的分割标志
        if(root == NULL)return 0;
        int res = 0;
        queue<TreeNode*> Q;
        Q.push(root);
        Q.push(NULL);
        while(Q.empty() == false)
        {
            TreeNode *p = Q.front();
            Q.pop();
            if(p != NULL)
            {
                if(p->left)Q.push(p->left);
                if(p->right)Q.push(p->right);
                if(p->left == NULL && p->right == NULL)
                {
                    res++;
                    break;
                }
            }
            else 
            {
                res++;
                if(Q.empty() == false)Q.push(NULL);
            }
        }
        return res;
    }
};

LeetCode:Maximum Depth of Binary Tree

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

算法1：dfs递归求解

class Solution {
public:
    int maxDepth(TreeNode *root) {
        if(root == NULL)return 0;
        int maxleft = maxDepth(root->left);
        int maxright = maxDepth(root->right);
        if(maxleft == 0)
            return maxright + 1;
        else if(maxright == 0)
            return maxleft + 1;
        else return max(maxleft, maxright) + 1;
    }
};

算法2 ：层序遍历，树的总层数就是树的最大高度

/**
 * Definition for binary tree
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode *root) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        //层序遍历计算树的层数即可,NULL作为每一层节点的分割标志
        if(root == NULL)return 0;
        int res = 0;
        queue<TreeNode*> Q;
        Q.push(root);
        Q.push(NULL);
        while(Q.empty() == false)
        {
            TreeNode *p = Q.front();
            Q.pop();
            if(p != NULL)
            {
                if(p->left)Q.push(p->left);
                if(p->right)Q.push(p->right);
            }
            else 
            {
                res++;
                if(Q.empty() == false)Q.push(NULL);
            }
        }
        return res;
    }
};