力扣第24题 两两交换链表中的节点 c++精讲 。

题目

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

中等

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

思路和解题方法

1. 创建一个虚拟头节点(dummyhead)，将其 next 指针指向原链表的头节点；

2. 使用一个 cur 指针来遍历链表，cur 指向当前要执行交换操作的节点的前一个节点；

3. 在循环中，判断 cur 的下一个节点(cur->next)和下下个节点(cur->next->next)是否存在，如果存在，则进行交换操作：

   • 将 tmp 指针指向 cur 的下一个节点，即要交换的第一个节点；
   • 将 tmp1 指针指向 cur 的下一个节点的下下个节点，保存下一个需要遍历的节点；
   • 修改指针连接关系，完成节点交换（交换 cur->next 和 cur->next->next）；
   • 更新 cur 指针，指向交换后的节点。

4. 循环结束后，返回虚拟头节点(dummyhead)的下一个节点作为新的头节点。

复杂度

        时间复杂度:

                O(n)

代码中的循环只遍历了一次链表，并且每次循环都只进行了常数次的操作。

        空间复杂度

                O(1)

除了创建一个虚拟头节点以外，代码没有使用额外的空间来存储数据。

c++ 代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyhead = new ListNode(0);  // 创建虚拟头节点
        dummyhead->next = head;  // 将虚拟头节点的 next 指针指向原链表的头节点
        ListNode* cur = dummyhead;  // cur 指针指向当前要执行交换操作的节点的前一个节点

        while (cur->next != nullptr && cur->next->next != nullptr) {
            ListNode* tmp = cur->next;  // tmp 指向要交换的第一个节点
            ListNode* tmp1 = cur->next->next->next;  // tmp1 指向下一个需要遍历的节点
            cur->next = cur->next->next;  // 修改指针连接关系，完成节点交换
            cur->next->next = tmp;
            tmp->next = tmp1;
            cur = cur->next->next;  // 更新 cur 指针
        }

        return dummyhead->next;  // 返回新的头节点
    }
};

Java代码

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyhead = new ListNode(0); // 创建虚拟头节点
        dummyhead.next = head; // 将虚拟头节点的 next 指针指向原链表的头节点
        ListNode cur = dummyhead; // cur 指针指向当前要执行交换操作的节点的前一个节点

        while (cur.next != null && cur.next.next != null) {
            ListNode tmp = cur.next; // tmp 指向要交换的第一个节点
            ListNode tmp1 = cur.next.next.next; // tmp1 指向下一个需要遍历的节点
            cur.next = cur.next.next; // 修改指针连接关系，完成节点交换
            cur.next.next = tmp;
            tmp.next = tmp1;
            cur = cur.next.next; // 更新 cur 指针
        }

        return dummyhead.next; // 返回新的头节点
    }
}

Python代码

class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        dummyhead = ListNode(0)  # 创建虚拟头节点
        dummyhead.next = head  # 将虚拟头节点的 next 指针指向原链表的头节点
        cur = dummyhead  # cur 指针指向当前要执行交换操作的节点的前一个节点

        while cur.next and cur.next.next:
            tmp = cur.next  # tmp 指向要交换的第一个节点
            tmp1 = cur.next.next.next  # tmp1 指向下一个需要遍历的节点
            cur.next = cur.next.next  # 修改指针连接关系，完成节点交换
            cur.next.next = tmp
            tmp.next = tmp1
            cur = cur.next.next  # 更新 cur 指针

        return dummyhead.next  # 返回新的头节点

觉得有用的话可以点点赞，支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦  >人<  。