【链表专题】Leetcode148待做

已于 2022-05-03 22:22:34 修改
阅读量73 收藏
点赞数
文章标签： 链表 list leetcode
于 2022-05-02 22:51:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Peanut31434331/article/details/124548346
版权

链表专题

  • 目前还没解决 遍历到null->next咋办
  • Leetcode148待做
  1. 当头结点可能被修改时：auto dummy=new ListNode(-1,head); 注意一定要把head串上去
  2. 找链表上倒数第n个数
    auto first=dummy,second=dummy;
    for(int i=0;i<n;i++)first=first->next;走n步
    first=first->next;
    while(first->next){//结束后，first位于最后一个接点，second处于倒数第n+1节点
    first=first->next;
    second=second->next;
    }
  3. 发现一般都是while(cur)因为while(cur->next)对空链表不适合

Leetcode19.删除链表的倒数第 N 个结点（模板）
Leetcode237删除链表中的节点（思路巧妙）
Leetcode83.删除排序链表中的重复元素
Leetcode61.旋转链表（模板-倒数第n个节点）
Leetcode24.两两交换链表中的节点（思路巧妙自己做还没做出来）
Leetcode206.反转链表（上一题的变题）
Leetcode92.反转链表 II（上一题的变题）
Leetcode160.相交链表（数学题-思路巧妙）
Leetcode142.环形链表 II（数学题-思路巧妙）
Leetcode148.排序链表（呜呜不会做）

一、Leetcode19.删除链表的倒数第 N 个结点.

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

    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) {}
	};
ListNode* removeNthFromEnd(ListNode* head, int n) {
        auto dummy=new ListNode(-1,head);
        auto first=dummy,second=dummy;
        for(int i=0;i<n;i++){
            first=first->next;
        }
        while(first->next){
            first=first->next;
            second=second->next;
        }
        second->next=second->next->next;
        return dummy->next;
    }

二、Leetcode237删除链表中的节点.

请编写一个函数，用于 删除单链表中某个特定节点 。在设计函数时需要注意，你无法访问链表的头节点 head ，只能直接访问 要被删除的节点 。

题目数据保证需要删除的节点 不是末尾节点 。

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
    void deleteNode(ListNode* node) {
        node->val=node->next->val;
        node->next=node->next->next;
    }

三、Leetcode83.删除排序链表中的重复元素.

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

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) {}
};
    ListNode* deleteDuplicates(ListNode* head) {
        auto cur=head;
        while(cur){
            if(cur->next&&cur->val==cur->next->val)cur->next=cur->next->next;
            else cur=cur->next;
        }
        return head;
    }

四、Leetcode61.旋转链表

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

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) {}
};
    ListNode* rotateRight(ListNode* head, int k) {
        int n=0;
        auto cur=head;
        while(cur){
            cur=cur->next;
            n++;
        }
        if(n==0)return head;
        k%=n;
        auto first=head,second=head;
        for(int i=0;i<k;i++){
            first=first->next;
        }
        while(first->next){
            first=first->next;
            second=second->next;
        }
        first->next=head;
        head=second->next;
        second->next=NULL;
        return head;
    }

五、Leetcode24.两两交换链表中的节点

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

    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) {}
};
ListNode* swapPairs(ListNode* head) {
        auto dummy=new ListNode(-1);
        dummy->next=head;

        for(auto p=dummy;p->next&&p->next->next;){
            auto a=p->next;
            auto b=a->next;
            p->next=b;
            a->next=b->next;
            b->next=a;

            p=a;
        }
        return dummy->next;
    }

六、Leetcode206.反转链表

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

    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) {}
};
 ListNode* reverseList(ListNode* head) {
        if(!head)return NULL;

        auto a=head;
        auto b=head->next;
        while(b!=NULL){
            auto c=b->next;
            b->next=a;
            a=b;
            b=c;
        }
        head->next=NULL;

        return a;
    }

七、Leetcode92.反转链表 II

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

    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) {}
};
ListNode* reverseBetween(ListNode* head, int left, int right) {
        if(left==right)return head;

        auto dummy=new ListNode(-1);
        dummy->next=head;
        auto a=dummy;auto c=dummy;
        for(int i=0;i<left-1;i++)a=a->next;
        for(int i=0;i<right;i++)c=c->next;
        auto d=c->next;
        auto b=a->next;
        for(auto p=a->next,q=p->next;q!=d;){
            auto qq=q->next;
            q->next=p;
            p=q;
            q=qq;
        }
        a->next=c;
        b->next=d;
        return dummy->next;

    }

八、Leetcode160.相交链表.

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        auto p=headA;
        auto q=headB;
        while(p!=q){
            if(p)p=p->next;
            else p=headB;
            if(q)q=q->next;
            else q=headA;
        }
        return q;
    }

