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、迭代法

代码

/**
 * 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) {  
        // 创建一个虚拟头节点，值为0，next指向原始链表的头节点
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        // 定义一个指针node0，指向虚拟头节点。用来遍历链表
        ListNode* node0 = dummyHead;  
  
        while (node0->next != nullptr && node0->next->next != nullptr){  
            ListNode* node1 = node0->next;
            ListNode* node2 = node0->next->next; 
            ListNode* node3 = node0->next->next->next;  
 
            node0->next = node2; // 0->2 
            node2->next = node1; // 0->2->1
            node1->next = node3; // 0->2->1->3
 
            // node0移动到新的位置，准备处理下一对相邻节点
            node0 = node1;
        }  
 
        // 返回交换后的新链表的头节点，即虚拟头节点的下一个节点
        head = dummyHead->next; // head指向已交换的第一个节点，即原始链表的第二个节点
        delete dummyHead; // 删除虚拟头节点，释放内存空间
        return head;  
    }  
};

复杂度分析

• 时间复杂度：O(n)，其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。
• 空间复杂度：O(1)。

2、递归

代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
        ListNode* newHead = head->next;
        head->next = swapPairs(newHead->next);
        newHead->next = head;
        return newHead;
    }
};

 复杂度分析

• 时间复杂度：O(n)，其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。
• 空间复杂度：O(n)，其中 n 是链表的节点数量。空间复杂度主要取决于递归调用的栈空间。