LeetCode题解——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.

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

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

            (*p)->next = t->next;
            t->next = *p;
            *p = t;

            p = &(*p)->next->next;
        }

        return head;
    }
};*/

//method 2 4ms
/*class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        
       if(head==NULL||head->next==NULL) return head;
       
       ListNode* newhd = new ListNode(0);
       newhd->next = head;
       
       ListNode* p1 = newhd;
       ListNode* p2 = head;
       
       while(p2 && p2->next)
       {
           p1->next = p1->next->next;
           p2->next = p2->next->next;
           p1->next->next = p2;
           
           p1 = p2;
           p2 = p2->next;
       }
        return newhd->next;
    }
};*/

//method 3 4ms：递归
class Solution {
public:
    ListNode *swapPairs(ListNode *head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode *newhead = new ListNode(0);
        newhead->next = head->next;
        head->next = swapPairs(head->next->next);
        newhead->next->next = head;
   
        return newhead->next;
    }
};