力扣日记8.14-【链表篇】反转链表、两两交换链表中的节点

最新推荐文章于 2026-01-09 18:00:00 发布

原创最新推荐文章于 2026-01-09 18:00:00 发布 · 89 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #链表 #算法

该博客记录力扣链表相关题目解题过程。包含206.反转链表和24.两两交换链表中的节点两题。介绍了反转链表的遍历、双指针法和递归解法，分析了复杂度；对于两两交换节点题，强调画图重要性，提及不同指针使用方式，两种题解时间复杂度均为O(n)。

力扣日记：【链表篇】反转链表、两两交换链表中的节点

日期：2023.8.14（摸了三天鱼了aaa…）
参考：代码随想录、力扣

206.反转链表

题目描述

难度：简单

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

题解

/**
 * 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) {}
 * };
 */
#define SOLUTION 3
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
#if SOLUTION == 1 // 遍历
        ListNode * newHead = head;
        while (head != nullptr && head->next != nullptr) {
            ListNode * tmp = head->next;
            head->next = head->next->next;
            tmp->next = newHead;
            newHead = tmp;
        }
        head = newHead;
        return head;
#elif SOLUTION == 2 // 双指针法
        ListNode* cur = head;
        ListNode* pre = nullptr;
        while (cur != nullptr) {
            ListNode* tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        head = pre;
        return head;
#elif SOLUTION == 3 // 递归
        return reverse(nullptr, head);        
#endif
    }
    ListNode* reverse(ListNode* pre, ListNode* cur) {
        if (cur == nullptr) return pre;
        ListNode* tmp = cur->next;
        cur->next = pre;
        return reverse(cur, tmp);
    }
};

执行结果

遍历
状态：通过
时间复杂度：O(n)
空间复杂度：O(1)
双指针法
状态：通过
时间复杂度：O(n)
空间复杂度：O(1)
递归
状态：通过
时间复杂度：O(n)
空间复杂度：O(n)（递归调用了n层栈空间）

在这里插入图片描述

思路总结

直接遍历的反转过程是：

1->2->3->4
2->1->3->4
3->2->1->4
4->3->2->1

双指针法的反转过程是：

null   1->2->3->4
null <-1 2->3->4
null <-1<-2 3->4
null <-1<-2<-3 4
null <-1<-2<-3<-4

递归在双指针法的基础上得到，两者是一样的逻辑。
- 在双指针法中，将pre初始化为null，将cur初始化为head，接着判断cur是否为null，为null则返回pre，否则进行反转，最后将pre赋值为cur，将cur赋值为tmp，再进行下一轮循环。
- 而在递归中，只是将循环写成了递归的形式（在递归函数的形参传递中完成了初始化以及每一轮循环中pre = cur, cur = tmp的操作）。
- 递归的结束条件对应循环的条件。注意最后一次递归通过if条件return后，返回上一次递归调用reverse位置，因此要在调用reverse时return其返回值，从而不断return到最外层递归。

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

题目描述

难度：中等

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

题解

/**
 * 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 {
#define SOLUTION 2
public:
    ListNode* swapPairs(ListNode* head) {
#if SOLUTION == 1 // my ver 
        if (head == nullptr || head->next == nullptr) return head;
        ListNode* dummyHead = new ListNode();
        dummyHead->next = head;
        // 初始化
        ListNode* pre = head;
        ListNode* cur = head->next;
        ListNode* ppre = dummyHead;
        head = head->next; // 唯一需要更新head的地方
        while (true) {
            pre->next = cur->next;
            cur->next = pre;
            ppre->next = cur;
            if (pre->next != nullptr && pre->next->next != nullptr) {
                ppre = pre;
                cur = pre->next->next;
                pre = pre->next;
            } else {
                break;
            }
        }
        return head;
#elif SOLUTION == 2 // 代码随想录ver
        // 只用一个cur!!!（还有两个tmp）
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr) {
            ListNode* tmp = cur->next; // 记录临时节点
            ListNode* tmp1 = cur->next->next->next; // 记录临时节点

            cur->next = cur->next->next;    // 步骤一
            cur->next->next = tmp;          // 步骤二
            cur->next->next->next = tmp1;   // 步骤三

            cur = cur->next->next; // cur移动两位，准备下一轮交换
        }
        return dummyHead->next;
#endif
    }
};

复杂度

两种题解的复杂度都是：
时间复杂度：O(n)
空间复杂度：O(1)

思路总结

画图很重要
两两交换，即第1、2个，第3、4个等交换，如果是奇数个节点，则最后一个节点不用交换。
代码随想录的题解只用了一个cur和两个tmp，更为简洁。我则用了三个指针ppre,pre,cur（本质是一样的）。
代码随想录的交换示意图：
代码随想录详细题解思路