LeetCode-24. 两两交换链表中的节点

题目来源

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

题目详情

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 链表中节点的数目在范围 [0, 100] 内
• 0 <= Node.val <= 100

题解分析

解法一：迭代法

1. 与普通的链表题目类似，本题可以使用迭代法来翻转相邻的两个节点。与之类似的题目有：25. K 个一组翻转链表，92. 反转链表 II。
2. 本题在迭代时候的关键是现需要设立一个虚拟头节点，因为需要固定头节点，否则在翻转的过程中，head节点指向的节点可能不是翻转后的第一个节点。
3. 此外，本题还有一个坑点就是只有当存在偶数节点时需要翻转相邻的节点，对于奇数节点，其最后的节点不需要改变。因此，需要转移迭代的边界条件。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null){
            return null;
        }
        ListNode dumy = new ListNode(-1);
        dumy.next = head;
        ListNode cur = dumy;
        while(cur.next != null && cur.next.next != null){
            ListNode node1 = cur.next, node2 = cur.next.next;
            node1.next = node2.next;
            node2.next = node1;

            cur.next = node2;// 修改前向指针
            
            cur = node1;

        }
        return dumy.next;
    }
}

解法二：递归法

1. 本题中还有一个不太直观的解法，那就是使用递归法，因为本题的核心可以看成是一个子问题，即先翻转前面的节点，再将翻转后的节点next指针指向节点后续链表。
2. 需要注意的是，本题的递归终点是遇到链表尾或者剩余链表中只有一个节点，这时候无法进行翻转，需要返回null或者单个节点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null){// 边界条件
            return head;
        }
        ListNode newNode = head.next;
        head.next = swapPairs(newNode.next);
        newNode.next = head;
        return newNode;
    }
}

结果展示