Leedcode刷题——3 链表

已于 2024-03-22 20:54:35 修改
阅读量443 收藏 9
点赞数 3
文章标签： 链表 数据结构
于 2024-02-06 11:32:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/as_your_heart/article/details/135766846
版权

注：以下代码均为c++

数据结构的定义与创建：

//数据结构的定义
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* createLink(vector<int> l){
    ListNode* head = new ListNode();
    ListNode* r = head, * s = head;
    for(auto a: l){
        s = new ListNode();
        s->val = a;
        r->next = s;
        r = s;
    }
    r->next = NULL;
    return head->next;
}
// 输出单链表的value
while(cur)
{
    cout << cur->val << " ";
    cur = cur->next;
}
cout << endl;

1. 删除链表的倒数第N个节点

在这里插入图片描述
思路：快慢指针
在这里插入图片描述

//注：这里的链表都没有头节点
ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* dummy = new ListNode(-1);  //因为有可能删除第一个节点，所以建一个头节点指向第一个节点，便于将第一个节点与其他节点统一处理。
    dummy->next = head;
    ListNode* first = dummy, *second = dummy;
    while(n--)  //first先走n步
        first = first->next;
    while(first->next){  //first走到头时，second走到倒数n+1个
        first = first->next;
        second = second->next;
    }
    second->next = second->next->next;
    return dummy->next;
}

2. 删除链表中的节点

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
思路：
在这里插入图片描述
“伪装”
我们知道要想删除当前节点必须知道它的上一节点，但我们只有当前要删除的节点地址，无法找到上一节点。
所以，我们将要删除的node伪装成下一个点，再将下一个点删掉。

void deleteNode(ListNode* node) {
    //node->val = node->next->val;
    //node->next = node->next->next;

    // 可以将上面两句话合并为一句话，因为链表的数据结构为结构体，其存储的val和next的地址是相邻的，
    // 我们将当前节点的val，next复制为下一节点的val，next，可以一起操作。
    *(node) = *(node->next);  //当前节点的地址 = 下一节点的地址
}

3. 删除排序链表中的重复元素

在这里插入图片描述
在这里插入图片描述
思路：
在这里插入图片描述

ListNode* deleteDuplicates(ListNode* head){
    ListNode* cur = head;
    while(cur){
        if(cur->next && cur->next->val == cur->val)
            cur->next = cur->next->next;
        else
            cur = cur->next;
    }
    return head;
}

4. 删除排序链表中的重复元素2

在这里插入图片描述
在这里插入图片描述

ListNode* deleteDuplicates(ListNode* head) {
    //设头节点
    ListNode* h = new ListNode();
    h->next = head;

    ListNode* first, *second;  //first指向不重复节点的尾部, second寻找下一个不重复节点
    first = h;
    second = first->next;

    while(second && second->next){
        if(second->val == second->next->val){
            while(second->next && second->val == second->next->val)
                second = second->next;
            second = second->next;
        }
        else{
            first->next = second;
            first = second;
            second = second->next;
        }
    }
    first->next = second;
    return h->next;
}

5. 旋转链表

在这里插入图片描述
在这里插入图片描述
思路：快慢指针
在这里插入图片描述

ListNode* rotateRight(ListNode* head, int k) {
    if(head == NULL)
        return head;
    //求n
    int n = 0;
    for(ListNode* p = head; p; p = p->next)
        n++;
    k = k % n;
    //定义快慢指针，快指针先走k步
    ListNode* first, *second;
    first = head;
    second = head;
    while(k--)
        second = second->next;
    //两指针同时走，直到快指针走到头
    while(second->next){
        first = first->next;
        second = second->next;
    }
    //旋转
    second->next = head;
    head = first->next;
    first->next = NULL;

    return head;
}

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

在这里插入图片描述
在这里插入图片描述
思路：
在这里插入图片描述

//2 建立头节点，因为对第一个节点进行操作，所以设置头节点来处理较为容易
ListNode* swapPairs(ListNode* head){
    ListNode* dummy = new ListNode();
    dummy->next = head;
    ListNode* p = dummy;
    while(p->next && p->next->next){
        ListNode *a = p->next, *b = p->next->next;
        p->next = b;
        a->next = b->next;
        b->next = a;
        p = a;
    }
    return dummy->next;
}

7. 反转链表

在这里插入图片描述
在这里插入图片描述
思路：
请添加图片描述

ListNode* reverseList(ListNode* head) {
    if(head == NULL || head->next == NULL)
        return head;
    ListNode* p = head, *q = p->next, *t = q->next;
    while(t){
        q->next = p;
        p = q;
        q = t;
        t = t->next;
    }
    q->next = p;  //这一步容易遗忘，当t=NULL时没有进入循环，直接退出了，需要补充一句。
    head->next = NULL;
    head = q;  //也可以不要这一句，直接返回q
    return head;
}

