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

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

一、基础概念与内存模型

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

// [典型错误示例] - Java中的引用传递陷阱
void modify(Node node) {
    node = node.next;  // [警告] 错误！仅修改局部引用的指向，不影响原始链表
}

// [正确做法] - 通过引用修改对象内部状态
void realModify(Node node) {
    node.val = 100;    // 修改对象属性
    node.next = null;  // 修改指针关系
}

💡 关键理解：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 内存结构可视化

二、链表反转核心技术

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

1.1 反转操作本质

1.2 单链表反转（迭代法）

/**
 * 反转单链表（迭代实现）
 * @param head 链表头节点
 * @return 反转后的链表头节点
 */
public ListNode reverseLinkedList(ListNode head) {
    // 初始化前驱节点为null
    ListNode 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. 实战关联与性能对比

🔗 相关实战题目：

• [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 - 链表可视化 - 链表操作可视化学习平台

视频链接

左老师视频链接