攻克链表与堆栈：从LeetCode实战到算法思维跃迁

攻克链表与堆栈：从LeetCode实战到算法思维跃迁

【免费下载链接】leetcode-notes 🐳 LeetCode 算法笔记：面试、刷题、学算法。在线阅读地址：https://datawhalechina.github.io/leetcode-notes/ 项目地址: https://gitcode.com/datawhalechina/leetcode-notes

为什么90%的算法新手都栽在数据结构上？

你是否也曾在LeetCode刷题时遇到这些困境：

• 看到链表题就手忙脚乱，分不清前驱节点与头指针
• 堆栈操作总是忘记边界条件，提交时反复TLE
• 明明掌握了理论知识，却无法将思路转化为高效代码

本文将通过8个实战案例+4种核心技巧+2套思维模型，帮你彻底攻克链表与堆栈难题。读完本文你将获得：

• 环形链表检测的3种高效算法及复杂度对比
• 堆栈在括号匹配问题中的极致应用
• 链表操作的"哑节点-双指针"黄金组合
• 从基础解法到最优解的思维跃迁路径

链表（Linked List）：数据结构中的"变形金刚"

链表的本质与内存模型

链表是一种物理存储单元上非连续、非顺序的线性数据结构，由一系列节点（Node）组成，每个节点包含数据域和指针域。

与数组相比，链表具有独特优势：

• 插入删除无需移动元素（时间复杂度O(1)）
• 理论上可无限扩展（不受预先分配空间限制）

但也存在固有缺陷：

• 无法随机访问（需从头节点遍历，时间复杂度O(n)）
• 额外空间存储指针域

实战一：合并两个有序链表（LeetCode #21）

问题描述：将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

输入示例：

list1 = [1,2,4], list2 = [1,3,4]
输出：[1,1,2,3,4,4]

解法：哑节点+双指针

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        # 创建哑节点作为合并后链表的起始点
        dummy_head = ListNode(-1)
        curr = dummy_head
        
        # 双指针遍历两个链表
        while list1 and list2:
            if list1.val <= list2.val:
                curr.next = list1
                list1 = list1.next
            else:
                curr.next = list2
                list2 = list2.next
            curr = curr.next
        
        # 处理剩余节点
        curr.next = list1 if list1 is not None else list2
        
        return dummy_head.next

算法解析：

• 使用哑节点（dummy node）避免头节点处理的边界条件
• 双指针同步遍历两个链表，每次选择较小值节点
• 时间复杂度O(m+n)，空间复杂度O(1)（仅使用常数额外空间）

思维提升点：

哑节点技术是链表操作的"关键方法"，尤其适用于头节点可能变化的场景。通过创建一个虚拟头节点，可以将所有节点的处理逻辑统一化，大幅减少代码复杂度。

实战二：环形链表检测（LeetCode #141）

问题描述：给定一个链表，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪next指针再次到达，则链表中存在环。

解法对比：

方法	实现思路	时间复杂度	空间复杂度
哈希表	存储已访问节点，遇到重复节点则有环	O(n)	O(n)
快慢指针	慢指针每次1步，快指针每次2步，相遇则有环	O(n)	O(1)

最优解法：Floyd判圈算法

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        if head is None or head.next is None:
            return False
            
        slow = head
        fast = head.next
        
        while slow != fast:
            if fast is None or fast.next is None:
                return False
            slow = slow.next        # 慢指针走1步
            fast = fast.next.next   # 快指针走2步
            
        return True

算法解析：

• 快指针如果追上慢指针，则证明存在环（类似操场跑步，快的终将追上慢的）
• 快指针每次移动2步，慢指针每次移动1步，相对速度为1步/次
• 无环情况下，快指针会率先到达终点（next为null）

思维提升点：

双指针技巧在链表问题中应用广泛，除了检测环，还可用于寻找中间节点、倒数第k个节点等场景。核心思想是通过指针速度差或位置差创造解题条件。

堆栈（Stack）：算法世界的"秩序守护者"

堆栈的哲学：后进先出（LIFO）

堆栈是一种遵循"后进先出"原则的线性数据结构，具有入栈（push）和出栈（pop）两种基本操作。在计算机科学中无处不在：

• 函数调用栈
• 表达式求值
• 浏览器历史记录
• 撤销操作实现

实战三：有效的括号（LeetCode #20）

问题描述：给定一个只包括'('，')'，'{'，'}'，'['，']'的字符串s，判断字符串是否有效。有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合
2. 左括号必须以正确的顺序闭合

解法：堆栈匹配法

