LeetCode 104. 二叉树的最大深度（C++实现）

一、题目描述

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

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

说明: 叶子节点是指没有子节点的节点。

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

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

 

二、思路

一般来说，树的遍历分为两种策略：

• DFS（深度优先搜索）

       在这个策略中，我们采用深度作为优先级，以便从跟开始一直到达某个确定的叶子，然后再返回根到达另一个分支。深度优先搜索策略又可以根据根节点、左孩子和右孩子的相对顺序被细分为前序遍历，中序遍历和后序遍历。

• BFS（广度优先搜索），我们按照高度顺序一层一层的访问整棵树，高层次的节点将会比低层次的节点先被访问到。就是层次遍历

对于本题来说，就可以用 DFS或者 BFS 来解决（其实大多数二叉树的问题都可以用树的遍历来解决）。根据实际情况灵活应变即可，比如本题就是不需要像中序遍历那样存储每一个节点，只需要计算深度即可（深度优先就是每往下走一节点就将深度加一，而广度优先就是每遍历一层，就将深度加一）。

 

方法一：DFS（深度优先遍历）

递归：

        对于DFS首先想到的是通过递归的方法来解决，在本题中每个节点的深度与它左右子树的深度有关，且等于其左右子树最大深度值加1，即：

迭代：

     DFS不是一定需要递归的，函数递归本质上是函数调用函数自己，在系统的底层，我们借助的是函数栈来保存之前的函数，也就是上一层的内容，如果不使用递归，那么就是说我们不能依靠系统为我们提供的函数栈，因此我们需要手动建立一个栈来保存上一层需要的内容。在本题中，我们使用 中序遍历的方法来找到二叉树的最大深度。

中序遍历的思想就是一直往左子树中，直到到达叶子节点，然后存下该叶子节点，再存根，接着转向右子树

 

方法二：BFS（广度优先遍历）

      用BFS，就是采用层次遍历的方法，需要一个队列

 

三、实现

 

法一：DFS递归

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


//版本二
class Solution {
public:
    int maxDepth(TreeNode* root) {
        int max = 1;
        if(root == NULL) return 0;
        int leftDepth = maxDepth(root->left);
        int rightDepth = maxDepth(root->right);
        if(leftDepth > rightDepth){
            max += leftDepth;
        }
        else{
            max += rightDepth;
        }
        return max;
    }
};

 

法二：DFS（迭代--中序遍历法）

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == NULL) return 0;
        int deep = 0;
        int maxDeep = 0;
        stack<pair<TreeNode*,int>> s;
        TreeNode* p =root;
        //若栈非空，则说明还有一些节点的右子树尚未探索；若p非空，意味着还有一些节点的左子树尚未探索
        while(!s.empty() || p != NULL){
            while(p){   //一直往左子树找直到叶子节点
                s.push(pair<TreeNode*,int>(p,++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（广度优先遍历）

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == NULL) return 0;
        deque<TreeNode*> q;         //创建双端队列
        q.push_back(root);          //层次遍历每个点只访问一次，所以开始就要将根节点入队列
        int deep = 0;
        while(!q.empty()){          //队列不为空，表示还有节点未访问
            deep++;
            int num = q.size();
            for(int i = 0;i < num;i++){  //一个for循环表示一层
                TreeNode* node = q.front();
                q.pop_front();
                if(node->left) q.push_back(node->left);  //先左节点再右节点，因为是队列，先进先出。
                if(node->right) q.push_back(node->right);
            }
        }
        return deep;
    }
};