九、Leetcode142.环形链表 II.

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

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

不允许修改 链表。

    struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
ListNode *detectCycle(ListNode *head) {
        auto fast=head;
        auto slow=head;
        while(fast){
            fast=fast->next;
            slow=slow->next;
            if(fast)fast=fast->next;
            else break;

            if(fast==slow){
                slow=head;
                 while(slow!=fast){
                    slow=slow->next;
                    fast=fast->next;
                 }
            return slow;
            }
        }
        return NULL;
    }

十、Leetcode148.排序链表.

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

    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) {}
};
ListNode* sortList(ListNode* head) {
        auto dummy=new ListNode(-1);
        dummy->next=head;
        int n=0;
        for(auto p=head;p;p=p->next)n++;

        for(int i=1;i<n;i=i*2){
            auto cur=dummy;
            for(int j=0;j+i<n;j+=i*2){
                auto left=cur->next,right=cur->next;
                for(int k=0;k<i;k++)right=right->next;
                int l=0,r=0;
                while(l<i&&r<i&&right){
                    if(left->val<=right->val){
                        cur->next=left;
                        cur=left;
                        left=left->next;
                        l++;
                    }else{
                        cur->next=right;
                        cur=right;
                        right=right->next;
                        r++;
                    }
                }
                while(l<i){
                    cur->next=left;
                    cur=left;
                    left=left->next;
                    l++;
                }
                while(r<i&&right){
                    cur->next=right;
                    cur=right;
                    right=right->next;
                    r++;
                }
                cur->next=right;
            }
        }
        return dummy->next;
    }
