[leet code] 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.

=============

Analysis:

After analyzing example of 1->2->3->4->5->6, I decided to use recursive approach to solve the problem.  The basic idea is to swap a single pair of node in one recursive call, then pass the 1st node of next pair of nodes as the parameter for next recursive call.  However, I did not get the answer after several times of try.  

Accordingly, I search the solutions that are available in the Internet, and all of them are using iteration approach, which can be summarized as below:

1. Create a fake header

2. Utilize 2 newly created list node "pre" - previous node and "cur" - current node as 2 pointer to implement the swap logic and examine nodes one by one.

Iteration approach

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null) return head;
        //creat fake header node
        ListNode fake = new ListNode(0);
        fake.next = head;
        
        ListNode pre = fake;
        ListNode cur = head;
        
        while(cur != null && cur.next != null){
            pre.next = cur.next;
            cur.next = cur.next.next;
            pre.next.next = cur;

            pre = cur;
            cur = pre.next;
        }
        
        return fake.next;
    }
}

After solving the problem by iteration approach, I came back to my original solution, i.e. recursive approach, and found some "node lost" issue.  

Key point: In linked list, nodes can be found based only on the links (implemented by .next).  While we are dealing with link list problem, always keep in mind to ensure all the nodes can be traced by the link.  If we change the link (.next), we should ensure no node lost.

Recursive approach:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) return head;
        
        return swapSinglePair(head);
    }
    
    public ListNode swapSinglePair(ListNode node){
        if (node == null || node.next == null) return node;
        // stor next node for recursive call
        ListNode next = node.next.next;
        
        // swap node pair
        ListNode temp = node;
        node = node.next;
        node.next = temp;
        
        // swap next pair of nodes
        node.next.next = swapSinglePair(next);
        
        // return header
        return node;
    }
}