两两交换链表节点

一个音乐播放列表：每两首歌需要互换位置（1→2→3→4变成2→1→4→3）。如何在链表中高效实现这种操作？

核心问题解析

两两交换链表节点看似简单，实则暗藏三个技术难点：

指针操作精度：四根指针需同步更新（prev→a→b→next）
边界处理：奇数链表最后一个节点保持原位
头节点丢失：交换后原链表头部会改变

迭代 vs 递归

方案一：迭代法（首选）

javascript 复制代码

// 使用虚拟头节点统一操作
const swapPairs = head => {
  // 虚拟头节点：解决头节点丢失问题
  const dummy = new ListNode(0, head); 
  let prev = dummy;

  // 关键条件：确保存在两个可交换节点
  while (prev.next && prev.next.next) {
    const node1 = prev.next;
    const node2 = node1.next;
    const nextHead = node2.next; // 缓存后续节点

    // 三指针重定向（四步操作）
    prev.next = node2; // Step1: 虚头指向node2
    node2.next = node1; // Step2: node2指向node1
    node1.next = nextHead; // Step3: node1接后续节点

    prev = node1; // Step4: 移动prev到下组前驱
  }

  return dummy.next; // 返回新链表头
};

操作分解：

graph LR A[prev] --> B[node1] --> C[node2] --> D[nextHead]

交换后:

graph LR A[prev] --> C[node2] --> B[node1] --> D[nextHead]

四步指针操作解析：

prev.next = node2：将前驱节点指向第二个节点
node2.next = node1：反转第二节点指向第一节点
node1.next = nextHead：连接后续链表
prev = node1：前驱移动到下一组的前一个节点

迭代过程示例（输入: 1→2→3→4）：

轮次	prev	node1	node2	nextHead	当前链表
初始	dummy	1	2	3	dummy→1→2→3→4
1	dummy	1	2	3	dummy→2→1→3→4
2	1	3	4	null	dummy→2→1→4→3

方案二：递归法（简洁但需谨慎）

javascript 复制代码

const swapPairs = head => {
  // 递归终止条件：单节点或无节点
  if (!head || !head.next) return head;
  
  const node1 = head;
  const node2 = head.next;

  // 递归魔法：处理后续节点
  node1.next = swapPairs(node2.next); 
  
  // 交换当前节点
  node2.next = node1; 

  return node2; // node2成为新头
};

递归法对比迭代法：

特性	迭代法	递归法
空间复杂度	O(1) 常量空间	O(n) 递归栈空间
可读性	指针操作稍复杂	代码简洁优雅
适用场景	长链表/系统资源受限环境	短链表/面试快速实现
工程实践	生产环境首选	需警惕栈溢出风险

边界陷阱与解决方案

单节点链表处理

javascript 复制代码

if (!head || !head.next) return head; // 终止条件必须前置

奇数链表末尾节点处理

迭代法中while (prev.next && prev.next.next)确保只操作成对节点
指针丢失问题

必须临时变量缓存nextHead = node2.next

性能优化实战：百万级链表处理

当处理超长链表时，迭代法优势明显：

javascript 复制代码

// 迭代法内存优化版
function swapBigList(head) {
  const dummy = new ListNode(0, head);
  let prev = dummy;
  
  // 批量化处理：每次处理100个节点
  while (prev.next) {
    let batchTail = prev;
    // 定位本批末尾
    for (let i = 0; i < 100 && batchTail.next; i++) {
      batchTail = batchTail.next;
    }
    
    // 批量交换本组节点
    while (prev.next !== batchTail) {
      if (prev.next.next === batchTail) {
        // 处理组内最后两个节点
        const node1 = prev.next;
        const node2 = batchTail;
        [prev.next, node2.next, node1.next] = [node2, node1, batchTail.next];
        break;
      }
      // 标准交换操作...
    }
    prev = batchTail;
  }
  return dummy.next;
}

优化策略：

批量分组减少指针更新次数
尾部特殊处理避免冗余操作
使用数组解构加速指针交换（[a,b] = [b,a]）

前端应用场景

DOM元素重排序

javascript 复制代码

// 虚拟DOM树中交换相邻组件位置
function swapComponents(componentList) {
  let head = createLinkedList(componentList);
  head = swapPairs(head);
  reRenderByList(head);
}

数据流处理

日志流中成对加密敏感数据
游戏开发

交换相邻地图格子的状态信息

终极选择指南

小型数据结构 → 递归法（代码简洁）
生产环境长链表 → 迭代法（安全高效）
内存敏感场景 → 分组迭代法（平衡资源）

重要原则：在处理浏览器DOM树等大型链式结构时，总是优先选择迭代法以避免调用栈溢出崩溃页面。

使用可视化工具逐步调试指针变化：
👉 链表交换动画演示工具