【简单】104. 二叉树的最大深度

【题目】
给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
来源：leetcode
链接：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/
【示例】
给定二叉树 [3,9,20,null,null,15,7]
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。
【代码：使用后序遍历】
后序遍历的非递归方式，虽然代码繁琐但是速度很快4ms

class Solution {
public:
    //使用后序遍历
    int depth=0;
    stack<TreeNode*> s;
    int maxDepth(TreeNode* root) {
        TreeNode* treeNode=root;
        TreeNode* lastVisit=NULL;
        while(!s.empty()||treeNode){
            while(treeNode){
                s.push(treeNode);
                depth=depth>=s.size()?depth:s.size();
                treeNode=treeNode->left;
            }
            if(!s.empty()){
                treeNode=s.top();
                if(treeNode->right&&treeNode->right!=lastVisit){
                    treeNode=treeNode->right;
                    s.push(treeNode);
                    depth=depth>=s.size()?depth:s.size();
                    treeNode=treeNode->left;                    
                }else{
                    s.pop();
                    lastVisit=treeNode;
                    treeNode=NULL;
                }
            }
        }
        return depth;
    }
};

【递归】
代码简洁但是速度较慢

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

【dfs深度优先迭代】
执行用时 :8 ms, 在所有 C++ 提交中击败了92.71% 的用户
内存消耗 :17 MB, 在所有 C++ 提交中击败了100.00%的用户

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root==NULL)
            return 0;
        int max_depth=0;
        stack<pair<TreeNode*,int>> s;
        s.push(pair<TreeNode*,int>(root,1));
        while(!s.empty()){
            TreeNode *node=s.top().first;
            int depth=s.top().second;
            s.pop();
            if(node->left)
                s.push(pair<TreeNode*,int>(node->left,depth+1));
            if(node->right)
                s.push(pair<TreeNode*,int>(node->right,depth+1));
            max_depth=max(max_depth,depth);
        }
        return max_depth;
    }
};

【bfs广度优先迭代】这个解法很好，既能得到树的深度又能得到树的宽度。

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