【Leetcode】【Medium】Swap Nodes in Pairs

Given a linked list, swap every two adjacent nodes and return its head.

For example,
Given

1->2->3->4

, you should return the list as

2->1->4->3

.

Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.

解题思路：

传统的链表操作题，需要注意如果结点不是偶数，最后一个结点不需要交换，放在队尾。

先条件：head不为空；head至少包含两个结点；

后条件：返回指向新链表第一个结点的指针；原链表结点全部加入新链表中，并且偶数对结点两两互换；新旧链表的结点数一致。

不变式：1、新建一个newhead指针，newhead->next永远指向新链表的头部；

　　　　2、新建一个newlist指针，newlist永远指向新链表的最后一个结点；

　　　　3、newlist->next始终为NULL；

　　　　4、head指针永远指向还未被操作的旧链表第一个结点；

　　　　5、新链表上的结点数加上旧链表剩余的结点数之和，应该和原链表结点数一致；

当head为空时，循环结束，每次循环：

　　　　1、将head中的结点按对取出~交换~插入newlist末端

　　　　2、若head只剩一个结点不够一对，则直接插入newlist末端；

解题步骤：

1、新建preHead结点，新建newlist指针；

2、按照不定式分析，开始循环，循环结束标志为head为空：

　　（1）如果当前head只剩一个结点，则将其插入newlist后，并结束循环；

　　（2）取出待操作的两个结点，head后移两位；

　　（3）将这两个结点反转插入newlist中

3、释放preHead，返回newlist；

代码1：

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
/*
if (head == NULL || head->next == NULL)
return head;
*/
ListNode* newhead = new ListNode(0);
ListNode* newlist = newhead;
ListNode* preNode = NULL;

while (head != NULL) {
if (head->next == NULL) {
newlist->next = head;
break;
}
preNode = head;
head = head->next->next;
preNode->next->next = preNode;
newlist->next = preNode->next;
newlist = preNode;
newlist->next = NULL;
}

head = newhead->next;
delete newhead;
return head;
}
};

代码2，使用二维指针：

基本逻辑实现：

ListNode **p = &head;
while (*p && (*p)->next) {
// n表示待交换的两个结点中，后一个结点
ListNode* n = (*p)->next;
(*p)->next = n->next;
n->next = *p;
p = &(*p)->next;
}

由于二维指针p一直在操作当前需要交换的结点，不断向后迭代，而head指针此时指向的是链表中第二个结点（前两个交换）；

因此上述代码唯一的问题是，没有指针指向头结点，无法返回...

所以我们希望在第一轮交换时，将head结点重新指向交换后的第一个结点。观察到第一轮交换时，*p其实就代表head，操作*p的指向，就是操作head的指向。

所以，最终代码为：

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* swapPairs(ListNode *head) {
ListNode **p = &head;

while (*p && (*p)->next) {
ListNode* n = (*p)->next;
(*p)->next = n->next;
n->next = *p;
*p = n;
p = &(*p)->next->next;
}

return head;
}
};