九月花生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Leetcode刷题方法总结---链表全解
修行的凡人的博客
08-24 1052
Leetcode刷题方法总结---链表全解
leetcode(链表专题)
Listen·Rain的博客
11-12 751
链表1.导论2.编程题2.1 203.移除链表元素 1.导论 链表分类：单链表、双向链表、循环链表 链表考查点： 链表的增删改查 虚拟头结点 链表反转 链表相交 是否有环 2.编程题 2.1 203.移除链表元素 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 列表中的节点数目在范围 [0, 104] 内 1 <= Node.val <= 50 0 <= val <= 50 /**
【链表】经典链表题LeetCode
鹏啊鹏
08-13 566
LeetCode经典链表题
leetcode刷题——链表
xxp的博客
03-12 299
leetcode刷题——链表
LeetCode算法之--链表系列
程序大视界
12-21 779
LeetCode链表常见算法题型
LeetCode分类刷题----链表篇
池鱼
01-12 1244
设立两个快慢指针，先让快指针走n+步，当快指针指向链表尾节点的时候，此时慢指针恰好走到要删除节点的前一个节点，此时对慢指针进行删除即可。设头节点到成环节点的距离为x，设成环节点到相遇节点的距离为y，设相遇节点到成环节点的距离为z。给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点。两个指针，当着两个指针走向尽头时，然后转向另一个链表的头节点，直到这两个链表相遇，因为这两个节点都走了同样的长度。当n=1的时候有x=z。
LeetCode题解：622. 设计循环队列，使用数组，JavaScript，详细注释
Lee Chen的博客
09-16 146
原题链接：https://leetcode-cn.com/problems/design-circular-queue/ 解题思路： 采用两个指针，头指针指向队首，尾指针指向入队元素插入队列的位置，尾指针-1则为队尾。 进行出入队列操作时，头尾指针都加1，注意处理指针移出队列范围时，要循环到队列内部的问题。 /** * Initialize your data structure here. Set the size of the queue to be k. * @param {number} k
LeetCode题解：641. 设计循环双端队列，使用双向链表，JavaScript，详细注释
Lee Chen的博客
09-29 155
原题链接：https://leetcode-cn.com/problems/design-circular-deque/ 解题思路： 如果你看到这题的时候，感到没有思路，可以先尝试其前导题目：622. 设计循环队列，以及我的题解LeetCode题解：622. 设计循环队列，使用双向链表，JavaScript，详细注释。 使用双向链表，每次插入元素时，都创建一个节点，将其连接到链表的头或尾。 删除元素时，值需要将链表头尾节点的连接打断即可。 使用头尾指针，分别指向链表的头尾，用于取值、添加和删除。 使用le
leetcode707:设计链表(增删差)
qq_48508278的博客
01-02 400
一:题目 二:上码 class MyLinkedList { public: //定义链表节点结构体 struct LinkedNode { int val; LinkedNode* next; LinkedNode(int val):val(val), next(nullptr){} }; // 初始化链表 MyLinkedList() { node = new LinkedNode(0); /
Leetcode刷题系列java版-----链表(简单)
qq_39687662的博客
07-21 354
我写的这个系列的博客解题的算法不一定是时间和空间复杂度最优的解,一切以能AC+算法模板普适性为原则解题 首先是链表的增删改查,所有问题都是以链表的增删改查为核心去变种的,改和查按照条件去遍历链表即可,下面直接看leetcode原题: 1.移除链表元素(链表删除节点的模板题) 要点: ①进来一定要先记得判空,在访问next的时候也一定要注意代码是否会造成空指针异常,如果一个类比如ListNode题中的两个属性val和next,如果当前节点node为null,那么访问val和next的时候都会报空指.
数据结构【双链表、Leetcode链表题--4】
我心如火
05-17 1328
双链表：带头双向循环链表，这是最优链表，任意地方插入删除时间复杂度都是O(1)。Leetcode链表刷题
【C++】list的模拟实现
2301_77954967的博客
08-16 1434
在 C++ 编程中，模拟实现标准模板库（STL）中的list具有重要意义和广泛的应用场景。list作为一种常用的数据结构，其独特的特性使得在许多情况下能够提供高效和灵活的操作。模拟实现list有助于深入理解其内部工作原理。通过亲手编写代码来模拟 list 的各种功能，如节点的创建、插入、删除、遍历等，可以清晰地掌握数据在链表中的存储和流动方式，这对于提升对数据结构的理解和编程能力至关重要。在实际应用中，list 常用于需要频繁进行插入和删除操作的场景。
FSOP，glibc-2.23攻击IO_list_all
yjh_fnu_ltn的博客
08-16 866
FSOP 是 File Stream Oriented Programming 的缩写，根据前面对 FILE 的介绍得知进程内所有的 _ IO_FILE 结构会使用 _ chain 域相互连接形成一个链表，这个链表的头部由_IO_list_all维护。FSOP 的核心思想就是劫持_IO_list_all 的值来伪造链表和其中的_IO_FILE 项，但是单纯的伪造只是构造了数据还需要某种方法进行触发。FSOP 选择的触发方法是调用_，这个函数会刷新_IO_list_all 链表中所有项的文件流，相当于。
java将list里的数据使用字符隔开并输出为一个String字符串
最新发布
baomingshu的博客
08-19 199
友情提醒:先看文章目录，大致了解文章知识点结构，点击文章目录可直接跳转到文章指定位置。有用记得关注。
C++入门——08list
木木没有跶
08-18 667
iteratorlist// 获取并打印最后一个元素if (!// 删除 3// 1 2。
Aria2@RPC下载@Alist批量下载
xuchaoxin1375的博客
08-15 837
Aria2 是一款轻量级、多协议、多源的命令行下载工具，其强大的功能使得它在开发者和高级用户中备受推崇。本文探讨 Aria2 的远程控制功能——RPC（Remote Procedure Call），并演示如何使用它来远程管理下载任务。添加、暂停、删除下载任务：可以通过 RPC 动态管理任务。获取任务状态：可以实时查询任务的下载进度、速度和状态。修改下载选项：支持在下载过程中修改下载参数，比如最大连接数、速度限制等。事件通知：可以通过 RPC 接口获取下载完成或出错的通知。
Vue3列表（List）
Mr Dear的博客
08-15 733
通用列表，支持：是否显示分割线；是否显示边框；三种尺寸；加载中；暂无数据；显示悬浮样式；列表添加操作项；自定义样式；竖排分页列表；总之；功能丰富，简单易用😁😁
26-vector arraylist和linkedlist的区别
weixin_41775999的博客
08-17 378
取决于你的具体需求，包括是否需要线程安全、数据的操作频率和类型（插入、删除、随机访问等），以及预期的数据量大小‌。‌ 是同步的，即线程安全的，它的所有方法都是同步的，
Java基础——IService.class 中查询数据方法list() 源码剖析及使用
qq_42631788的博客
08-19 323
功能：根据传入的查询符合条件的所有记录。参数Wrapper<T>实例，用于定义查询条件。这可以是或，允许你以链式调用的方式构建查询条件。返回值：符合查询条件的记录列表。使用方法功能：分页查询符合条件的记录，返回当前页的数据列表。参数pageIPage<T>实例，用于指定分页信息，如当前页码和每页记录数。通常使用Page<T>类的实现。Wrapper<T>实例，用于定义查询条件。返回值：当前页符合条件的记录列表。使用方法// 第1页，每页10条记录功能。
LeetCode链表专题：高效反转策略与递归解法
"LeetCode算法数据结构专训笔记，涵盖了链表、栈、递归等常见数据结构和算法，旨在提升编程能力与解决问题的技巧。笔记详细解释了如何使用不同方法，如头插法和栈，来解决链表反转问题，并通过递归深入理解反转逻辑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值