LeetCode - 解题笔记 - 102 - Binary Tree Level Order Traversal

最新推荐文章于 2024-09-03 22:33:53 发布

原创最新推荐文章于 2024-09-03 22:33:53 发布 · 104 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #二叉树 #广度搜索

LeetCode解题笔记专栏收录该内容

191 篇文章

订阅专栏

这篇博客介绍了如何使用宽度优先搜索（BFS）来实现二叉树的层次遍历。作者提供了C++和Python两种语言的实现方式，并详细解释了代码逻辑，包括处理空节点和每层节点的存储。此外，还分析了时间复杂度和空间复杂度，其中时间复杂度为O(N)，空间复杂度在最坏情况下为O(2^logN)。

Solution 1

直观上就是一个BFS，使用队列管理每一层的遍历节点就可以了。

实现过程中需要注意力两点：

注意过滤遍历过程中的空节点
一整层需要放在一个数组内，我一开始类似的实现了一个包含vector的queue，发现很浪费，直接每一轮遍历当前队列内所有的节点（一层）就可以了

时间复杂度： $O (N)$ ，其中 $N$ 为输入序列的节点个数，线性遍历处理输入
空间复杂度： $O(2⌊log⁡N⌋)O(2^{\lfloor \log N \rfloor})$ ，其中 $N$ 为输入序列的节点个数，因为最坏情况下，最后一层全满，整个队列最大占用就是最后一层

/**
 * 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<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        
        if (root != nullptr) {
            queue<TreeNode*> q;
            q.push(root);
            ans.push_back({root->val});
            // cout << "ROOT " << root->val << endl;
            
            while (!q.empty()) {
                int numNodeLevel = q.size();
                vector<int> temp;
                
                while (numNodeLevel--) {
                    auto now = q.front();
                    q.pop();
                    // cout << "NOW " << now->val << endl;
                    
                    auto left = now->left;
                    if (left != nullptr) {
                        temp.push_back(left->val);
                        // cout << "LEFT " << left->val << endl;
                        q.push(left);
                    }

                    auto right = now->right;
                    if (right != nullptr) {
                        temp.push_back(right->val);
                        // cout << "RIGHT " << right->val << endl;
                        q.push(right);
                    }
                }
                                
                if (!temp.empty()) {
                    ans.push_back(temp);
                }
            }
        }
        
        return ans;
    }
};

Solution 2

Solution 1的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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        ans = list()
        
        if root is not None:
            q = collections.deque([root])
            ans.append([root.val])
            
            while q:
                numNodeLevel = len(q)
                temp = list()
                
                while numNodeLevel:
                    
                    now = q.popleft()

                    left, right = now.left, now.right
                    if left is not None:
                        temp.append(left.val)
                        q.append(left)
                    if right is not None:
                        temp.append(right.val)
                        q.append(right)
                        
                    numNodeLevel -= 1
                    
                if len(temp) > 0:
                    ans.append(temp)
            
        return ans