二叉树的深度_二叉树的深度

题目描述

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

数据结构 TreeNode 的定义：

牛客编程题高级数据结构格式说明_牛客博客​blog.nowcoder.net

解题思路及代码

方法一：分治法

分治法的基本思想是：求一个规模为 n 的问题时，我们先求左边规模大约为 n/2 的问题，然后再求右边规模大约为 n/2 的问题，最后合并左边，右边的解得到最终解。

所以对于求二叉树深度这个具体的问题而言，解决思路就是分别求出左右子树的深度，然后取较大值加 1 就是最终解。（一个递归的过程）

步骤为：

1. 求TreeDepth(TreeNode* pRoot)->int
2. 先求 TreeDepth(pRoot->left) ->lval
3. 再求TreeDepth(pRoot->right) ->rval
4. return max(lval, rval) + 1

代码为：

class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
        if (!pRoot) return 0;
        int lval = TreeDepth(pRoot->left);
        int rval = TreeDepth(pRoot->right);
        return max(lval, rval) + 1;

    }
};

Java 版：

public int TreeDepth(TreeNode root) {
    return root == null ? 0 : 1 + Math.max(TreeDepth(root.left), TreeDepth(root.right));
}

时间复杂度：O(n)

空间复杂度：O(n),当退化到链表时

方法二：层次遍历

使用队列来完成层次遍历。

步骤：

1. 初始化：一个队列queue q， 将root节点入队列q
2. 如果队列不空，做如下操作：
3. 弹出队列头，保存为node，将node的左右非空孩子加入队列
4. 做2,3步骤，知道队列为空

如果不需要确定当前遍历到哪一层，模板如下：

void bfs() {
    vis[] = 0;
    queue<int> pq(start_val);

    while (!pq.empty()) {
        int cur = pq.front(); pq.pop();
        for (遍历cur所有的相邻节点nex) {
            if (nex节点有效 && vis[nex]==0){
                vis[nex] = 1;
                pq.push(nex)
            }
        }
    }
}

如果需要确定遍历到哪一层，模板如下：

添加一个变量 level，然后每一层遍历完 level 加 1。

void bfs() {
    int level = 0;
    vis[] = 0; // or set
    queue<int> pq(original_val);
    while (!pq.empty()) {
        int sz = pq.size();

        while (sz--) {
                int cur = pq.front(); pq.pop();
            for (遍历cur所有的相邻节点nex) {
                if (nex节点有效 && vis[nex] == 0) {
                    vis[nex] = 1;
                    pq.push(nex)
                }
            } // end for
        } // end inner while
        level++;

    } // end outer while
}

所以本题的代码为：

class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
        if (!pRoot) return 0;
        queue<TreeNode*> q;
        q.push(pRoot);
        int leve1 = 0;
        while (!q.empty()) {
            int sz = q.size();
            while (sz--) {
                auto node = q.front(); q.pop();
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            leve1 += 1;
        }
        return level;

    }
};

时间复杂度：O(n),二叉树的每个节点遍历一次

空间复杂度：O(n),最差情况下，树平衡时，队列最多存储n/2个节点。

---

解析参考来自：

二叉树的深度_牛客网​www.nowcoder.com