009 【入门】单双链表及其反转-堆栈诠释

链表与堆栈系统详解 | [数据结构]-[中级]-[通用]

一、基础概念与内存模型

1. 按值传递 vs 按引用传递 | [Java]-[基础]-[内存]

// [典型错误示例] - Java中的引用传递陷阱
void modify(Node node) {node = node.next;  // [警告] 错误！仅修改局部引用的指向，不影响原始链表
}// [正确做法] - 通过引用修改对象内部状态
void realModify(Node node) {node.val = 100;    // 修改对象属性node.next = null;  // 修改指针关系
}

传递方式	特点说明	内存影响	复杂度
按值传递	传递基本类型值的副本，方法内修改不影响原始变量	创建独立副本	⏱️ O(1)
按引用传递	传递对象引用的副本，通过引用可修改对象内部状态	共享同一对象	⏱️ O(1)

💡 关键理解：node = node.next 仅改变局部变量指向，而node.next = nextNode会真实修改链表结构

2. 单链表 vs 双链表定义 | [数据结构]-[基础]-[链表]

2.1 核心数据结构

// ▶ JDK8+
// [单链表节点] - 单向指针结构
public class ListNode {int val;           // 节点值ListNode next;     // 指向下一节点的指针/*** 构造单链表节点* @param val 节点存储的值*/public ListNode(int val) {this.val = val;this.next = null;  // [最佳实践] 显式初始化为null}
}// [双链表节点] - 双向指针结构
public class DoublyListNode {int val;                // 节点值DoublyListNode prev;   // 指向前驱节点的指针DoublyListNode next;   // 指向后继节点的指针/*** 构造双链表节点* @param val 节点存储的值*/public DoublyListNode(int val) {this.val = val;this.prev = null;  // [最佳实践] 显式初始化this.next = null;}
}

2.2 内存结构可视化

链表类型	优点	缺点	适用场景
单链表	实现简单，内存占用少	只能单向遍历	简单顺序存储，栈实现
双链表	可双向遍历，删除操作O(1)	额外内存开销，实现复杂	需要双向遍历的场景，如LRU缓存

二、链表反转核心技术

1. 链表反转原理（系统级视角）| [算法]-[中级]-[链表]

1.1 反转操作本质

1.2 单链表反转（迭代法）

/*** 反转单链表（迭代实现）* @param head 链表头节点* @return 反转后的链表头节点*/
public ListNode reverseLinkedList(ListNode head) {// 初始化前驱节点为nullListNode prev = null;// 当前处理的节点初始为头节点ListNode curr = head;// ⏱️ 时间复杂度: O(n)，空间复杂度: O(1)while (curr != null) {// 1. 暂存后继节点（避免断链）ListNode nextTemp = curr.next;// 2. 反转当前节点指针curr.next = prev;// 3. 移动双指针prev = curr;      // 前驱指针前进curr = nextTemp;  // 当前指针前进}// 返回新的头节点（原链表的尾节点）return prev;
}

1.3 双链表反转（双指针法）

/*** 反转双向链表* @param head 双向链表头节点* @return 反转后的双向链表头节点*/
public DoublyListNode reverseDoublyList(DoublyListNode head) {DoublyListNode curr = head;DoublyListNode newHead = null;// ⏱️ 时间复杂度: O(n)，空间复杂度: O(1)while (curr != null) {DoublyListNode next = curr.next;curr.next = curr.prev;curr.prev = next;if (next == null) {newHead = curr;}curr = next;}return newHead;
}

2. 堆栈诠释反转（递归法）| [算法]-[中级]-[递归]

2.1 递归实现原理

/*** 反转单链表（递归实现）* @param head 链表头节点* @return 反转后的链表头节点*/
public ListNode reverseByRecursion(ListNode head) {if (head == null || head.next == null) {return head;}ListNode newHead = reverseByRecursion(head.next);head.next.next = head;head.next = null;// ⏱️ 时间复杂度: O(n)，空间复杂度: O(n)（递归栈）return newHead;
}

2.2 递归栈内存分析

