代码随想录leetcode200题之链表

已于 2024-05-06 01:14:59 修改
阅读量320 收藏 4
点赞数 2
分类专栏： 代码随想录leetcode200题 文章标签： 链表 数据结构
于 2024-05-05 16:41:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ymwm_/article/details/138463851
版权

目录

1 介绍

本博客用来记录代码随想录leetcode200题中链表部分的题目。

2 训练

题目1：203移除链表元素

C++代码如下，

/**
 * 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* removeElements(ListNode* head, int val) {
        ListNode* p = new ListNode(0, head);
        ListNode* res = p;
        while (p->next != nullptr) {
            if (p->next->val == val) p->next = p->next->next;
            else p = p->next;
        }

        return res->next;
    }
};

python3代码如下，

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        p = ListNode(0, head)
        res = p
        while p.next is not None:
            if p.next.val == val:
                p.next = p.next.next 
            else:
                p = p.next 
        return res.next

题目2：707设计链表

C++代码如下，

// struct ListNode {
//     int val;
//     ListNode* next;
//     ListNode() : val(0), next(nullptr) {}
//     ListNode(int x) : val(x), next(nullptr) {}
//     ListNode(int x, ListNode* nx) : val(x), next(nx) {}
// };

class MyLinkedList {
private:
    ListNode* head; //head无实际含义

public:


    MyLinkedList() {
        head = new ListNode(0);
    }
    
    int get(int index) {
        //时间复杂度O(N)
        int i = 0;
        ListNode* p = head->next;
        while (p != nullptr) {
            if (i == index) return p->val;
            p = p->next;
            i += 1;
        }
        return -1;
    }
    
    void addAtHead(int val) {
        //时间复杂度O(1)
        ListNode* p = new ListNode(val, head->next);
        head->next = p; 
    }
    
    void addAtTail(int val) {
        //时间复杂度O(N)
        ListNode* p = head;
        while (p->next != nullptr) p = p->next;
        ListNode* t = new ListNode(val);
        p->next = t;
    }
    
    void addAtIndex(int index, int val) {
        //时间复杂度O(N)
        ListNode* p = head; //p从头结点开始算
        int i = 0;
        while (p != nullptr && i < index) {
            p = p->next;
            i += 1;
        }

        if (p == nullptr) return;

        ListNode* t = new ListNode(val, p->next);
        p->next = t;
    }
    
    void deleteAtIndex(int index) {
        //时间复杂度为O(N)
        ListNode* p = head; //p从头结点开始算
        int i = 0;
        while (p != nullptr && i < index) {
            p = p->next;
            i += 1;
        }

        if (p == nullptr || p->next == nullptr) return;

        p->next = p->next->next;
    }
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

python3代码如下，

class MyLinkedList:

    def __init__(self):
        self.head = ListNode(0)


    def get(self, index: int) -> int:
        #时间复杂度为O(N)
        i = 0
        p = self.head.next 
        while p is not None:
            if i == index:
                return p.val 
            p = p.next 
            i += 1
        return -1

    def addAtHead(self, val: int) -> None:
        #时间复杂度为O(1)
        p = ListNode(val, self.head.next)
        self.head.next = p

    def addAtTail(self, val: int) -> None:
        #时间复杂度为O(N)
        p = self.head 
        while p.next is not None:
            p = p.next 
        t = ListNode(val)
        p.next = t 

    def addAtIndex(self, index: int, val: int) -> None:
        #时间复杂为O(N)
        p = self.head 
        i = 0
        while p is not None and i < index:
            p = p.next 
            i += 1
        
        if p is None:
            return 
        
        t = ListNode(val, p.next)
        p.next = t 

    def deleteAtIndex(self, index: int) -> None:
        #时间复杂度为O(N)
        p = self.head 
        i = 0
        while p is not None and i < index:
            p = p.next 
            i += 1
        
        if p is None or p.next is None:
            return 
        
        p.next = p.next.next 



# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

题目3：206. 反转链表

C++代码如下，

/**
 * 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* reverseList(ListNode* head) {
        if (head == nullptr || head->next == nullptr) { //特判空集或一个结点的时候
            return head;
        }

        ListNode* a = head;
        ListNode* b = a->next;

        while (a != nullptr && b != nullptr) {
            ListNode* t = b->next;
            b->next = a;

            a = b;
            b = t;
        }
        
        head->next = nullptr;
        return a;
    }
};

python3代码如下，

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if head is None or head.next is None: #特判空集和一个结点的情况
            return head 

        a = head 
        b = a.next 
        while a is not None and b is not None:
            t = b.next

            b.next = a 

            a = b
            b = t 
        
        head.next = None 
        return a

题目4：24两两交换链表中的节点

C++代码如下，

/**
 * 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) {
        if (head == nullptr || head->next == nullptr) { //特判空集或者只有一个结点的情况
            return head;
        }

        ListNode* a = head;
        ListNode* b = a->next;

        ListNode* res = b;
        ListNode* aprev = nullptr;

        while (a != nullptr && b != nullptr) {
            ListNode* t = b->next;

            b->next = a;
            a->next = t;
            if (aprev != nullptr) aprev->next = b;

            aprev = a;
            a = t;
            if (a != nullptr) b = a->next;
            else break;
        }

        return res;
    }
};

python3代码如下，

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if head is None or head.next is None: #特判空集或者一个结点的情况
            return head 
        
        a = head 
        b = a.next 
        aprev = None 

        res = b 

        while a is not None and b is not None:
            t = b.next 

            b.next = a 
            a.next = t 
            if aprev is not None:
                aprev.next = b
            
            aprev = a 
            a = t
            if a is not None:
                b = a.next 
            else:
                break
        
        return res

题目5：19删除链表的倒数第 N 个结点

C++代码如下，

/**
 * 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* removeNthFromEnd(ListNode* head, int k) {
        //删除倒数第k个结点，快慢指针法

        ListNode* dummy = new ListNode(0, head);

        ListNode* a = dummy;
        ListNode* b = dummy;

        while (k--) { //b先走k步
            b = b->next;
        }

        while (b->next != nullptr) { //b走到最后一个结点
            a = a->next;
            b = b->next;
        }

        if (a->next != nullptr) a->next = a->next->next;
        else cout << "a->next is nullptr!" << endl;

        return dummy->next;
    }
};

python3代码如下，

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        dummy = ListNode(0, head)
        a = dummy
        b = dummy 

        while k > 0:
            b = b.next
            k -= 1

        while b.next is not None:
            b = b.next 
            a = a.next 
        
        a.next = a.next.next 
        return dummy.next

题目6：面试题 02.07. 链表相交

C++代码如下，

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA == nullptr || headB == nullptr) { //特判都为空集，或者有一方为空集的情况
            return nullptr;
        }
        
        ListNode* a = headA;
        ListNode* b = headB;

        bool flaga = true;
        bool flagb = true;
        while (a != b) {
            a = a->next;
            b = b->next;

            if (a == nullptr) {
                if (flaga) {
                    a = headB;
                    flaga = false;
                } else {
                    break;
                }
            }

            if (b == nullptr) {
                if (flagb) {
                    b = headA;
                    flagb = false;
                } else {
                    break;
                }
            }
        }

        if (a == b) return a;
        else return nullptr;
    }
};

python3代码如下，

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        if headA is None or headB is None:
            return None 
        
        a = headA 
        b = headB 
        flaga = True
        flagb = True 
        while a != b:
            a = a.next 
            b = b.next 

            if a is None:
                if flaga:
                    a = headB 
                    flaga = False
                else:
                    break 
            
            if b is None:
                if flagb:
                    b = headA 
                    flagb = False 
                else:
                    break 
        
        if a == b:
            return a 
        else:
            return None

题目7：142. 环形链表 II

C++代码如下，

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        //这次的快慢指针，是速度上的快慢指针，而非提前走的快慢指针
        ListNode* a = head;
        ListNode* b = head;

        while (b != nullptr && b->next != nullptr) {
            a = a->next;
            b = b->next->next;

            //起点到环入口的距离为x
            //快慢指针相遇点到环入口的距离为y
            //环的周长为c
            //有x % c = y恒成立
            if (a == b) { 
                ListNode* t = head;
                while (t != a) {
                    t = t->next;
                    a = a->next;
                }
                return a;
            }
        }
        return nullptr;
    }
};

python3代码如下，

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        a = head 
        b = head 

        while b is not None and b.next is not None:
            a = a.next 
            b = b.next.next 

            if a == b:
                t = head 
                while t != a:
                    t = t.next 
                    a = a.next 
                return a 
        return None

3 参考

代码随想录官网

YMWM_
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode算法题-链表操作（两数相加）
12-20
在LeetCode上，有一道经典的算法题，名为“两数相加”（Add Two Numbers）。题目要求使用两个非空的链表来表示两个非负整数，这些整数的每一位都是逆序存储的，即链表的头部表示最高位。每个链表节点仅能存储一个...
《代码随想录》LeetCode 刷题攻略：200道经典题目刷题顺序，共60w字的详细图解，视频难点剖析，50余张思维.zip
02-21
《代码随想录》是一本专注于LeetCode刷题攻略的资源集合，旨在帮助程序员提升算法能力和编程技巧。这本书包含了200道精心挑选的经典题目，覆盖了数据结构、算法、设计模式等多个方面，总计约60万字的详细解析，配以...
代码随想录 LeetCode链表篇 Java
guliguliguliguli的博客
05-15 417
用head表示原始链表的头节点，新的链表的第二个节点，用newHead表示新的链表的头节点，原始链表的第二个节点，则原始链表中的其余节点的头节点是newHead.next。如果temp的后面没有节点或者只有一个节点，则没有更多的节点需要交换，因此结束交换。根据栈【先进后出】的原则，弹出栈的第n个节点就是需要删除的节点，并且，目前栈顶的节点就是待删除节点的前驱节点。如果链表中至少有两个节点，则在两两交换链表中的节点之后，原始链表的头节点编程新的链表的第二个节点，原始链表的第二个节点变成新的链表的头节点。
【leetcode刷题总结】——代码随想录（链表总结）
lingxw的博客
05-18 2998
什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
LeetCode代码随想录
死也不承认自己笨的博客
05-07 1137
代码随想录 (programmercarl.com) java 35.搜索插入位置 34.在排序数组中查找元素的第一个和最后一个位置 java 69.X的平方根 java java 27移除元素 c++ java 283.移动零 java 844.比较含退格的字符串 java:双指针版 java:栈版 97.有序数组的平方 c++ java
代码随想录LeetCode | 链表问题总结
weixin_40142386的博客
11-18 283
链表LeetCode刷题；刷题模式优化：记录做不出来时想的思路
代码随想录LeetCode | 链表刷题总结II
weixin_40142386的博客
11-19 169
链表刷题进阶题目：两两交换链表中的节点 删除链表的倒数第N个节点 链表相交 环形链表II
代码随想录leetcode刷题60天之三
weixin_57647564的博客
11-06 171
自我解释：就是移除一个链表中的一个元素，比较关键的点是如果是第一元素是不是需要另外判断一下,所以如果用一个比较统一的方式来做这一道题的话，就是加一个dummy head。有几个地方第一次写的时候是错的， delete这个写错了，else忘记写了，这个是个基础题，但是有些边界如果没有注意的话也会出错。这道题应该算比较基础的题。203.移除链表元素。
[C++学习] 链表 相交链表 环形链表II 代码随想录 LeetCode题 代码 笔记
最新发布
qq_49696822的博客
07-17 32
是一种基于哈希表的数据结构，用于存储不重复的元素，与 set（集合，一个内部自动有序且不含重复元素的容器）不同，unordered_set 不保证元素的有序性，但提供了更快的平均查找时间复杂度。利用哈希集合，判断节点是否已经被添加进哈希集合，若集合中存在该节点，则该节点为入环的第一个节点，返回该节点。求出两个链表的长度和差值，让 curA 移动到和 curB 末尾对齐的位置，比较链表内元素是否相等，若相等则为相交节点，返回该节点。该题目的求解有两种思路，一种是对齐链表后比较节点是否相等，一种是利用。
[C++学习] 链表 移除链表元素 设计链表 代码随想录 LeetCode题 代码 笔记
qq_49696822的博客
07-12 165
用法：用来申请动态空间，返回类型为同变量类型的指针(在堆区开辟内存)，需要手动 delete 释放。：设置一个虚拟头节点，作为新的头节点。这样在删除列表元素时，如果要删除的是头结点，不需要特殊处理。c++中，变量名加前缀 ‘_’ 是一种命名约定，用于区分类的成员变量与局部变量。的一些基础知识：链表的结点由两部分组成——数据域和指针域，指向下一个结点的地址。（关于头节点是否要存数据，力扣上的会存。来创建链表中的新结点，用来枚举结点的变量。包含了链表的常见操作，较为简单。存放结点要存储的数据，
代码随想录 Leetcode707. 设计链表
meeiuliuus的博客
01-11 563
写在文后：这道题太考验细节了，我因为各种小错误改了好久不对，最后实在没办法了和参考答案一行一行对才通过，发现是delete里的if中的第一个条件没有写=号，人晕了。
java-leetcode题解之第61题旋转链表.zip
06-05
【压缩包子文件的文件名称列表】：只有一个文件名“java_leetcode题解之第61题旋转链表”，这很可能是一个包含Java源代码的文件，可能命名为`.java`扩展名，用于描述如何将链表旋转指定的步数。代码通常会包含类定义...
java-leetcode题解之第148题排序链表.zip
06-17
这个资源包"java_leetcode题解之第148题排序链表"应该包含了解决此问题的Java代码实现，你可以通过阅读和学习这段代码来加深对链表排序的理解，也可以尝试自己动手实现，从而进一步巩固链表操作和排序算法的知识。...
java-leetcode题解之第141题环形链表.zip
06-17
在本压缩包中，我们关注的是Java编程语言与LeetCode平台上的第141题——环形链表。这道题目是数据结构和算法领域的一个经典问题，主要考察对链表的理解以及如何检测一个链表是否存在环。我们将深入探讨这个问题，并...
数据结构—链式二叉树-C语言
h_number_1的博客
07-11 1039
上述内容，即是我个人对数据结构-链式二叉树-搜索二叉树-C语言的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。
数据结构专项-字符串
qq_52241267的博客
07-16 255
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。深拷贝和浅拷贝：浅拷贝实际上是复制了被拷贝对象的引用，也就是说浅拷贝的和被拷贝对象指向的是同一块内存空间，而深拷贝则是连同引用的对象也被拷贝，两者指向的是不同的内存空间。然后计算乘法，故之后是*，再计算加法，因此+要在6的前面，不然就是计算4*(x+3)+6了，故选D。中缀表达式中应该先计算x+3，因此后缀表达式中+应该出现在x和3的后面，排除BC。
【Java--数据结构】二叉树
2301_80898480的博客
07-16 863
如有错误，欢迎指出~
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1731
栈超超超详解
「代码随想录」背包问题专题精讲（v1.0）.pdf
08-03
"「代码随想录」背包问题专题精讲（v1.0）是一份深入讲解背包问题的PDF资料，由知名博主Carl编写。该专题覆盖了LeetCode中的经典背包问题，包括但不限于动态规划（Dynamic Programming, dp）算法的应用，如DP表格法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YMWM_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值