LeetCode之递归与非递归求二叉树最大最小深度

最新推荐文章于 2021-09-08 00:27:26 发布

原创最新推荐文章于 2021-09-08 00:27:26 发布

· 339 阅读

2 ·

版权

本文深入探讨了二叉树的最大深度和最小深度的求解方法，包括递归和非递归算法实现，提供了清晰的代码示例，适合算法学习者和计算机科学爱好者。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

104. 二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

利用递归我们很容易就可以写出来：

/**
 * 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 maxDepth(TreeNode* root) {
        if(NULL==root) return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

在利用非递归时，我们想到层序遍历，以及C++之二叉树的左右视图，通过队列很容易就可以得到层数。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(NULL==root) return 0;
        queue<TreeNode*> q;
        q.push(root);
        int res=0;
        while(!q.empty())
        {
            int n=q.size();
            while(n)
            {
                TreeNode* t=q.front();
                q.pop();
                if(t->left) q.push(t->left);
                if(t->right) q.push(t->right);
                n--;
            }
            res++;
        }
        return res;
    }
};

111. 二叉树的最小深度
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明: 叶子节点是指没有子节点的节点。

在利用递归的时候，我们不能简单粗暴的直接递归了，请看下面代码：

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(NULL==root) return 0;
        int l=minDepth(root->left);
        int r=minDepth(root->right);
        return (l&&r)?1+min(l,r):1+l+r;
    }
};

主要是遇到没有子节点的结点时，返回的是0，肯定是最小值了，，所以不能像球最大深度那样简单粗暴了。

在用非递归的方法时，也用层序遍历这一BFS方法，很容易得到：

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == NULL) return 0;

        queue<TreeNode* > q;
        q.push(root);
        int level = 1;
        while(!q.empty())
        {
            int size = q.size();
            for(int i = 0; i < size; i++)
            {
                TreeNode *p = q.front();
                q.pop();
                if(p->left == NULL && p->right == NULL)
                    return level;
                if(p->left) q.push(p->left);
                if(p->right) q.push(p->right);
            }
            level++;
        }
        return -1;
    }
};