调用栈示例（链表1→2→3）：
| 栈帧层次 | 操作内容                      | 返回值 | 链表状态                      |
|---------|------------------------------|-------|------------------------------|
| 第3层   | reverseByRecursion(3)        | 3     | 3→null                       |
| 第2层   | reverseByRecursion(2)        | 3     | 3→2→null                     |
| 第1层   | reverseByRecursion(1)        | 3     | 3→2→1→null                   |
| 调用方  | 接收最终结果                  | 3     | 完成反转的链表 3→2→1→null     |

[警告] 递归实现虽然代码简洁，但存在栈溢出风险，不适用于长链表。可用迭代法替代。

三、高级应用与实战

1. K个一组反转链表 | [算法]-[高级]-[链表]

/*** K个一组反转链表* @param head 链表头节点* @param k 每组的大小* @return 反转后的链表头节点*/
public ListNode reverseKGroup(ListNode head, int k) {ListNode dummy = new ListNode(0);dummy.next = head;ListNode prev = dummy;ListNode curr = head;int length = 0;while (head != null) {length++;head = head.next;}for (int i = 0; i < length / k; i++) {ListNode groupTail = curr;for (int j = 0; j < k - 1; j++) {ListNode next = curr.next;curr.next = next.next;next.next = prev.next;prev.next = next;}prev = groupTail;curr = groupTail.next;}return dummy.next;
}

2. 堆栈应用：括号匹配 | [数据结构]-[中级]-[堆栈]

/*** 判断括号字符串是否有效* @param s 包含括号的字符串* @return 是否为有效的括号组合*/
public boolean isValid(String s) {if (s.length() == 0) {return true;}Stack<Character> stack = new Stack<>();for (char c : s.toCharArray()) {if (c == '(' || c == '[' || c == '{') {stack.push(c);} else {if (stack.isEmpty()) {return false;}char top = stack.pop();if ((c == ')' && top != '(') || (c == ']' && top != '[') || (c == '}' && top != '{')) {return false;}}}return stack.isEmpty();
}

3. 实战关联与性能对比

算法	时间复杂度	空间复杂度	适用场景
迭代反转	O(n)	O(1)	生产环境，大型链表
递归反转	O(n)	O(n)	代码简洁性优先，小型链表
K组反转	O(n)	O(1)	分块处理需求
栈应用	O(n)	O(n)	配对匹配问题

🔗 相关实战题目：

• [LeetCode 206] 反转链表 | [链表]-[简单]
• [LeetCode 25] K 个一组翻转链表 | [链表]-[困难]
• [LeetCode 92] 反转链表 II | [链表]-[中等]
• [LeetCode 20] 有效的括号 | [栈]-[简单]

3.1 算法可视化与跨栈关联

• 🔄 前端关联：虚拟DOM diff算法底层常用链表结构
• 🛡️ 安全提示：链表操作前务必检测环，避免死循环

四、面试要点与工程实践

1. 笔试/面试要点

• 空间复杂度优先：迭代法(O(1))优于递归法(O(n))
• 关键测试用例：
  • 空链表 → 返回null
  • 单节点链表 → 返回自身
  • 含循环链表 → 需提前检测
• 常见变种题：
  • 反转链表II（局部反转）
  • K个一组反转
  • 回文链表判断
• 高频陷阱：
  • [陷阱] 递归反转未断开head.next，导致环
  • [陷阱] 头插法反转时next指针丢失，链表断裂

2. 工程实践建议

// [最佳实践] 链表操作安全检查模板
public ListNode safeOperation(ListNode head) {// 1. 空链表检查if (head == null) {return null;}// 2. 单节点链表快速返回if (head.next == null) {return head;}// 3. 环检测（可选）if (hasCycle(head)) {throw new IllegalArgumentException("链表中存在环，无法安全操作");}// 4. 正常逻辑处理// ...
}// 检测链表是否有环（快慢指针法）
private boolean hasCycle(ListNode head) {ListNode slow = head;ListNode fast = head;while (fast != null && fast.next != null) {slow = slow.next;fast = fast.next.next;if (slow == fast) {return true;}}return false;
}

3. 提示

▶ 扩展问题：如何检测并处理链表中的环？

🚀 效率工具：VisuAlgo - 链表可视化 - 链表操作可视化学习平台

视频链接

左老师视频链接