力扣刷题实战：二叉树遍历与循环队列设计

1. 数据结构刷题实战：从力扣Day7看算法思维养成

作为一名经历过校招和社招双重考验的程序员，我深知数据结构刷题对职业发展的重要性。今天要分享的是我在力扣第七天刷题时的完整记录和思考过程，这不仅是简单的解题记录，更包含了我对数据结构应用的深度理解。

1.1 为什么选择力扣作为刷题平台

力扣（LeetCode）之所以成为程序员必备的刷题平台，关键在于它的几个核心优势：题目分类清晰、测试用例完善、社区讨论活跃。特别是它的数据结构分类，几乎涵盖了从基础到高阶的所有类型，每道题都有详细的问题描述和示例，这对系统化学习数据结构非常有帮助。

我在第七天选择了三道中等难度的题目，分别是：

• 二叉树的锯齿形层次遍历（103题）
• 设计循环队列（622题）
• 合并K个升序链表（23题）

这三道题分别代表了树、队列和链表这三种最常用的数据结构，难度递进且具有代表性。

1.2 刷题前的准备工作

在开始刷题前，我通常会做以下准备：

1. 复习相关数据结构的基础知识
2. 准备测试环境（我习惯用VS Code配合LeetCode插件）
3. 准备笔记本记录思路（纸质或电子均可）
4. 设定时间限制（中等题一般控制在30-45分钟）

重要提示：刷题时一定要先自己思考，不要直接看答案。即使最终没能解出来，思考的过程也是极其宝贵的。

2. 二叉树的锯齿形层次遍历解析

2.1 问题重述与理解

题目要求对给定的二叉树进行锯齿形层次遍历，即第一层从左到右，第二层从右到左，第三层再从左到右，以此类推。

示例：
输入：

code复制    3
   / \
  9  20
    /  \
   15   7

输出：

code复制[
  [3],
  [20,9],
  [15,7]
]

2.2 解题思路分析

这道题本质上是层次遍历的变种，核心难点在于如何实现方向的交替变化。我的思考过程如下：

1. 基础解法：普通的层次遍历使用队列即可实现
2. 方向控制：需要一个标志位来指示当前层的遍历方向
3. 结果存储：需要按层存储节点值

最终确定的算法步骤：

1. 使用队列进行标准的BFS遍历
2. 维护一个布尔变量zigzag，初始为False
3. 每处理完一层，反转zigzag的值
4. 根据zigzag的值决定是否反转当前层的节点值列表

2.3 代码实现与优化

初始实现（Python）：

python复制from collections import deque

class Solution:
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        
        queue = deque([root])
        result = []
        zigzag = False
        
        while queue:
            level_size = len(queue)
            current_level = []
            
            for _ in range(level_size):
                node = queue.popleft()
                current_level.append(node.val)
                
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            
            if zigzag:
                current_level = current_level[::-1]
            
            result.append(current_level)
            zigzag = not zigzag
        
        return result

优化点：

1. 使用双端队列可以更高效地实现反向遍历
2. 可以提前判断是否需要反转，减少不必要的操作

2.4 复杂度分析与边界条件

时间复杂度：O(N)，每个节点访问一次
空间复杂度：O(N)，队列存储的节点数

边界条件考虑：

• 空树的情况
• 只有左子树或右子树的情况
• 单节点树的情况

3. 设计循环队列的实现

3.1 理解循环队列的概念

循环队列是一种线性数据结构，其操作基于FIFO（先进先出）原则，并且队尾连接到队首形成循环。这种结构可以更有效地利用存储空间。

关键特性：

• 固定容量
• 两个指针：front和rear
• 空和满的区分方法

3.2 设计思路与实现细节

我选择使用数组来实现循环队列，因为数组的固定大小特性与循环队列的需求匹配。关键点在于：

1. 空队列条件：front == rear
2. 满队列条件：(rear + 1) % capacity == front
3. 入队操作：rear指针移动
4. 出队操作：front指针移动

实现代码：

python复制class MyCircularQueue:

    def __init__(self, k: int):
        self.capacity = k + 1  # 额外空间用于区分空和满
        self.queue = [0] * self.capacity
        self.front = 0
        self.rear = 0

    def enQueue(self, value: int) -> bool:
        if self.isFull():
            return False
        self.queue[self.rear] = value
        self.rear = (self.rear + 1) % self.capacity
        return True

    def deQueue(self) -> bool:
        if self.isEmpty():
            return False
        self.front = (self.front + 1) % self.capacity
        return True

    def Front(self) -> int:
        if self.isEmpty():
            return -1
        return self.queue[self.front]

    def Rear(self) -> int:
        if self.isEmpty():
            return -1
        return self.queue[(self.rear - 1) % self.capacity]

    def isEmpty(self) -> bool:
        return self.front == self.rear

    def isFull(self) -> bool:
        return (self.rear + 1) % self.capacity == self.front

