[LeetCode]113. Maximum Depth of Binary Tree二叉树的最大深度

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

 

解法1：很简单的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) {
        if (root == NULL) return 0;
        return 1 + max(maxDepth(root->left), maxDepth(root->right));
    }
};

 

解法2：借助队列进行BFS（层序遍历），最后一个遍历到的节点就是最深的节点，遍历一层高度加1。

/**
 * 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) {
        if (root == NULL) return 0;
        int max_depth = 0, cur_layer_node = 1;
        queue<TreeNode*> path;
        path.push(root);
        while (!path.empty()) {
            TreeNode* curr = path.front();
            path.pop();
            --cur_layer_node;
            if (curr->left != NULL || curr->right != NULL) {
                if (curr->left != NULL) path.push(curr->left);
                if (curr->right != NULL) path.push(curr->right);
            }
            if (cur_layer_node == 0) { // 一层所有节点遍历完毕
                ++max_depth; // 高度加1
                cur_layer_node = path.size(); // 计算下一层节点数目
            }
        }
        return max_depth;
    }
};

 

解法3：使用栈，如果首先沿着左指针遍历到最左边的子节点，然后回溯，如果存在右孩子则重新前面的过程。每深入一层就计算当前路径深度（栈元素个数）并更新最大深度。

/**
 * 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) {
        if (root == NULL) return 0;
        int max_depth = 1;
        TreeNode* prev = NULL;
        stack<TreeNode*> path;
        path.push(root);
        while (!path.empty()) {
            TreeNode* curr = path.top();
            if (prev == NULL || prev->left == curr || prev->right == curr) { //当前节点是根节点或者前一个节点还有孩子未被遍历
                if (curr->left != NULL) path.push(curr->left);
                else if (curr->right != NULL) path.push(curr->right);
            }
            else if (curr->left == prev) { // 已经回溯了，并且左孩子已经遍历过
                if (curr->right != NULL) path.push(curr->right); // 如果有右孩子则进栈
            }
            else
                path.pop(); // 当前节点左右孩子已经遍历完毕
            prev = curr;
            max_depth = max(max_depth, (int)path.size());
        }
        return max_depth;
    }
};