leecode 解题总结：24 Swap Nodes in Pairs

#include <iostream>
#include <stdio.h>
#include <vector>

using namespace std;
/*
问题:
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.

分析:交换链表中相邻两个结点，并且不是结点中的值交换。而且只能使用常量空间。
暴力破解：将链表从后向前每两个结点分成一组，记录每一组中两个结点的前驱和后继。
举例:
1->2->3->4->5->6
当前组的前驱将连接后一组的前驱
当前组的后继将会被连接在后一组的前驱

另外一种解法：直接对每一组内部结点先交换，重新确定每一组内部的连接指向，组外的连接指向则直接处理即可

需要注意的是：链表中第二个元素(如果有的话，会变成链表头部)

输入:
6(链表元素个数)
1 2 3 4 5 6

5
1 2 3 4 5

1
1
输出:
2 1 4 3 6 5
2 1 4 3 5
1

关键:
1 直接对每一组内部结点先交换，重新确定每一组内部的连接指向，组外的连接指向则直接处理即可
注意：设置最后一个结点指向为空
*/

struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
//交换结点
ListNode* swapPairs(ListNode* head) {
//如果链表为空，直接返回为空
if(NULL == head)
{
return NULL;
}
//如果链表只有一个元素，直接返回
if(NULL == head->next)
{
return head;
}

//下面需要将链表分成每两个结点一组
ListNode* node = head;
int count = 0;
vector< pair<ListNode* , ListNode*> > pairs;
while(node)
{
//刚好累计两个结点，加入元素中
pair<ListNode* , ListNode*> myPair;
myPair.first = node;
//如果第二个结点不空
if(NULL != node->next)
{
myPair.second = node->next;
pairs.push_back(myPair);
}
else
{
myPair.second = NULL;
pairs.push_back(myPair);
break;
}
//遍历第i + 2个结点
node = node->next->next;
}
//分组结束后，从后向前，先保存当前组组上一组的前驱pre和下一组的后继next，当前组的前驱指向下一组的后继,上一组的前驱指向当前组的后继
int size = pairs.size();
for(int i = 0 ; i < size ; i++)
{
if(i != size - 1)
{
pairs.at(i).second->next =  pairs.at(i).first;
ListNode* tempNode = pairs.at(i).first;
pairs.at(i).first = pairs.at(i).second;
pairs.at(i).second = tempNode;
}
else
{
//如果最后一组结点中第二个结点为空，直接跳过
if(NULL == pairs.at(i).second)
{
pairs.at(i).first->next = NULL;//设定最后一个结点指向空
continue;
}
else
{
pairs.at(i).second->next =  pairs.at(i).first;
ListNode* tempNode = pairs.at(i).first;
pairs.at(i).first = pairs.at(i).second;
pairs.at(i).second = tempNode;
pairs.at(i).second->next = NULL;
}
}
}
//每一组内部指向已经全部结束，下面进行组外连接：上一组的第二个结点连接到下一组的第一个结点即可
for(int i = 0 ; i < size - 1 ; i++)
{
pairs.at(i).second->next = pairs.at(i+1).first;
}
return pairs.at(0).first;
}
};

ListNode* buildList(vector<int>& datas)
{
if(datas.empty())
{
return NULL;
}
int size = datas.size();
ListNode* head = NULL;
ListNode* tail = NULL;
for(int i = 0 ; i < size ; i++)
{
if(i)
{
ListNode* node = new ListNode(datas.at(i));
tail->next = node;
tail = node;
}
else
{
head = new ListNode(datas.at(i));
tail = head;
}
}
return head;
}

void releaseList(ListNode* head)
{
while(head)
{
ListNode* node = head->next;
delete head;
head = node;
}
}

void print(ListNode* head)
{
if(NULL == head)
{
cout << "No result" << endl;
return;
}
ListNode* tempHead = head;
while(tempHead)
{
cout << tempHead->val << " ";
tempHead = tempHead->next;
}
cout << endl;
}

void process()
{
int nodeNum;
vector<int> datas;
int value;
Solution solution;
while(cin >> nodeNum)
{
datas.clear();
for(int i = 0 ; i < nodeNum ; i++)
{
cin >> value;
datas.push_back(value);
}
ListNode* head = buildList(datas);
ListNode* newHead = solution.swapPairs(head);
print(newHead);
releaseList(newHead);
}
}

int main(int argc , char* argv[])
{
process();
getchar();
return 0;
}

/*
if(i != size - 1)
{
}
//最后一组元素只需要获取前一组的前驱进行指向
else
{
//如果当前组第二个结点为空，则其本身无需交换,都无需修改
ListNode* secondNode = pairs.at(i).second;//当前组第一个结点现在要被其第二个结点指向
if(NULL == secondNode)
{
continue;
}
ListNode* firstNode = pairs.at(i).first;
ListNode* nextNode = pairs.at(i-1).first;

node->next = nextNode;
}
*/