剑指offer 38. 二叉树的深度

38. 二叉树的深度

题目描述

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }

法一：递归遍历

class Solution {
public:
    // 前序递归遍历，分别统计左右子树的高度
    int preOrder(TreeNode* pRoot){
        if(pRoot){
            int leftH = preOrder(pRoot->left);
            int rightH = preOrder(pRoot->right);
            if(leftH >= rightH){
                return leftH + 1;
            }else{
                return rightH + 1;
            }
        }
        return 0;
    }
    
    int TreeDepth(TreeNode* pRoot)
    {
        return preOrder(pRoot);
    }
};

 Java实现：

class Solution {
    // 递归方式
    public int maxDepth(TreeNode root) {
        // 如果root不为空，递归统计左右子树的高度
        if(root != null){
            int leftDepth = maxDepth(root.left);
            int rightDepth = maxDepth(root.right);
            // 返回左右子树高度的稍大者+1
            return (leftDepth >= rightDepth ? leftDepth : rightDepth) + 1;
        }else{        // 如果root为空，直接返回0
            return 0;
        }
    }
}

leetcode运行时间为0ms，空间为39.1mb

复杂度分析：

时间复杂度：对个每个结点都进行了一次遍历，所以复杂度复杂度为O(n)

空间复杂度：递归栈的深度为O(logn)

法二：层序遍历

利用队列实现层序遍历， 用一个变量记录当前深度的结点个数，每出队一个结点，入队两个子节点后计数器加一，如果当前层的所有结点都已经出队完毕（计数器的值等于当前深度的结点个数），层数加一，计数器重置，当前层结点个数更新

class Solution {
public:
    
    int TreeDepth(TreeNode* pRoot)
    {
        // 层序遍历统计深度
        queue<TreeNode*> Q;
        if(pRoot != NULL){
            Q.push(pRoot);
        }
        int dep = 0, count = 0, nextCount = Q.size();    // nextCount 存储的是当前层数的结点个数
        while(!Q.empty()){
            TreeNode* node = Q.front();
            Q.pop();
            count++;
            if(node->left)
                Q.push(node->left);
            if(node->right)
                Q.push(node->right);
            // 如果当前层的所有结点都已经出队完毕，层数加一，计数器重置，当前层结点个数更新
            if(count == nextCount){
                dep++;
                count = 0;
                nextCount = Q.size();
            }
        }
        return dep;
    }
};

Java实现

抛出当前层左右结点，将下层结点入队，队列中的元素个数即为当前层的结点个数

class Solution {
    // 层序遍历方式
    public int maxDepth(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        if(root == null){
            return 0;
        }
        queue.offer(root);
        int layer = 0;
        int count = 0;
        while(!queue.isEmpty()){
            // 抛出当前层左右结点，将下层结点入队
            count = queue.size();　　// 队列中的元素个数即为当前层的结点个数
            for(int i = 0; i < count; i++){
                TreeNode top = queue.poll();
                if(top.left != null){
                    queue.offer(top.left);
                }
                if(top.right != null){
                    queue.offer(top.right);
                }
            }
            layer++;
        }
        return layer;
    }
}

leetcode运行时间为1ms，空间为38.6mb

复杂度分析：

时间复杂度：同样是把每个元素都入队出队了一次，所以时间复杂度为O(n)

空间复杂度：空间复杂度为树每层结点个数的最大值，即为O(n)