【两次过】Lintcode 451. 两两交换链表中的节点

本文介绍了一种链表操作技巧——两两交换节点的方法。提供了两种解决方案：一是通过交换节点值实现，适用于允许修改节点值的情况；二是通过实际交换节点来解决，适用于不能更改节点值的情形。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给一个链表，两两交换其中的节点，然后返回交换后的链表。

样例

给出 1->2->3->4, 你应该返回的链表是 2->1->4->3。

挑战

你的算法只能使用常数的额外空间，并且不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

解题思路1：

最简单的做法是不进行实际节点交换，仅仅交换它们的值即可。

/**
 * Definition of singly-linked-list:
 * class ListNode {
 * public:
 *     int val;
 *     ListNode *next;
 *     ListNode(int val) {
 *        this->val = val;
 *        this->next = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param head: a ListNode
     * @return: a ListNode
     */
    ListNode * swapPairs(ListNode * head) 
    {
        // write your code here
        ListNode * p = head;
        
        while(p != NULL && p->next != NULL)
        {
            int tmp = p->val;
            p->val = p->next->val;
            p->next->val = tmp;
            
            p = p->next->next;
        }
        
        return head;
    }
};

解题思路2：

挑战不让交换值，这里就交换节点。首先在head节点前添加一个头节点dummy方便处理，然后遍历此链表两两反转即可。

/**
 * Definition for ListNode
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */

public class Solution {
    /**
     * @param head: a ListNode
     * @return: a ListNode
     */
    public ListNode swapPairs(ListNode head) {
        // write your code here
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode pre = dummy;
        
        while(pre.next != null && pre.next.next != null){
            ListNode a = pre.next;
            ListNode b = pre.next.next;
            
            //交换a,b指向的两节点
            a.next = b.next;
            b.next = a;
            pre.next = b;
            
            pre = a;
        }
        
        return dummy.next;
    }
}