8. 反转链表2

在这里插入图片描述
在这里插入图片描述
思路：
在这里插入图片描述

ListNode* reverseBetween(ListNode* head, int left, int right) {
    if(left == right)
        return head;

    int i;
    //建立头节点
    ListNode* dummy = new ListNode();
    dummy->next = head;
    head = dummy;
    //找到first和second的位置，first->next是第一个要翻转的点，second是最后一个要翻转的点。
    ListNode* first = head, *second;
    for(i = 1; i < left; i++)
        first = first->next;
    second = first->next;
    for(i = 1; i <= right - left; i++)
        second = second->next;
    //翻转
    ListNode* p = first->next, *q = p->next, *t = q->next;
    while(t != second->next){
        q->next = p;
        p = q;
        q = t;
        t = t->next;
    }
    q->next = p;
    first->next->next = t;
    first->next = second;

    return head->next;
}

9. 相交链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
思路：
在这里插入图片描述

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    ListNode* p = headA, *q = headB;
    while(p != q){  //注意这个while循环内部一定是if-else，这种结构的语句，不然会出现问题。
        if(p == NULL)
            p = headB;
        else
            p = p->next;
        if(q == NULL)
            q = headA;
        else
            q = q->next;
    }
    return p;
}

10. 环形链表2

在这里插入图片描述
在这里插入图片描述
思路1：哈希表（我看这道题的第一个想法）
一个非常直观的思路是：我们遍历链表中的每个节点，并将它记录下来；一旦遇到了此前遍历过的节点，就可以判定链表中存在环。借助哈希表可以很方便地实现。
思路2：快慢指针
（1）
快指针：一次走两步（红色）
慢指针：一次走一步（蓝色）
快慢指针一起走，假设当慢指针走到b点时，快指针走到c’点，那么快慢指针将在c点相遇。
在这里插入图片描述
（2）
快慢指针相遇后，将慢指针指向链表头部，快慢指针均一次走一步，快慢指针将在b点相遇，即环的起始点。
在这里插入图片描述