3.3 常见错误与调试技巧

在实现过程中容易犯的错误：

1. 容量计算错误：需要k+1的空间
2. 指针移动时忘记取模
3. 判断空和满的条件混淆

调试技巧：

1. 画图辅助理解指针移动
2. 编写测试用例覆盖边界条件
3. 逐步打印指针位置和队列状态

4. 合并K个升序链表的挑战

4.1 问题描述与难点分析

题目要求将k个升序链表合并为一个新的升序链表。难点在于如何高效地处理多个链表的合并。

示例：
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]

4.2 多种解法比较

我考虑了三种主要解法：

1. 暴力法：将所有节点值存入数组，排序后重建链表

   • 时间复杂度：O(NlogN)
   • 空间复杂度：O(N)

2. 顺序合并：两两合并链表

   • 时间复杂度：O(kN)
   • 空间复杂度：O(1)

3. 优先队列（堆）：维护当前各链表的最小节点

   • 时间复杂度：O(Nlogk)
   • 空间复杂度：O(k)

4.3 最优解实现与优化

使用优先队列的实现：

python复制import heapq

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        min_heap = []
        # 初始化堆，存储每个链表的头节点
        for i, node in enumerate(lists):
            if node:
                heapq.heappush(min_heap, (node.val, i, node))
        
        dummy = ListNode(0)
        current = dummy
        
        while min_heap:
            val, i, node = heapq.heappop(min_heap)
            current.next = node
            current = current.next
            
            if node.next:
                heapq.heappush(min_heap, (node.next.val, i, node.next))
        
        return dummy.next

优化点：

1. 使用索引i避免比较ListNode对象
2. 原地修改链表，减少空间使用

4.4 复杂度分析与实际应用

时间复杂度：O(Nlogk)，其中N是总节点数，k是链表数量
空间复杂度：O(k)用于堆存储

实际应用场景：

• 多路归并排序
• 外部排序
• 日志合并等大数据处理场景

5. 数据结构刷题的进阶技巧

5.1 如何选择合适的数据结构

在面对问题时，选择合适的数据结构至关重要。我的经验法则：

1. 需要快速查找：哈希表
2. 维护有序元素：平衡二叉搜索树
3. 先进先出：队列
4. 后进先出：栈
5. 层级关系：树
6. 图关系：邻接表或邻接矩阵

5.2 调试与优化方法论

1. 小数据测试：先用简单例子验证基本逻辑
2. 边界测试：考虑空输入、极端值等情况
3. 复杂度分析：确保算法在合理范围内
4. 代码复审：检查是否有冗余操作

5.3 刷题的系统化学习路径

建议的学习顺序：

1. 线性结构：数组、链表、栈、队列
2. 树结构：二叉树、二叉搜索树、堆
3. 图结构：DFS、BFS、最短路径
4. 高级主题：并查集、线段树、Trie等

5.4 常见问题解答

Q：刷了很多题但还是不会做新题怎么办？
A：建议每道题做完后总结解题模式，建立自己的解题模板库。

Q：如何平衡刷题速度和质量？
A：初期以理解为主，不求速度；熟练后可计时练习。

Q：需要刷多少题才能应对面试？
A：精刷150-200道经典题目比泛刷500道更有效。

6. 个人刷题心得与建议

经过第七天的刷题，我总结了以下几点心得：

1. 画图辅助思考：对于树和图的问题，画图能极大帮助理解
2. 先写伪代码：明确思路后再写实际代码，减少错误
3. 重视边界条件：很多错误都发生在边界情况下
4. 定期复习：遗忘是正常的，需要定期回顾经典题目

对于想要系统学习数据结构的朋友，我建议：

• 从基础数据结构开始，逐步深入
• 每学完一个数据结构，就刷对应的题目巩固
• 建立错题本，记录易错点和解题技巧
• 参与讨论，学习他人的优秀解法

最后分享一个小技巧：在力扣上可以查看国际站的高票解答，往往能学到更优雅的实现方式。不过要注意，有些解法为了追求简洁牺牲了可读性，在实际工程中需要权衡。