两两交换链表中的节点（递归，迭代，栈）

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例:

给定 1->2->3->4, 你应该返回 2->1->4->3.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/swap-nodes-in-pairs
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

递归：

/**
 * 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||!head->next){
            return head;
        }
        ListNode*tmp = head->next;
        head->next = swapPairs(tmp->next);
        tmp->next=head;
        return tmp;
    }
};

迭代：

/**
 * 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||!head->next){
            return head;
        }
        ListNode*tmp=NULL;
        ListNode*a=head;
        ListNode*b=head->next;
        a->next=b->next;
        b->next=a;
        head=b;
        while(a->next!=NULL){
            tmp= a;
            a= a->next;
            if(a->next==nullptr){
                break;
            }
            b= a->next;
            tmp->next=b;
            a->next=b->next;
            b->next=a;
        }
        return head;

    }
};

运用数据结构栈

/**
 * 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||!head->next){
            return head;
        }
        stack<ListNode*>mystack;
        ListNode* p = new ListNode(0);
        ListNode*tmp=head;
        head = p;
        ListNode*q;
        while(tmp&&tmp->next){
            mystack.push(tmp);
            mystack.push(tmp->next);
            tmp = tmp->next->next;
            q=mystack.top();
            p->next=q;
            p=p->next;
            mystack.pop();
            q=mystack.top();
            p->next=q;
            p=p->next;
            mystack.pop();
        }
        if(tmp){
            p->next = tmp;
        }else{
            p->next = NULL;
        }
        return head->next;
    }
};