[leetcode 24] 两两交换链表中的节点(swap-nodes-in-pairs)

 

题目描述：

https://leetcode.cn/problems/swap-nodes-in-pairs/

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

示例 1：

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

示例 2：

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

示例 3：

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

 

提示：

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

解题思路：

 图片来源【灵茶山艾府】

node1和node3的含义：node1指的是当前要交换的两个节点中的第一个，node3指当前要交换两个节点的后一个节点。

代码(C++/Python)：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        // 对象在栈上分配内存，不需要手动释放内存
        // 指针在堆上分配内存，需要手动释放内存，避免内存泄漏
        ListNode dummy(0,head); //初始化列表的形式创建对象，作为哨兵节点
        auto node0=&dummy;
        auto node1=head;

        // 至少有两个节点
        while(node1 && node1->next){
            auto node2=node1->next;
            auto node3=node2->next;

            node0->next=node2;//0->2
            node2->next=node1;//2->1
            node1->next=node3;//3->1

            // 下一轮交换，
            node0=node1; //0是1
            node1=node3; //1是3
        }
        
        return dummy.next;
    }
};

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:

        node0=dummy=ListNode(next=head)
        node1=head

        while node1 and node1.next:
            node2=node1.next
            node3=node2.next

            node0.next=node2
            node2.next=node1
            node1.next=node3

            node0=node1
            node1=node3
        
        return dummy.next

 

思路总结：

1. 引入哨兵节点：dummy对象作为哨兵节点，简化对链表头结点的处理逻辑
2. 交换与遍历：使用多个指针遍历链表，在每次循环中找到待交换的两个结点及其后续结点，进行节点交换，然后更新指针，准备下一轮的交换
3. 返回结果：循环结束，dummy.next作为新链表的头结点