循环双向链表相邻节点交换及代码逻辑排查求助

moveCard逻辑分析 #

逻辑意图是对的：通过p次相邻节点交换，将目标节点c向后移动p个位置。但该逻辑完全依赖swap方法能正确处理相邻节点交换，一旦swap存在bug，整个移动逻辑会直接失效。

swap方法的核心bug #

你的swap方法在处理相邻节点时会出现指针自环，直接破坏链表结构：

1. 假设Card1.next == Card2（相邻），执行Card1.prev = Card2.prev时，Card2.prev就是Card1，所以Card1.prev = Card1。
2. 接着执行Card1.prev.next = Card1，等价于Card1.next = Card1，形成自环，后续链表遍历会陷入死循环。
3. 循环链表中不存在next或prev为null的节点，代码里的if (xxx != null)判断完全冗余，还可能跳过必要的指针更新。

排查调试步骤 #

1. 最小场景复现：构造仅含3个节点的循环链表（如A→B→C→A），手动调用swap(B, C)，单步跟踪每一个指针的变化，重点看：
   • 交换后B和C的prev/next是否正确
   • 链表是否还保持闭环（head.prev == tail、tail.next == head）
2. 修复swap的相邻节点处理：
   • 先保存所有涉及的指针（Card1.prev、Card1.next、Card2.prev、Card2.next），避免中间修改导致的指针混乱
   • 增加判断：如果Card1和Card2是相邻节点（Card1.next == Card2或Card2.next == Card1），单独处理指针关联，避免自环
3. 验证moveCard逻辑：在swap修复后，用3节点链表测试moveCard(B, 1)，检查B是否移动到C的位置，链表结构是否正确；再测试moveCard(B, 2)，检查B是否回到原位置（循环链表特性）。

优化后的swap参考逻辑 #

private void swap(Card Card1, Card Card2) {
    if (Card1 == Card2) return; // 无需交换
    
    Card c1Prev = Card1.prev;
    Card c1Next = Card1.next;
    Card c2Prev = Card2.prev;
    Card c2Next = Card2.next;

    // 更新head和tail
    if (head == Card1) {
        head = Card2;
    } else if (head == Card2) {
        head = Card1;
    }
    if (tail == Card1) {
        tail = Card2;
    } else if (tail == Card2) {
        tail = Card1;
    }

    // 处理Card1的前驱和后继
    if (c1Prev != Card2) {
        c1Prev.next = Card2;
    }
    Card2.prev = c1Prev;

    // 处理Card2的前驱和后继
    if (c2Prev != Card1) {
        c2Prev.next = Card1;
    }
    Card1.prev = c2Prev;

    // 处理Card1的后继
    if (c1Next != Card2) {
        c1Next.prev = Card1;
    }
    Card2.next = c1Next;

    // 处理Card2的后继
    if (c2Next != Card1) {
        c2Next.prev = Card2;
    }
    Card1.next = c2Next;

    // 确保循环闭环
    head.prev = tail;
    tail.next = head;
}

内容的提问来源于stack exchange，提问作者Flink