ListNode *detectCycle(ListNode *head) {
    ListNode *quick = head, *slow = head;
    //注意开始需要将quick和slow走起来，因为如果开始不走，quick=slow，无法进入下面while循环
    if(quick == NULL || (quick != NULL && quick->next == NULL))
        return NULL;
    quick = quick->next->next;
    slow = slow->next;

    while(quick != slow  && quick && quick->next){  //注意quick和quick->next需要判空
        quick = quick->next->next;
        slow = slow->next;
    }
    if(quick != slow)  //如果遇到空就说明不是环，返回NULL
        return NULL;
    slow = head;
    while(quick != slow){
        quick = quick->next;
        slow = slow->next;
    }
    return quick;
}
黎栗栗
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Leetcode刷题总结——链表
weixin_47883447的博客
05-17 279
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。 链接的入口节点称为链表的头结点也就是head。 数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。 链表是通过指针域的指针链接在内存中各个节点。 所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。 学会自己构造一个链表 C++会默认生成一个构造函数，
LeetCode刷题——旋转图片
12-23
旋转图片题目的思路探讨与源码 旋转图片的题目如下图，核心是把一个矩阵进行顺时针90度的旋转，并且只能在当前矩阵上改动，不能新建矩阵，所以只需要把该矩阵旋转...matrix=[[1,2,3],[4,5,6],[7,8,9]] print(matrix)
leetcode刷题——链表
xxp的博客
03-12 271
leetcode刷题——链表
Leetcode刷题——链表
weixin_47156261的博客
01-14 410
Leetcode刷题-链表一、链表定义一、Leetcode题目1.移除链表元素 一、链表定义 c++链表节点定义方式： // 单链表 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; 自己定义构造函数初始化节点： ListNode *head=new ListNode(5) 使用默
LeetCode刷题笔记3——链表
weixin_47692652的博客
03-15 463
LeetCode刷题笔记3——链表
LeetCode刷题day3——链表part1
nosnef的博客
06-21 401
问题：1.不知道初始化什么对象，以及里面要定义哪些值。2.index非法情况怎么具体在代码中体现。3.边界处理不到位，比如=size =0这些我还自己分开讨论，其实可以写在一起。所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！注意卡哥说的在C++里面，要自己定义，leetcode里面默认的是可以直接赋值的。这个题是二刷了一开始这个思路就是利用虚拟头结点，但是中间很多小细节都考虑不到，例如初始化一个新的链表，循环条件的写法等。考虑用双指针法，但自己想的时候还是串联不起来思路。
leetcode刷题笔记——链表操作
weixin_53432918的博客
10-08 70
【代码】leetcode刷题笔记——链表操作。
leetcode刷题记录——链表
GZW18620285024的博客
09-01 327
leetcode链表
Leetcode刷题——重排链表
qq_43403657的博客
07-02 286
单链表求中间结点，逆转，合并操作
leetcode刷题——链表篇
qq_43651945的博客
05-11 231
例题1移除链表的指定元素 203. 移除链表元素 - 力扣（LeetCode） (leetcode-cn.com) 头部的处理和后续的处理有不同，所以有两种处理方式； 方式一先处理头部 while(head!=null && head.val==val){ head=head.next; } if(head==null) return head; //头结点为空直接结束 方式二加入一个新的头结点，统一处理 if (head == null) { re
LeetCode刷题——链表1
fudaodao的博客
09-10 126
LeetCode刷题——数组1链表定义移除链表元素 链表定义 单链表 struct ListNode { int val; ListNode* next; ListNode(int x): val(x),next(nullptr){} }; 双链表 移除链表元素 题目链接. 题意：删除链表中所有满足 Node.val == val 的节点，并返回新的头节点 。 关键：如果删除头节点，怎么处理。 思路：使用一个虚拟头节点指向头节点 class Solution { public:
LeetCode刷题——Complex multiplication复数乘法
12-21
复数乘法题目的思路探讨与源码 复数乘法的题目如下图，该题属于字符串类的题目，主要考察split函数以及字符串函数转整型以及四则运算，虽然属于中级但是难度相对较低。只要区分实数部分和虚数部分即可。...
LeetCode刷题——矩阵置零
12-21
矩阵置零题目的思路探讨与源码 矩阵置零的题目如下图，核心把矩阵中当前0元素所在的行和列都重置为0，并且只能在当前矩阵上改动，不能新建矩阵，所以要使用下标进行标记，并最终重新赋值。 原创文章 40获赞 41访问...
LeetCode刷题——91. 解码方法
12-20
题目 ...输出: 3 解释: 它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/decode-ways 思路 这个题有点像爬楼梯，但是
【数据结构】堆的实现和堆排序--TOP-K问题
最新发布
2301_78724721的博客
06-21 1040
在头文件中进行堆的定义和接口的声明int size;}HP;//堆的初始化//堆的销毁//堆的插入//堆的删除//取堆顶的数据// 堆的数据个数//堆的判空堆的实现堆是一种特殊的树形数据结构，通常实现为完全二叉树。堆分为最大堆和最小堆，最大堆的父节点值大于或等于其子节点值，而最小堆的父节点值小于或等于其子节点值。堆通常使用数组来实现，通过索引关系模拟树形结构，支持高效的插入、删除和查找最大/最小元素操作。堆排序堆排序是一种基于堆的排序算法。
【数据结构】顺序表
奋斗的小羊的博客
06-18 1913
顺序表超超超详解
伸展树(数据结构篇)
hellmorning的博客
06-20 736
讲解数据机构中的伸展树
嵌入式学习——数据结构（双向无头有环链表、内核链表、栈）——day48
qq_47798402的博客
06-21 362
先进后出 first in last out。增：栈顶指针向内存高地址移动（0x1000低地址 ——0x2000高地址）快指针每走一步，判断是否为空或者是否与慢指针相遇。只允许从一端进行插入和删除的数据结构称为栈。利用快慢指针判断是否相遇。2. 函数的形参、返回值。浏览器返回上一层操作。满、空栈：栈顶所在位置是否存有数据。减：栈顶指针向内存低地址移动。1. 判断单向链表是否有环。
leetcode刷题手册c++版
09-07
LeetCode刷题手册C版是一本针对程序员刷题的教材，旨在帮助他们提高编程能力、学习算法和数据结构。C语言作为一门广泛应用于系统编程和嵌入式开发的语言，在LeetCode刷题中也是非常重要的一种编程语言。 这本手册主要包括了LeetCode网站上的题目分类和解题思路。它以系统的方式组织了数百道LeetCode题目，并提供了针对每道题目的解题思路和详细的C语言代码实现。通过这本手册，程序员可以快速了解各种算法和数据结构的特点，掌握它们在解决实际问题中的应用。 LeetCode刷题手册C版的优势在于它提供了C语言的实现和相关的技巧。C语言是一种高效、灵活且广泛使用的编程语言，掌握C语言的编程技巧能够帮助程序员更好地理解算法和数据结构的原理，并设计出高质量的代码。此外，C语言也是很多面试中常见的编程语言，因此掌握LeetCode刷题手册C版可以帮助程序员在面试中更好地展示自己的技术能力。 总之，LeetCode刷题手册C版是一个针对C语言程序员的宝贵资源，它可以帮助程序员提升编程能力、学习算法和数据结构，并在面试中展现自己的优势。通过刷题手册C版的学习，程序员可以更好地理解LeetCode题目，提高解题效率，进一步提升自己的技术水平。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值