leetcode之链表总结

最新推荐文章于 2025-06-06 17:17:40 发布
原创 最新推荐文章于 2025-06-06 17:17:40 发布 · 300 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode #链表

本文精讲LeetCode中的经典链表题目，包括反转链表、回文链表、移除重复节点等，覆盖简单至中等难度，提供多种解题思路与代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

leetcode之链表总结

文章目录

1. 反转链表(简单)

https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof/
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* curr = head;
        while(curr!=NULL){
            ListNode* temp = curr->next;
            curr->next = pre;
            pre = curr;
            curr = temp;
        }
        return pre;
    }
};

做完这个可以做反转链表2

2. 回文链表（简单）

请判断一个链表是否为回文链表。
示例 1:
输入: 1->2
输出: false

示例 2:
输入: 1->2->2->1
输出: true

第一种方法
https://leetcode-cn.com/problems/palindrome-linked-list/
比较骚的操作：
第一步：复制链表到数组中
第二步：使用双指针法判断是否为回文

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode* dummy = head;
        vector<int> res;
        while(dummy!=NULL){
            res.push_back(dummy->val);
            dummy = dummy->next;
        }
        int i=0;
        int j=res.size()-1;
        while(i<=j){
            if(res[i]==res[j]){
                i++;
                j--;
            }
            else{
                return false;
            }
        }
        return true;
    }
};

时间复杂度o(n),空间复杂度o(n)

第二种做法：快慢指针
整个流程分为五个部分：
1.找到前半部分链表的尾节点
2.反转后半部分链表
3.判断是否回文
4.恢复链表(一般情况下希望链表执行完之后不对原始链表进行改变，不要这一步，对结果也不会产生影响)
5.返回结果

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(head==NULL) return true;
        ListNode *firstEnd = findMid(head);
        ListNode *secondList = reverseList(firstEnd->next);
        ListNode *first = head, *second = secondList;
        bool result = true;
        while(result && second!=NULL){
            if(first->val != second->val){
                result = false;
            }
            first = first->next;
            second = second->next;
        }
        firstEnd->next = reverseList(secondList);
        return result;
    }
    ListNode *reverseList(ListNode* head){
        ListNode *pre = nullptr,*curr=head;
        while(curr!=NULL){
            ListNode *temp = curr->next;
            curr->next = pre;
            pre = curr;
            curr = temp;
        }
        return pre;
    }
    ListNode *findMid(ListNode* head){
        ListNode *slow = head,*fast = head;
        while(fast->next!=NULL&&fast->next->next!=NULL){
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
};

时间复杂度 o(n),空间复杂度 o(1)

注：这两种做法都有牢记，在不对空间复杂度做要求时，推荐第一种做法，毕竟简单。但第二种做法涉及到链表一些常见的解题技巧，快慢指针，反转链表等，也要记住。

3.移除重复节点(简单)

https://leetcode-cn.com/problems/remove-duplicate-node-lcci/
编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。

示例1:
输入：[1, 2, 3, 3, 2, 1]
输出：[1, 2, 3]

示例2:
输入：[1, 1, 1, 1, 2]
输出：[1, 2]

1.哈希表 hash_set
与去重有关的问题首选哈希表（集合）

class Solution {
public:
    ListNode* removeDuplicateNodes(ListNode* head) {
        if(head==NULL||head->next==NULL) return head;
        unordered_set<int> occurred = {head->val};
        ListNode *pos = head;
        while(pos->next!=NULL){
            ListNode *cur = pos->next;
            if(!occurred.count(cur->val)){
                occurred.insert(cur->val);
                pos = pos->next;
            }else{
                pos->next = pos->next->next;
            }
        }
        return head;
    }
};

时间复杂度 o(n) 空间复杂度 o(n)

  1. 双重循环
    对每一个节点保证后面的节点与他没有重复的。
class Solution {
public:
    ListNode* removeDuplicateNodes(ListNode* head) {
        if(head==NULL||head->next==NULL) return head;
        ListNode *pos = head;
        while(pos!=NULL){
            ListNode *cur = pos;
            while(cur->next!=NULL){
                if(cur->next->val==pos->val){
                    cur->next = cur->next->next;
                }else{
                    cur = cur->next;
                }
            }
            pos = pos->next;
        }
        return head;
    }
};

时间复杂度 o（n^2） 空间复杂度 o(1)

4.环形链表（简单）

https://leetcode-cn.com/problems/linked-list-cycle/
快慢指针的典型应用

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。 否则，返回 false 。
在这里插入图片描述
在这里插入图片描述

进阶：你能用 O(1)（即，常量）内存解决此问题吗？

  1. 如果存在环，那么快慢指针一定会在某一刻相遇
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head==NULL||head->next==NULL) return false;
        ListNode *slow = head->next,*fast=head->next->next;
        while(slow!=fast){
            if(fast==NULL||fast->next==NULL) return false;
            slow = slow->next;
            fast = fast->next->next;
        }
        return true;
    }
};

