LeetCode: 515. 在每个树行中找最大值本文参与「新人创作礼」活动，一起开启掘金创作之路 515. 在每个树行

本文已参与「新人创作礼」活动，一起开启掘金创作之路。

515. 在每个树行中找最大值

来源：力扣（LeetCode）

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1： 在这里插入图片描述

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

示例2：

输入: root = [1,2,3]
输出: [1,3]

提示：

二叉树的节点个数的范围是 [0, $10^4$ ]
$-2^{31}$ <= Node.val <= $2^{31} - 1$

解法

BFS：层序遍历，使用一个列表维持当前层的节点。当前层的长度来控制遍历的次数，初始化该层的最大值为INT_MIN，然后遍历该层节点与之进行比较，更新该层的最大值。同时如果有左右子节点，将其加到列表中；
DFS：给定的node以及层，判断层数是否与结果的长度相同，如果是相同，说明该node应该放入该层中进行比较，并更新该层的最大值，注意是从第0层开始。

代码实现

BFS

python实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        
        res = []
        
        queue = [root]
        while queue:
            level_max_val = float('-INF')
            level_wide = len(queue)
            for i in range(level_wide):
                current_node = queue.pop(0)
                if current_node.val > level_max_val:
                    level_max_val = current_node.val
                
                if current_node.left:
                    queue.append(current_node.left)
                
                if current_node.right:
                    queue.append(current_node.right)
                
            res.append(level_max_val)
        return res

c++实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        if (root == nullptr)
            return {};
        
        queue<TreeNode*> q;
        vector<int> res;
        q.push(root);
        while (q.size()) {
            int level_wide = q.size();
            int level_max = INT_MIN;
            for(int i=0; i<level_wide; i++) {
                TreeNode* node = q.front();
                q.pop();
                if (node->val > level_max)
                    level_max = node->val;
                
                if (node->left != nullptr)
                    q.push(node->left);
                
                if (node->right != nullptr)
                    q.push(node->right);
            }
            res.push_back(level_max);
        }
        return res;
    }
};

复杂度分析

时间复杂度： $O(n)$
空间复杂度： $O(n)$

DFS

python实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        
        res = []

        def dfs(node, level):
            if len(res) == level:
                res.append(float('-inf'))
            
            if node.val > res[level]:
                res[level] = node.val
            
            if node.left:
                dfs(node.left, level+1)
            
            if node.right:
                dfs(node.right, level+1)
        
        dfs(root, 0)
        return res

c++实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    vector<int> res;
public:
    void dfs(TreeNode* node, int level) {
        if (res.size() == level)
            res.push_back(INT_MIN);
        
        if (node->val > res[level])
            res[level] = node->val;
        
        if (node->left != nullptr)
            dfs(node->left, level+1);
        
        if (node->right != nullptr)
            dfs(node->right, level+1);
    }

    vector<int> largestValues(TreeNode* root) {
        if (root == nullptr)
            return {};
        
        dfs(root, 0);
        return res;
    }
};

复杂度分析

时间复杂度： $O(n)$
空间复杂度： $O(n)$