【LeetCode】-链表

最新推荐文章于 2023-04-07 23:35:22 发布
最新推荐文章于 2023-04-07 23:35:22 发布
阅读量712 收藏
点赞数
分类专栏： LeetCode 文章标签： 链表 leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangshuqian1314/article/details/122657927
版权

文章目录

前言

初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。

一、移除链表元素

题目：
给你一个链表的头节点 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, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、直接删除，不添加虚拟头结点，此时，删除头结点的方法和其他节点不同
2、添加虚拟头结点，此时，删除头结点方法和其他节点相同

代码：

# 直接删除法

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 删除头结点
        while(head != NULL && head->val == val){
            ListNode* tmp = head->next;
            head = head->next;
            delete tmp;
        }
        // 删除非头结点
        ListNode* cur = head;
        while(cur != NULL && cur->next != NULL){
            if(cur->next->val == val){
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }else{
                cur = cur->next;
            }
        }

        return head;

    }
};

#设置虚拟头结点法
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* cur = dummyHead;
        while(cur->next != NULL){
            if(cur->next->val == val ){
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }else{
                cur = cur->next;
            }
        }
        
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

二、设计链表

题目：
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3
linkedList.get(1); //返回2
linkedList.deleteAtIndex(1); //现在链表是1-> 3
linkedList.get(1); //返回3

提示：

所有val值都在 [1, 1000] 之内。
操作次数将在  [1, 1000] 之内。
请不要使用内置的 LinkedList 库。

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、添加虚拟节点

代码：

class MyLinkedList {
public:

    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val): val(val),next(nullptr){}
    };

    MyLinkedList() {
        _dummyHead = new LinkedNode(0);
        _size = 0;
    }
    
    int get(int index) {
        if(index > (_size - 1)|| index < 0){
            return -1;
        }

        LinkedNode* cur = _dummyHead->next;
        while(index--){
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;

    }
    
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if (index > _size) {
            return;
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--){
            cur = cur->next;
        }
        newNode->next =cur->next;
        cur->next = newNode;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--){
            cur = cur->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }
    private:
       int _size;
       LinkedNode* _dummyHead;
};

三、反转链表

题目：
给你单链表的头节点 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

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、将指针进行反转，这样就可以实现链表的反转

代码：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* tmp;
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur){
            tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;

    }
};

四、两两交换链表中的节点

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、直接将图画在草稿纸上，避免出错！

代码：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = 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;
        }

        return dummyHead->next;
    }
};

五、删除链表的倒数第N个节点

题目：
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、双指针法，一个fast指针和一个slow指针，让fast指针先往前走n+1步，多一步的话，可以使slow指针指向删除节点的前面节点，方便删除操作。

代码：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast != NULL){
            fast = fast->next;
        }
        fast = fast->next;
        while(fast != NULL){
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;

        return dummyHead->next;

    }
};

六、链表相交

题目：
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at ‘2’
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

listA 中节点数目为 m
listB 中节点数目为 n
0 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
1、用两个指针分别指向两个链表的表头，先求出两个链表的长度，再求出两个链表的差值。将长链表的表头移动到和短链表的表头平齐。之后比较两个指针的值是否相同，如果相同则放回；如果不相同则指针分别偏移一个单位。

代码：

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0,lenB = 0;
        while(curA != NULL){
            lenA++;
            curA = curA->next;
        }
                
        while(curB != NULL){
            lenB++;
            curB = curB->next;
        }
        
        curA = headA;
        curB = headB;

        if(lenB > lenA){
            swap(lenA,lenB);
            swap(curA,curB);
        }

        int gap = lenA - lenB;
        
        while(gap--){
            curA = curA->next;
        }

        while(curA != NULL){
            if(curA == curB){
                return curA;
            }

            curA = curA->next;
            curB = curB->next;
        }

        return NULL;

    }
};

七、环形链表 II

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

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

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-search

思路：
也是双指针法，一个快指针和一个慢指针，当两个指针相遇的时候；在定义两个指针，一个指针从相遇点开始走，另一个指针从头结点开始走，当两个指针相遇的时候，就是入口结点。
（具体推理过程，参看代码随想录）

