LeetCode OJ：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.

如题实例所示，需要成对的交换节点，这里我用到了两个帮助节点，一个记下起点的前面位置，一个作为每一对prev的前面一个节点使用，思路比较简单，就是交换之后再向后面移动两个节点就可以了，代码如下所示：

 /**
  * 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) return NULL;
         if(!head->next) return head;
           ListNode * helper1 = new ListNode(INT_MIN);
           ListNode * helper2 = new ListNode(INT_MIN);
           helper1->next = head;
           helper2->next = head->next;// 先记录下首节点的位置,供函数返回的时候使用
           ListNode * prev = head;
           ListNode * curr = head->next;
           while(prev){
               if(curr){
                   ListNode * tmpNode = curr->next;
                   curr->next = prev;
                   helper1->next = curr;
                   prev->next = tmpNode;
                   helper1 = prev;
                   if(prev->next && prev->next->next){
                       prev = prev->next;
                       curr = prev->next;
                   }else
                       break;
               }else
                   break;

           }
           return helper2->next;
     }
 };