【二叉树】102. 二叉树的层序遍历

题目

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]]:
        if not root:
            return []
        res = list()
        q1 = collections.deque()
        q1.append(root)
        while len(q1) > 0:
            size = len(q1)
            tmp_list = list()
            for i in range(size):
                tmp_node = q1.popleft()
                tmp_list.append(tmp_node.val)
                if tmp_node.left:
                    q1.append(tmp_node.left)
                if tmp_node.right:
                    q1.append(tmp_node.right)
            res.append(tmp_list)
        
        return res

在Python的collections模块中，deque（双端队列）是一个线程安全、内存效率高的双向队列，它支持从两端快速地添加（append）和弹出（pop）元素。与list相比，deque在两端进行元素操作时的性能更高，因为它不需要像list那样在内存中进行大量的元素移动。

deque可以用于实现各种队列和栈的功能：

FIFO队列（先进先出）：你可以从一端添加元素，从另一端移除元素。
LIFO栈（后进先出）：你可以从同一端添加和移除元素。
以下是一些使用collections.deque的示例：

from collections import deque

# 创建一个空的双端队列
fifo_queue = deque()

# 从右端添加元素
fifo_queue.append(1)
fifo_queue.append(2)
fifo_queue.append(3)

# 打印队列内容（从左到右）
print(fifo_queue)  # 输出: deque([1, 2, 3])

# 从左端移除元素
print(fifo_queue.popleft())  # 输出: 1
print(fifo_queue)  # 输出: deque([2, 3])


from collections import deque

# 创建一个空的双端队列
lifo_stack = deque()

# 从右端添加元素（模拟压栈）
lifo_stack.append(1)
lifo_stack.append(2)
lifo_stack.append(3)

# 打印栈内容（从左到右，但通常我们想象栈是垂直的）
print(lifo_stack)  # 输出: deque([1, 2, 3])

# 从右端移除元素（模拟弹栈）
print(lifo_stack.pop())  # 输出: 3
print(lifo_stack)  # 输出: deque([1, 2])

Java

法1:基本好法

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offerLast(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> tmp = new ArrayList<>();
            for (int i = 0; i < size; ++i) {
                TreeNode node = deque.pollFirst();
                tmp.add(node.val);
                if (node.left != null) {
                    deque.offerLast(node.left);
                }
                if (node.right != null) {
                    deque.offerLast(node.right);
                }
            }
            ans.add(tmp);
        }

        return ans;
    }
}

版本2 code

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> tmp = new ArrayList<>();
        if (root == null) {
            return res;
        }
        List<TreeNode> q1 = new LinkedList<>();
        List<TreeNode> q2 = new LinkedList<>();
        q1.add(root);
        while (!q1.isEmpty()) {
            TreeNode topNode = q1.remove(0);
            tmp.add(topNode.val);
            if (topNode.left != null) {
                q2.add(topNode.left);
            }
            if (topNode.right != null) {
                q2.add(topNode.right);
            }
            if (q1.isEmpty()) {
                res.add(new ArrayList<>(tmp));
                tmp.clear();
                q1 = new LinkedList<TreeNode>(q2);
                q2.clear();
            }
        }

        return res;
    }
}