程序员必刷力扣题：107.二叉树的层序遍历 II 探寻深度，触及核心要点

2023-11-05 07:25:28

引言：二叉树与层序遍历

二叉树是一种常见的数据结构，它由节点和边组成。每个节点包含一个值，边连接两个节点。二叉树的层序遍历是一种遍历二叉树的方法，它从根节点开始，逐层从左向右访问每个节点。

广度优先搜索：剖析核心算法

广度优先搜索（BFS）是一种图论算法，它从一个节点开始，逐层搜索图中的所有节点。在二叉树中，我们可以使用广度优先搜索来进行层序遍历。具体来说，我们可以使用队列来存储当前层的所有节点，然后逐个访问这些节点，并将它们的子节点加入队列。重复这个过程，直到所有节点都被访问。

Python 实现：清晰简洁的代码示例

def levelOrderBottom(root):
  if not root:
    return []

  queue = [root]
  result = []

  while queue:
    level = []
    for _ in range(len(queue)):
      node = queue.pop(0)
      level.append(node.val)
      if node.left:
        queue.append(node.left)
      if node.right:
        queue.append(node.right)

    result.insert(0, level)

  return result

Java 实现：面向对象的优雅表达

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new LinkedList<>();
        if (root == null) {
            return result;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> level = new LinkedList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }

            result.add(0, level);
        }

        return result;
    }
}

C++ 实现：追求极致性能的利器

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        if (root == nullptr) {
            return result;
        }

        queue<TreeNode*> queue;
        queue.push(root);

        while (!queue.empty()) {
            int size = queue.size();
            vector<int> level;
            for (int i = 0; i < size; i++) {
                TreeNode* node = queue.front();
                queue.pop();
                level.push_back(node->val);
                if (node->left != nullptr) {
                    queue.push(node->left);
                }
                if (node->right != nullptr) {
                    queue.push(node->right);
                }
            }

            result.insert(result.begin(), level);
        }

        return result;
    }
};