Swap nodes in pairs

https://leetcode.com/problems/swap-nodes-in-pairs/

 
 ------------------------------------RECURSIVE SOLUTION----------------------------------------
class Solution {
public:
    
    ListNode* swapPairs(ListNode* head) {
    
    
        if(head == NULL)return NULL;
        if(head -> next == NULL){
            return head;
        }
        
        //  1 -> 2 -> 3 -> 4
        // After swapping  =  2 -> 1 -> 4 -> 3
        
        
        // 1. Think.... what will be the newhead after the swapping nodes in pairs ?
        // --> Assign newhead pointer
        // 2. Now , What should we do - either swap the current pair or recurse first ?
        // --> If we swap the current pair (1 -> 2 ==> 2 -> 1) then we will never be able to traverse furthur
        //     Therefore, we will recurse first.
        //     Expectation - we will return newhead after swapping nodes in pairs
        //     faith -  we will assume that , we'll get head with all pairs are swapped except the current one.
        //     faith to expectation - we just swap the current pair and return the newhead;
        
        ListNode* newhead = head -> next;
        head -> next = swapPairs(newhead -> next);   
        newhead -> next = head;
        return newhead;
       
        
        
    }
};


--------------------- Think of iterative sol ----------------------------------

/*
       #---->@---->@---->@---->@---->@---->@
                   ^     ^
                   pre   cur

      1. pre->next = cur->next
                    __________
                   /          \
       #---->@---->@     @---->@---->@---->@
                   ^     ^
                   pre   cur

      2. pre = pre->next
                    __________
                   /          \
      #---->@---->@      @---->@---->@---->@
                         ^     ^
                         cur   pre

      3. cur->next = pre->next
                    __________
                   /          \
       #---->@---->@     @     @---->@---->@
                          \_________/
                         ^     ^
                         cur   pre

      4. pre->next = cur
                   __________
                  /          \
      #---->@---->@     @<----@     @---->@
                         \_________/
                        ^     ^
                        cur   pre
    
      5. pre = cur; cur = cur->next
                   __________
                  /          \
      #---->@---->@     @<----@     @---->@
                         \_________/
                        ^           ^
                        pre         cur
                        
                        
                        
     ------------------- code ------------------
 
 
class Solution {
public:
    
    ListNode* swapPairs(ListNode* head) {
    
    
        if(head == NULL)return NULL;
        if(head -> next == NULL){
            return head;
        }
        
        
        ListNode* curr = head;
        ListNode* temp = new ListNode(0);
        temp -> next= head;
        ListNode* prev = temp;
        
        while(curr and curr -> next){
            prev -> next = curr -> next;
            prev = prev -> next;
            curr -> next = prev -> next;
            prev -> next = curr;
            prev= curr;
            curr = curr -> next;
        }
        
    return temp -> next;    
       
        
        
    }
};