class Solution:
    def isValid(self, s: str) -> bool:
        # 奇数长度直接返回False
        if len(s) % 2 == 1:
            return False
            
        stack = []
        # 括号匹配字典
        mapping = {')': '(', ']': '[', '}': '{'}
        
        for char in s:
            if char in mapping.values():
                # 左括号入栈
                stack.append(char)
            elif char in mapping.keys():
                # 右括号出栈匹配
                if not stack or stack.pop() != mapping[char]:
                    return False
            else:
                # 非括号字符（题目中未出现，但为鲁棒性考虑）
                return False
                
        # 栈为空则完全匹配
        return len(stack) == 0

算法解析：

• 使用字典存储括号匹配规则，简化条件判断
• 左括号入栈，右括号则与栈顶元素匹配
• 提前判断字符串长度为奇数的情况，优化性能
• 时间复杂度O(n)，空间复杂度O(n)

思维提升点：

堆栈是处理"嵌套结构"的利器。在括号匹配、HTML标签验证、表达式求值等场景中，堆栈能够天然地处理层级关系。这种"后进先出"的特性，完美契合了嵌套结构的闭合顺序要求。

从算法到思维：链表与堆栈的设计哲学

数据结构选择决策树

链表操作的黄金法则

1. 边界处理优先：永远先考虑空链表、单节点链表等边界情况

   # 良好的边界处理习惯
   if not head:
       return None
   if not head.next:
       return head
   

2. 哑节点技术：在头节点可能变化时使用

   dummy = ListNode(0)
   dummy.next = head
   # 操作dummy.next而非head，避免头节点丢失
   

3. 双指针技巧：解决中点、环检测、距离问题

   • 快慢指针：步速差创造条件
   • 前后指针：维持距离关系

4. 递归思维：链表天然的递归结构

   # 链表反转的递归实现
   def reverseList(head):
       if not head or not head.next:
           return head
       p = reverseList(head.next)
       head.next.next = head
       head.next = None
       return p
   

堆栈应用的精髓

1. 单调栈：维持栈内元素单调性，解决"下一个更大元素"类问题
2. 最小栈：常数时间获取栈内最小值（空间换时间思想）
3. 栈的嵌套使用：复杂问题拆解为多个栈操作
4. 栈与递归的转化：将递归算法转为非递归（避免栈溢出）

进阶挑战：链表与堆栈的组合应用

实战四：接雨水问题（LeetCode #42）

问题描述：给定n个非负整数表示每个宽度为1的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

堆栈解法：

class Solution:
    def trap(self, height: List[int]) -> int:
        stack = []
        water = 0
        current = 0
        
        while current < len(height):
            # 栈不为空且当前高度大于栈顶高度
            while stack and height[current] > height[stack[-1]]:
                top = stack.pop()
                if not stack:
                    break
                    
                # 计算距离和高度差
                distance = current - stack[-1] - 1
                bounded_height = min(height[current], height[stack[-1]]) - height[top]
                water += distance * bounded_height
                
            stack.append(current)
            current += 1
            
        return water

算法解析：

• 使用单调栈存储柱子索引，维持栈内高度递减
• 遇到更高柱子时计算接水量，体现"凹槽"思想
• 时间复杂度O(n)，空间复杂度O(n)

思维提升点：

单调栈是一种特殊的堆栈应用，通过维持栈内元素的单调性，可以高效解决"下一个更大元素"、"最大矩形面积"等问题。这种数据结构将基础解法的O(n²)时间复杂度优化为O(n)，体现了数据结构对算法效率的巨大影响。

总结与升华：从代码到思维的跃迁

通过本文的学习，你已经掌握了链表与堆栈的核心操作和实战技巧。但真正的算法能力提升，在于培养以下思维方式：

1. 抽象数据类型思维：关注"操作"而非"实现"，理解每种数据结构的本质特性
2. 复杂度权衡意识：在时间与空间之间寻找最优解，理解"没有免费的午餐"
3. 问题转化能力：将实际问题抽象为数据结构问题，如括号匹配→堆栈问题
4. 边界条件敏感性：培养对空值、边界、极限情况的敏锐嗅觉

后续学习路径

1. 基础巩固：完成LeetCode链表专题（#206反转链表、#142环形链表II）
2. 堆栈进阶：学习单调栈（#84柱状图中最大的矩形）、最小栈（#155最小栈）
3. 综合应用：尝试LRU缓存机制（#146），结合哈希表与双向链表
4. 算法设计：研究用栈实现队列（#232）、用队列实现栈（#225）

记住，数据结构是算法的基石，而算法是编程的灵魂。掌握链表与堆栈，将为你打开更广阔的算法世界大门。现在就打开LeetCode，用本文学到的知识解决#21、#20、#141这三道题，检验你的学习成果吧！

【免费下载链接】leetcode-notes 🐳 LeetCode 算法笔记：面试、刷题、学算法。在线阅读地址：https://datawhalechina.github.io/leetcode-notes/ 项目地址: https://gitcode.com/datawhalechina/leetcode-notes