104.二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

//普通的递归实现dfs 

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

 //用栈来模拟是实现dfs

dfs就像是二叉树的后序遍历

/**
 * 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) {
        stack<pair<TreeNode*,int>> s;
        int MaxDeep = 0,deep = 0;
        TreeNode* p = root;
        while(!s.empty()||p)
        {
            while(p)
            {
                s.push(pair<TreeNode*,int>(p,deep+1));
                deep++;
                p = p->left;
            }
            p = s.top().first;
            deep = s.top().second;
            if(MaxDeep < deep)
                MaxDeep = deep;
            s.pop();
            p = p->right;
        }
        return MaxDeep;
    }
};

 

 

//用队列模拟实现BFS

所谓BFS，就和二叉树的层序遍历是一样的

/**
 * 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) {
        deque<TreeNode*> d;
        int deep = 0;
        if(root == nullptr)
            return deep;
        d.push_back(root);
        TreeNode* p;
        while(!d.empty())
        {
            deep++;
            int size = d.size();
            while(size)
            {
                p = d.front();
                d.pop_front();
                if(p->left) d.push_back(p->left);
                if(p->right) d.push_back(p->right);
                size--;
            }
        }
        return deep;
    }
};