zoukankan      html  css  js  c++  java
  • [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;
        }
    };
  • 相关阅读:
    Java对象的生命周期与作用域的讨论(转)
    [置顶] Oracle学习路线与方法
    Java实现 蓝桥杯 算法训练 未名湖边的烦恼
    Java实现 蓝桥杯 算法训练 未名湖边的烦恼
    Java实现 蓝桥杯 算法训练 未名湖边的烦恼
    Java实现 蓝桥杯 算法训练 最大的算式
    Java实现 蓝桥杯 算法训练 最大的算式
    Java实现 蓝桥杯 算法训练 最大的算式
    Java实现 蓝桥杯 算法训练 最大的算式
    Java实现 蓝桥杯 算法训练 最大的算式
  • 原文地址:https://www.cnblogs.com/aprilcheny/p/5076775.html
Copyright © 2011-2022 走看看