LeetCode_No.24 两两交换链表中的结点

题目：

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

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

示例:

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

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

方法一：迭代法：

需要借助一个额外结点。
对于比较复杂的链表处理，可以往额外链表结点上考虑。

时间复杂度： O(n)
空间复杂度： O(1)

执行用时：
0 ms, 在所有 C++ 提交中击败了100.00%的用户

内存消耗：
6.5 MB, 在所有 C++ 提交中击败了15.13%的用户

/**
 * 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 == NULL || head->next == NULL) return head;
        ListNode* preHead = new ListNode;
        preHead->next = head;
        ListNode* tmp = preHead;

        while(preHead->next != NULL && preHead->next->next != NULL) {
            ListNode* first = preHead->next;
            ListNode* second = preHead->next->next;

            preHead->next = second;
            ListNode* tmp = second->next;
            second->next = first;
            first->next = tmp;
            preHead = first;
        }
        return tmp->next;
    }
};

方法二：递归法：

这种循环某种重复操作的问题，一般都是可以使用递归法解决的。
递归解法的关键，就是“找出最小重复子单元”，
然后代码只需解决一个重复子单元的流程即可，其余的循环交给递归。

时间复杂度： O(N)
空间复杂度： O(N) //递归需要借助栈

/**
 * 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 == NULL || head->next == NULL) return head; //terminator
        ListNode* p = swapPairs(head->next->next); //drill down

        ListNode* first = head;
        ListNode* second = head->next;
        first->next = p;
        second->next = first;

        return second;
    }
};