力扣24. 两两交换链表中的节点

题目描述

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

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

示例

输入：head = [1,2,3,4]
输出：[2,1,4,3]

输入：head = []
输出：[]

输入：head = [1]
输出：[1]

解法一：迭代法

思路：

使用迭代的方法解决，定义一个虚拟节点 dummy，其 next 指向头节点 head。然后使用循环将链表中相邻的两个节点进行交换，并更新指针位置，重复执行直到全部节点都已经被遍历。

具体来说，定义两个指针 prev 和 curr，分别记录交换节点的前一个节点和当前节点。通过更新它们的 next 指针完成相邻节点的交换，然后将它们移动到下一组相邻节点。

时间复杂度为 $O(n)$，其中 $n$ 是链表的长度。遍历链表一次，对于每组相邻节点需要交换它们的指针位置，因此时间复杂度为 $O(n)$。空间复杂度为 $O(1)$，使用常量级别的额外空间。

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(0); // 定义一个虚拟节点
        dummy.next = head;
        ListNode prev = dummy;

        while (head != null && head.next != null) {
            ListNode firstNode = head;
            ListNode secondNode = head.next;

            prev.next = secondNode;
            firstNode.next = secondNode.next;
            secondNode.next = firstNode;

            prev = firstNode;
            head = firstNode.next;
        }

        return dummy.next;
    }
}

解法二：递归法

思路：

使用递归的方法解决，将问题转化成单个单元素相邻节点的交换，然后递归解决所有的相邻节点问题。

具体来说，定义递归函数 swapPairs(head)，它会返回已经完成相邻节点交换的子链表的头节点，并在交换完成后更新节点的指针位置。

递归终止条件是链表中只剩下一个节点或不剩下节点，此时直接返回该节点。否则，对当前两个相邻节点 head 和 head.next，先通过递归调用 swapPairs(head.next.next) 完成后续相邻节点的交换，返回已经交换的子链表的头节点 newHead，然后将当前两个节点交换指针位置，让前一个指向后一个，后一个指向前一个，最后返回交换后的子链表的头节点 newHead。

时间复杂度为 $O(n)$，其中 $n$ 是链表的长度。递归调用的深度为链表中相邻节点的对数，因此时间复杂度为 $O(n)$。空间复杂度为 $O(n)$，递归调用会使用隐式栈空间，栈空间的大小取决于递归调用的深度，因此空间复杂度为 $O(n)$。

class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }

        ListNode newHead = swapPairs(head.next.next);
        ListNode firstNode = head;
        ListNode secondNode = head.next;
        firstNode.next = newHead;
        secondNode.next = firstNode;
        return secondNode;
    }
}