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.

思路：
1.两两读入，转换指针方向。
2.考虑尾节点,看是在first，还是在second.

LinkNode *swapNodeInPairs(LinkNode *head)
{
	//有效性判断
	if(NULL == head || NULL == head->next)
		return head;
	LinkNode *dummy = new LinkNode(-1);
	dummy->next = head;
	LinkNode *first,*second,*tmp,*pre;
	pre = dummy;//tmp指向first的前驱
	first = head;
	second = first->next;

	do
	{
		if(second->next)
			tmp = second->next;
		else
			tmp = NULL;
		second->next = first;
		pre->next = second;		

		//找下两个节点
		if(tmp != NULL)
		{	
			first->next = tmp;
			pre = first;
			first = tmp;
			if(tmp->next != NULL)	
				second = tmp->next;
			else
			{
				first->next = NULL;
				second = NULL;
			}
		}
		else
		{
			pre = first;
			pre->next = NULL;
			first = NULL;
		}
	}while(first&&second);
	head = dummy->next;
	delete dummy;
	return head;
}

改进。

方法1：把每两个作为一个group。

1)前驱节点指向A2, 

2)A1指向下一个group,

3)A2指向A1

4)Pre挪到A1（作为下一个的pre）

方法2：

如果可以交换数值，不用交换节点，就更简单了。但是题目不允许。

#include <iostream>
using namespace std;

struct LinkNode{
	int data;
	LinkNode *next;
	LinkNode(int x):data(x),next(NULL){}
};

class Solution{
public:
	LinkNode *swapInPairs(LinkNode *head)
	{
		LinkNode *dummy = new LinkNode(-1);
		dummy->next = head;
		LinkNode *pre = dummy;

		while(pre->next!=NULL && pre->next->next!=NULL)
		{
			LinkNode *cur = pre->next;
			pre->next = cur->next;   //pre链接上A2
			cur->next=pre->next->next;//A1链接上后面的group
			pre->next->next=cur;//A2链接A1
			pre=cur;//pre指向A1，作为下一个group的前驱
		}

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

	//如果可以交换数值，不用交换节点，就更简单了。但是题目不允许。
	LinkNode *swapInPairs2(LinkNode *head)
	{
		LinkNode *p = head;
		while(p&&p->next)
		{
			swap(p->data,p->next->data);
			p=p->next->next;
		}
		return head;
	}

	//创建只有空链表，返回一个dummy节点
	LinkNode * createLink()
	{
		LinkNode *dummy = new LinkNode(-1);
		return dummy;
	}

	LinkNode * initLink(LinkNode *dummy)
	{
		//用一个数组初始化链表
		int array[] = {1,2,3,4,5,6};

		LinkNode *tmp,*head;
		tmp = dummy;
		//使用的是尾插入法
		for(int i=0;i<sizeof(array)/sizeof(int);i++)
		{
			LinkNode *p = new LinkNode(array[i]);
			tmp->next=p;
			tmp = tmp->next;
		}
		head = dummy->next;
		delete dummy;
		return head;	
	}

	//显示链表
	void showList(LinkNode *head)
	{
		while(head)
		{
			printf("%d ",head->data);
			head = head->next;
		}
		printf("\n");
		return;
	}

	//摧毁链表
	void desroyList(LinkNode *head)
	{
		while(head)
		{
			LinkNode *tmp = head->next;
			delete head;
			head = tmp;		
		}
		return;
	}
};

void main()
{
	Solution sol;
	//创建一个空链表
	LinkNode *dummy = sol.createLink();
	//对链表初始化，返回head
	LinkNode *head = sol.initLink(dummy);
	//显示链表
	sol.showList(head);
	//swap
	head = sol.swapInPairs(head);
	//显示链表
	sol.showList(head);
	sol.desroyList(head);
}