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

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

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

    方法1：一次遍历每一个节点并交换前后两个节点，而且交换以后需要将链表连起来，防止断裂。

    1. /**
    2.  * Definition for singly-linked list.
    3.  * struct ListNode {
    4.  *     int val;
    5.  *     ListNode *next;
    6.  *     ListNode(int x) : val(x), next(NULL) {}
    7.  * };
    8.  */
    10. class Solution {
    11. public:
    12.     // 方法1：遍历+判断个数的奇偶性
    13.     ListNode* swapPairs(ListNode* head) 
    14.     {
    16.         if (head == nullptr || head->next == nullptr)
    17.             return head;
    18.         ListNode * new_head;
    19.         new_head = head->next;
    20.         ListNode * curr = head;
    21.         ListNode * nxt = curr->next;
    23.         while(curr != nullptr && nxt != nullptr)
    24.         {
    25.             ListNode * tmp = nxt->next;
    26.             nxt->next = curr;                      // nxt指向前一个结点
    28.             // tmp与tmp->next不为空, 保证链表不断裂，
    29.             // curr->next指向tmp->next  
    30.             if (tmp != nullptr && tmp->next != nullptr)
    31.             {
    32.                 curr->next = tmp->next;      
    33.             }
    34.             else
    35.             {
    36.             // tmp为空或tmp->next为空，curr->next指向tmp即可
    37.                 curr->next = tmp;            
    38.             }
    40.             // 更新curr为tmp
    41.             curr = tmp;
    42.             if (tmp != nullptr)
    43.                 nxt = tmp->next;
    44.         }
    45.         return new_head;
    46.     }
    47. }

    方法2：方法1中由于设置的交换节点不够好，导致需要判断剩余链表节点的奇偶性(尾部节点是否存在？？？) 通过改进节点设置，可以优化程序，是程序变得简洁。

    // 方法2：遍历
class Solution
{
    ListNode* swapPairs(ListNode* head) {
        // 新建一个结点指向头节点；
        ListNode* p = new ListNode(0);
        p->next = head;
        // curr节点指针指向p节点，用于指向后面相邻结点交换以后的子链
        ListNode* curr = p;
        while(head != NULL && head->next != NULL){
            ListNode* firstNode = head;
            ListNode* secondNode = head->next;

            // 交换第一个节点和第二个节点
            curr->next = secondNode;
            firstNode->next = secondNode->next;
            secondNode->next = firstNode;

            // 更新curr节点指向子链表的最后一个节点，head指向还未交换的子链表的头节点；
            curr = firstNode;
            head = firstNode->next;
        }
        return p->next;
    }
 }

    递归方法

      class Solution
  {
    // 1、首先定义一个函数swapPairs(), 输入是一个head作为头结点的链表，最后的输出是相邻节点反转以后的链表头指针；
    // 2、首先交换head和head->next两个节点，然后采用swapPairs(head->next->next)处理后面的剩余的链表，因为处理方式是相同的，所以递归；
    // 3、将head与head->next交换后的链表指向->swapPairs(head->next->next);
    // 递归
    ListNode* swapPairs(ListNode* head){
        // 如果为空链表或只有一个节点，则直接返回
        if (head == NULL || head->next == NULL)
            return head;
        // p用来指向最后结果的链表头
        ListNode* p = new ListNode(0);
        p->next = head;
        // curr指向交换完相邻节点的子链表的最后一个节点；
        ListNode* curr = p;
        // firstNode与secondNode便于区分
        ListNode* firstNode = head;
        ListNode* secondNode = head->next;
        // 交换secondNode与firstNode指向
        curr->next = secondNode;
        firstNode->next = secondNode->next;
        secondNode->next = firstNode;

        curr = firstNode;
        head = firstNode->next;
        curr->next = swapPairs(head);

        return p->next;
    }
};

    欢迎交流，批评指正！