代码：

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast = head;
        while(fast !=NULL && fast->next != NULL){
            fast = fast->next->next;
            slow = slow->next;
            if(slow == fast){
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while(index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2;
            }
        }
        return NULL;
    }
};
电科_银尘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode-链表笔记
02-06
链表是一种基础且重要的数据结构，它在计算机科学和编程中扮演着至关重要的角色，特别是在算法和数据结构的学习中，LeetCode 是一个很好的实践平台。本笔记将深入探讨 LeetCode 中涉及的链表相关问题，旨在帮助你...
链表的next指向理解
wcy18629063634的博客
10-20 1336
链表指向语言坑爹
数据结构笔记——链表
关于我的学习记录
12-05 2221
数据结构笔记——链表
链表的.next指向问题
YangYoung_的博客
08-27 5361
这是在leetcode上做的一道链表题，有时候会不懂到底 .next 指的是。像这样，左边不带 .next 的是类似于赋值语句，自己的指针指向右边位置。这种就代表等号左边指向右边，左边的是指向，右边就代表确切的下一个节点。
数据结构之单链表
weixin_64394633的博客
04-25 1003
相比于顺序表，我们知道顺序表的优点为 1.物理空间连续 2.下表随机访问 但是其缺点也很明显 1.空间不够需要扩容。而扩容有一定的性能消耗，其次一般扩容2倍，存在一定空间浪费。 2.头部或者中间插入效率低下。 故以此缺点上我们提出改进方案 1.按需申请释放空间 因此我们引入单链表来实现其优化 定义：“单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，
【c语言】链表（适合初学者）
weixin_74337975的博客
04-07 2303
C语言中的链表是一种常见的数据结构，它由一系列的节点（node）组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表可以用来表示各种数据结构，例如队列、堆栈、树等。在C语言中，链表的节点通常是通过结构体来定义的。int data;在这个结构体中，data是节点存储的数据元素，next是指向下一个节点的指针。因为next指向的是另一个Node类型的结构体，所以需要使用类型来定义。链表的头指针是指向第一个节点的指针，通常称为head。对于一个空链表，头指针为NULL。链表的尾节点的next。
【leetcode-链表】环形链表
12-21
在给定的LeetCode问题中，我们需要判断链表中是否存在环，并通过整数`pos`来表示环的位置。如果`pos`为-1，则链表没有环。提供的解决方案使用了“快慢指针”（Floyd's Cycle-Finding Algorithm，也称为龟兔赛跑算法...
【leetcode-链表】扁平化多级双向链表
01-20
本题是关于扁平化多级双向链表的问题，来自LeetCode。在多级双向链表中，每个节点除了拥有指向下一个节点（next）和前一个节点（prev）的指针，还有一个子链表指针（child），可以指向一个单独的双向链表。这种结构...
leetcode-86 分隔链表
01-08
给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。 你应当保留两个分区中每个节点的初始相对位置。 示例: 输入: head = 1->4->3->2->5->2, x = 3 输出: 1->2->2->4-...
zwangZJU#LeetCode-in-python-wznote#LeetCode-python-142-环形链表-II1
07-25
给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从
数据结构秘籍之链表
qq_53113851的博客
04-23 1498
文章目录链表链表简介单链表的实现常见的链表oj题链表的带环问题链表的深度拷贝双向循环链表的实现啥是链表？单链表的实现链表的带环问题解题思路解题思路复制带随机指针的链表解题思路 链表 链表简介 单链表的实现 常见的链表oj题 链表的带环问题 链表的深度拷贝 双向循环链表的实现 啥是链表？ 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据
指针链表的实现
qq_42912469的博客
01-08 832
1.说明。 链表可以处理预先不知道变量个数的问题。 每一个结点都由两个部分组成。左边的部分用来存放具体的数值，用一个整型变量 就可以；右边的部分存储下一个结点的地址，可以用指针来实现（也称为后继指针）。 这里我们定义一个结构体类型来存储这个结点，如下： struct node { int data; struct node *next; }; 第二个成员是一个指针，用来存储下一个结 点的地址。因为下一个结点的类型也是 struct node，所以这个指针的类型也必须是 struct n
链表
TYPFOON的博客
03-16 320
链表 概念： 链表通过节点的方式来存储数据； 分有两个域组成：data域（存储数据），next域（指向下一个节点的索引，链表结束的时候给next域赋值为NULL）； 链表的各个节点不一定是连续存储的； 链表分为带头结点（头节点不存放数据，在一个链表中只起到连接的作用）和不带头结点的链表。 （注：这里虽然看起来是顺序的，但实际上next域指向的下一节点不一定都是连续的，这个图只是便于理解，但是不...
next在c语言有特殊,c语言之单向链表
weixin_39627201的博客
05-19 838
0x00 什么是链表链表可以说是一种最为基础的数据结构了，而单向链表更是基础中的基础。链表是由一组元素以特定的顺序组合或链接在一起的，不同元素之间在逻辑上相邻，但是在物理上并不一定相邻。在维护一组数据集合时，就可以使用链表，这一点和数组很相似。但是，链表有着数组所不具有的优势。一方面，链表在执行插入删除操作时拥有更高的效率；另一方面，链表是在堆区动态的开辟存储空间，而大多数的数据在编译时大小并不能...
数据结构与算法---链表
SimpleZihao的博客
01-25 540
看尚硅谷韩顺平老师课程写的记录
数据结构之链表
m0_59392076的博客
05-28 531
小结： 1、链表是以节点的方式链式储存 2、每个节点包含data域，next域：指向下一个节点 3、如图：发现链表的各个节点不一定是连续储存的 4、链表分带节点的链表没有头节点链表，根据实际实际的需求来确定 单列表的创建示意图，显示单向链表的分析 代码实现 package com.atguigu.linkedlist; public class SingleLinkedList { public static void main(String[] arg..
数据结构-链表
RichardGeek的博客
06-20 905
链表的相关知识
c语言链表中next作用,C语言链表详解
weixin_32304579的博客
05-17 4033
本文摘自wikipedia。本文内容是关于：C语言 链表详解，c语言链表教程。 链表(Linked list)是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。 单链表(单向链表)是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始，如下图所示。本文将结合代码详解C语言链表，单向链表的数据...
JAVA中链表的next解释
weixin_51981189的博客
12-31 4562
为有助于理解链表和next属性 先新建一个节点类 对于链表数据结构来说，基本的单元是节点Node，对于单向链表来说，任何一个节点Node中都有属性：1.存储的数据 2.下一个节点的内存地址 public class Node { Object data; Node next; public Node() { } public Node(Object data, Node next) { this.data = data; t
leetcode-5:实现链表的首尾链接
最新发布
12-30
leetcode-5题要求我们实现链表的首尾链接，即将链表中最后一个节点的next指针指向链表中的第一个节点，并将链表中的第一个节点的prev指针指向链表中最后一个节点。 解题思路如下： 1. 首先，判断链表是否为空，若为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值