时间复杂度 o(n) 空间复杂度 o(1)

2.哈希表，如果存在环，节点就会被重复添加。

class Solution {
public:
    bool hasCycle(ListNode *head) {
        unordered_set<ListNode*> seen;
        while(head!=NULL){
            if(seen.count(head)){
                return true;
            }else{
                seen.insert(head);
                head = head->next;
            }
        }
        return false;
    }
};

时间复杂度 o(n), 空间复杂度 o(n)

5.环形链表2（中等）

https://leetcode-cn.com/problems/linked-list-cycle-ii/

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

进阶：

你是否可以使用 O(1) 空间解决此题？
在这里插入图片描述
在这里插入图片描述
1.延续上一题哈希表的思想

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set<ListNode*> seen;
        while(head!=NULL){
            if(seen.count(head)){
                return head;
            }else{
                seen.insert(head);
                head = head->next;
            }
        }
        return NULL;
    }
};

时间复杂度 o(n) 空间复杂度 o(n)

2.快慢指针

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *slow=head,*fast=head;
        while(fast!=NULL&& fast->next!=NULL){
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast){
                ListNode *ptr = head;
                while(ptr!=slow){
                    ptr = ptr->next;
                    slow = slow->next;
                }
                return slow;
            }
        }
        return NULL;
    }
};

涉及到数学推理，不建议
时间复杂度 o(n)，空间复杂度 o(1)

6.重排链表（中等）

给定一个单链表 L：L0→L1→…→Ln-1→Ln ，
将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→…

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1:
给定链表 1->2->3->4, 重新排列为 1->4->2->3.

示例 2:
给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3.

1.直接双重循环进行插入

class Solution {
public:
    void reorderList(ListNode* head) {
        if(head==NULL||head->next==NULL) return;
        ListNode *pre = head;
        while(pre!=NULL&&pre->next!=NULL&&pre->next->next!=NULL){
            ListNode *cur = pre;
            while(cur->next->next!=NULL){
                cur = cur->next;
            }
            cur->next->next = pre->next;
            pre->next = cur->next;
            cur->next=NULL;
            //if(pre->next==NULL||pre->next->next==NULL) return;
            pre = pre->next->next;
        }
    }
};

时间复杂度 o(n^2) 空间复杂度 o(1)

2.线性表
因为链表不支持下标访问，所以我们无法随机访问链表中任意位置的元素。

因此比较容易想到的一个方法是，我们利用线性表存储该链表，然后利用线性表可以下标访问的特点，直接按顺序访问指定元素，重建该链表即可。

对于链表中涉及到元素交换的都可以考虑使用线性表（数组）进行处理

