二叉树 （`Depth`）递归 深度优先遍历 DFS

二叉树的高度（深度）为二叉树结点层次的最大值，也可以认为在根节点不为 nullptr 的情况下左右子树的最大高度 + 1；

先序（后序）遍历求解二叉树高度（Depth）的递归算法

算法描述：深度优先遍历 

若 root 为空，则 Depth 为 0

若 root 非空，则 Depth 为左右子树的最大高度 + 1

代码如下

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr)    //root 为空，高度（Depth）为 0 
            return 0;
        int depth_left, depth_right, depth_max;
        depth_left = maxDepth(root->left);    //遍历左子树
        depth_right = maxDepth(root->right);    //遍历右子树
        depth_max = depth_left > depth_right ? depth_left : depth_right;
        return (depth_max + 1);
    }
};

int g_max_depth = 0;
void maxDepth(TreeNode* root, int _depth)
{
    if(root != nullptr)
    {
        if(_depth > g_max_depth)
            g_max_depth = _depth;    //如果当前结点的层次值大于 depth ，更新 depth 值
        maxDepth(root->left, _depth + 1);
        maxDepth(root->right, _depth + 1);
    }
}

算法思想

二叉树的高度（Depth）为二叉树中结点层次的最大值，假设根结点为第一层结点，左右 h 层的结点的左右孩子都在 h + 1 层，因此可以通过遍历计算二叉树中的没个结点的层次，其中最大值为二叉树的高度（Depth）

二叉树 （`Depth`）非递归 广度优先遍历 BFS

广度优先遍历又叫层次遍历，从根结点开始，每遍历完一层 Depth + 1，直到最后一层；基于队列实现；当且仅当二叉树的每一层结点出队完毕 Depth + 1；

算法描述

利用队列进行二叉树高度（Depth）计算的非递归写法

若 root 为空，则返回 0 值

每次只有把同一层的结点输出，则 Depth + 1，因此要知道当前队列的长度 int length = q.size();当前队列的长度就是这一层的结点数

每一层的结点 pop 出队

TreeNode* pRoot = root;
while(length--)
{
    pRoot = q.front();
    q.pop();
    if(root->left != nullptr)
        q.pop(pRoot->left);
    if(root->right != nullptr)
        q.pop(pRoot->right);
}

代码如下

int maxDepth(TreeNode* root)//利用队列进行非递归算法
{
    queue<TreeNode*> q;
    TreeNode* pRoot=root;
    int _depth=0,lenth;
    if(root == nullptr)
        return 0;
    q.push(pRoot);
    while(!q.empty())//每次只有把在同一层的所有结点出队以后才_depth++，因此要知道当前队列的长度，用lenth表示
    {
        _depth++;
        lenth=q.size();//当前队列长度就代表这一层的结点个数
        while(lenth--)
        {
            pRoot=q.front();
            q.push();
            if(pRoot->left)
                q.push(pRoot->left);
            if(pRoot->right)
                q.push(pRoot->right);
        }
    }
    return _depth;
}