求二叉树的最大、最小深度

1、描述

输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

例如：

给定二叉树 [3,9,20,null,null,15,7]，

3

/
9 20
/
15 7
返回它的最大深度 3

来源：力扣（LeetCode）
求二叉树的最大深度
求二叉树的最小深度
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2、关键字

二叉树，求深度

3、思路

层序遍历，两层while循环，
思路2：递归

4、notes

queue的入队列，是que.push();,出队列是que.pop();

que.push();
que.pop();
que.pop_front();// ???,没有这玩意！！！！

外层循环是队列非空，内层循环是次数是当前层元素的个数。
1、图的广度优先就是树的层序遍历的推广
3、广度优先遍历的代码结构第一层while()判断是否为空，第二层while()判断 一层是否结束
2、queueSTL不熟悉，
queue入队，如例：q.push(x); 将x 接到队列的末端。

queue出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。

访问queue队首元素，如例：q.front()，即最早被压入队列的元素。

访问queue队尾元素，如例：q.back()，即最后被压入队列的元素。

判断queue队列空，如例：q.empty()，当队列空时，返回true。

访问队列中的元素个数，如例：q.size()

5、复杂度

时间： O(mlogh),m是叶子节点个数，h是树高度
空间：O(m),只要一个变量存结果，还需要一个队列的长度m，最多元素的那一层。

6、code

最大深度：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

// 最大深度：方法2：递归
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(!root) return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};


// 最大深度： 方法1：
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        int res = 0;  // 这里初始化为0，不能为1，不然是多的 ！
        queue<TreeNode*>que;
        que.push(root);
        while(!que.empty()){
            int nn = que.size();
            while(nn--){
                auto tem = que.front();
                // que.pop_front();  // 这里怎么写来着？？？
                que.pop();
                if(tem->left){
                    que.push(tem->left);
                }
                if(tem->right){
                    que.push(tem->right);
                }
            }            
            res++;
        }
        return res;
    }
};

二叉树的最小深度

/**
 * 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) return 0;
        else if(!root->left) return minDepth(root->right) + 1;
        else if(!root->right) return minDepth(root->left) + 1;
        else return min(minDepth(root->left),minDepth(root->right)) + 1;
    }
};


// 最小深度 非递归层序遍历，队列，
class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*>qu;  // 树的队列
        if(root==NULL) return 0;  // 如果根节点为空，直接返回
        qu.push(root);
        int res=1;  // 记录结果
        while(!qu.empty())  // 不为空
        {
            int queNum=qu.size();    // 一层的数量      
            while(queNum--)  // 此一层的操作
            {
                auto tem=qu.front();   // 取此一层队列的第一个元素 
                qu.pop();  // 此为队列删除队首元素            
                if(tem->left==NULL)  // 判断左子树是否为空，此条件下两种情况，后边else有两种情况
                {
                    //qu.push(tem->left);
                    if(tem->right==NULL)  // 如果右子树也是空，即为叶子节点
                    return res;
                    else  // 右子树不为空
                    qu.push(tem->right);
                }
                else  // 左子树不为空
                {
                    qu.push(tem->left);  // 左子树直接进队列
                    if(tem->right!=NULL)  // 判断右子树也得不为空才进队列
                    qu.push(tem->right);
                }                            
            }
            res++;
        }
        return res;       
    }
};