class Solution {
public:
    void reorderList(ListNode* head) {
        if(head==NULL||head->next==NULL) return;
        vector<ListNode*> res;
        ListNode *cur = head;
        while(cur!=NULL){
            res.push_back(cur);
            cur = cur->next;
        }
        int i=0,j = res.size()-1;
        while(i<j){
            res[i]->next = res[j];
            i++;
            if(i==j) break;
            res[j]->next = res[i];
            j--;
        }
        res[i]->next = NULL;
    }
};

注意：循环跳出的条件，边界值
时间复杂度 o(n) ,空间复杂度 o(n)

3. 寻找链表中点 + 链表逆序 + 合并链表
链表常见解题方法的综合应用

class Solution {
public:
    void reorderList(ListNode* head) {
        if(head==NULL||head->next==NULL) return;
        ListNode *firstEnd = findMid(head);
        ListNode *secondList = reverseList(firstEnd->next);
        firstEnd->next = NULL;
        ListNode *first=head,*second = secondList;
        while(second!=NULL){
            ListNode *temp = second->next;
            second->next = first->next;
            first->next = second;
            first = first->next->next;
            second = temp;

        }
        //first->next = NULL;
    }
    ListNode *reverseList(ListNode* head){
        ListNode *pre=NULL,*cur = head;
        while(cur!=NULL){
            ListNode *temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
    ListNode *findMid(ListNode* head){
        ListNode *slow = head,*fast = head;
        while(fast->next!=NULL && fast->next->next!=NULL){
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
};

时间复杂度 o(n) 空间复杂度 o(1)

7.有序链表转换二叉搜索树

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
在这里插入图片描述
分治

class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        return buildTree(head,nullptr);
    }
    ListNode *findMid(ListNode* left,ListNode *right){
        ListNode *slow = left,*fast = left;
        while(fast!=right && fast->next!=right){
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }
    TreeNode *buildTree(ListNode *left,ListNode *right){
        if(left==right) return nullptr;
        ListNode *mid = findMid(left,right);
        TreeNode* root = new TreeNode(mid->val);
        root->left = buildTree(left,mid);
        root->right = buildTree(mid->next,right);
        return root;
    }
};

时间复杂度 o(nlogn) 空间复杂度 o(logn)

总结

反转链表 + 快慢指针+找中间节点
考虑使用线性表（vector）/数组
与去重（不重复）有关的用哈希表 unordered_set m; unordered_set<ListNode*> m;

leetcode-链表
Ritchie_Lin的博客
04-22 427
String Tree 783. 二叉搜索树节点最小距离 给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。 解析： 如果对节点的值进行排序，那某个值与其相邻的两个值的差值中的最小值就是该值与其它值差值的最小值，那实际上只要对排序后的值进行遍历，就可以找出最小值。 给定的树是二叉搜索数，即对于每个节点，父节点的值大于左子节点的值，且小于右子节点的值。所以如果对其进行中序遍历，那遍历的值是升序的。 所以解题思路就是先对二叉树进行中序遍历，将节点的值保存到数组中，此时，数组
LeetCode链表题解技巧归纳总结
小白码上飞
06-21 656
总结一下链表题型的解题技巧，以及对应题目的解题思路
leetcode总结_链表
qq_31332765的博客
06-10 357
算法，数据结构，leetcode，链表
leetcode链表
qq_43283527的博客
04-03 468
例题 2. 两数相加 代码如下： # Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def addTwoN...
Leetcode | 链表（Linked List）原理及高频题型一网打尽！
最新发布
weixin_44649780的博客
06-06 1029
特性内容操作效率插入/删除 O(1)，查找 O(n)编程技巧虚拟头节点、快慢指针、递归反转等推荐使用场景插入删除频繁、不能随机访问判断是否使用链表题目涉及节点/引用/链式结构时想要了解更多内容，可在VX小程序搜索🔍AI Pulse,获取更多最新内容。
LeetCode-链表
a445673440的博客
11-26 451
记录，整理LeetCode中与“链表”相关的题目
LeetCode之链表
qq_38773342的博客
11-19 778
1 反转链表 给定一个单链表的头结点pHead，长度为n，反转该链表后，返回新链表的表头。 如当输入链表{1,2,3}时， 经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。 truct ListNode* ReverseList(struct ListNode* pHead ) { if(pHead == NULL || pHead->next == NULL){ return pHead; } struct ListNode *p
leetcode-链表笔记
02-06
链表是一种基础且重要的数据结构，它在计算机科学和编程中扮演着至关重要的角色，特别是在算法和数据结构的学习中，LeetCode 是一个很好的实践平台。本笔记将深入探讨 LeetCode 中涉及的链表相关问题，旨在帮助你...
Leetcode 反转链表.js
02-21
LeetCode 206的题目是“反转链表”（Reverse Linked List），它要求将一个单链表的所有节点反转，并返回反转后链表的头节点。这是一个基础但非常重要的链表操作问题，它不仅考察了对链表数据结构的理解，还涉及到了...
LeetCode环形链表
2301_78310843的博客
04-20 1110
环形链表，快慢指针，leetcode
leetcode求链表中点-AlgoBootcamp:算法训练营
07-06
leetcode求链表中点 数据结构 | 算法 | 力扣笔记 数据结构 队列：FIFO - 可以使用节点（更高效）或数组及其方法（push pop 等）构建 堆栈：LIFO - 可以使用节点（更有效）或数组及其方法（push pop 等）构建 对于...
Leetcode-链表大总结
legalhighhigh的博客
12-05 332
链表简单题全部做完做个小总结： 141、linked-list-cycle 两个指针，一块一慢，若快指针能遇到慢指针则返回true 160、tersection-of-two-linked-lists 两个不等的线段并起来最后的长度相同，用两个指针同时走就行 或者： 最朴素的想法，求长度，求差，再两个一起走，直到相等或者返回空 203.remove-linked-list-elements.cp...
【LeetCode之链表】
Liususiu的秃头日记
11-12 540
LeetCode链表系列常见的题目。
链表数据结构总结（leetcode）
qq_40595812的博客
08-06 383
链表的相关考点总结： /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ //由于说明了给定的k值一定有效，所以不用考虑k值比元素个数多的情况。 int kthToLast(struct ListNode* head, int k){ struct ListNode*pre = head,*p=head;
leetcode 之 链表
Luckyzhoufangbing的博客
12-02 245
1. 链表中倒数第 K 个节点 设置快慢两个指针，首先他们 都是 head，快的先走 k - 1 步，然后快慢一起走，一步一步走，快的走到终点，此时慢的就是所求的值 var kthToLast = function(head, k) { var showLink = head var fastLink = head // 快指针先走k-1步 while (k > 1) { fastLink = fastLink.next k-- } // 当快指针到达
LeetCode—链表
weixin_42589774的博客
06-14 174
LeetCode—链表 1、找出两个链表的交点 T.160 Intersection of Two Linked Lists (Easy) /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public:
LeetCode——链表
努力努力再努力L
02-11 387
LeetCode——链表 目录 概述 找出两个链表的交点 链表反转 归并两个有序的链表 从有序链表中删除重复节点 删除链表的倒数第n个节点 交换链表中的相邻节点 链表求和 回文链表 分隔链表 链表元素按奇偶聚集 0. 概述 链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理 1. 找出两个链表的交点 概述 1. A和B两个链表相交于c1，但不会...
【LeetCode】-链表
银尘博客
01-27 808
文章目录一、移除链表元素二、设计链表 一、移除链表元素 题目： 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5] 示例 2： 输入：head = [], val = 1 输出：[] 示例 3： 输入：head = [7,7,7,7], val = 7 输出：[] 提示： 列表中的节点数目在范围 [0, 10
Java解决LeetCode环形链表问题详解
以上就是针对"java-leetcode题解之第141题环形链表.zip"的知识点总结。通过解决这一类问题，可以加深对Java语言的理解，提升解决实际问题的能力，同时也能够为应对技术面试中可能出现的相关问题打下坚实的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值