力扣刷题链表篇

最新推荐文章于 2023-03-18 19:51:17 发布
最新推荐文章于 2023-03-18 19:51:17 发布
阅读量135 收藏
点赞数
分类专栏： Leetcode刷题 文章标签： 链表 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57041698/article/details/118576489
版权

141. Linked List Cycle

题目地址
解题思路:

  1. 快慢指针,创建指针p每次前进一格,创建指针q每次前进二格,步长过大会增加pq相遇的时间。
  2. p, q的初始位置不同，原因是当只存在一个节点时，while循环会因为q的下一节点为NULL跳出循环，返回true值（当然也可以在while中做判断）
  3. whlie中 q != NULL && q->next != NULL 条件是为了防止q指向空指针。
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == NULL) return false;
        ListNode *p = head, *q = head->next;
        while(q != NULL && q->next != NULL && q != p){
            p = p->next;
            q = q->next->next;
        }
        return q==p;
    }
};

142. Linked List Cycle II

题目地址
解题思路：
基于快慢指针的思想，假设当q的步长是p的两倍时，head节点到 循环链表起点 距离为a个节点:

  1. 如下图所示，当p到达循环起点时,q已经在循环链表中走了a个节点，设q到p的距离为x，则循环链表周长为 a+x
    在这里插入图片描述
  2. 当p走了x，q就走了2x，此时两节点相遇，注意此时p和q到循环起点的距离为a，等于head到链表起点的距离。
    在这里插入图片描述
  3. 如图所示，重新让q指向head节点，当p, q再次相遇时，就会位于循环起始点。
    在这里插入图片描述
    代码实现：
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(head == NULL) return NULL;
        ListNode *p = head, *q = head;
        while(q && q->next){
            p = p->next;
            q = q->next->next;
            //if判断语句放在循环内仍然是为了考虑单个节点
            if(q == p){
	            q = head;
	            while(q != p){
	                q = q->next;
	                p = p->next;
	            }
	            return p;
        	}
        }
        return NULL;
    }
};

202. Happy Number

题目地址
解题思路：
如图所示，快乐数的推导过程可以看作是由自身节点推出下一个节点，最后输出相同的值时即为进入循环链表(快乐数会进入1循环，数字2会进入20循环)。所以仍然可以使用快慢指针判断。
在这里插入图片描述

class Solution {
public:
    
    int getNext(int x){
        int sum = 0;
        while(n){
            sum += (n % 10)*(n % 10);
            n = n/10;
        }
    }
    
    bool isHappy(int n) {
        int p = n, q = n;
        do{
            p = getNext(p);
            q = getNext(getNext(q)); 
        }while(q != p && q != 1)
        return q == 1;   
    }
};

206.reverse linked list

题目地址
解题思路：
创建三个指针：pre, cur, next
指针操作步骤：

  1. 定义 pre 为空指针
  2. cur 指向 pre 指向的节点
  3. pre 指向 cur 指向的节点
  4. cur 指向 next 指向的节点
  5. next 指向 next 的下一个节点
  6. 重复 2~6 直到 cur 指向最后的空节点

下图显示了上面描述的指针操作过程
在这里插入图片描述
上图的代码实现

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head-> next == nullptr) return head;
        ListNode *pre = nullptr, *cur = head, *p = head -> next;
        while(cur){
            cur -> next = pre;
            pre = cur;
            //这里是为了防止最后 p节点为空，会出现错误
            (cur = p) && (p = p -> next);
        }
        return pre;
    }
};

另一种思路是使用递归
如下图所示，交换 head节点 和 tail节点 的位置

代码实现为

head -> next = tail -> next;
tail -> next = head;

将上述思路通过递归的方式，从最后的节点开始逐对反转

代码实现：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head->next == nullptr) return head;
        ListNode *tail = head -> next, *p = reverseList(head -> next);//p 是最后的结点，也就是反转后的头结点
        head -> next = tail -> next;
        tail -> next = head;
        return p;
    }
};

92.reverse linked list II

解法1：使用上面的常规的三指针操作，记录起始反转位置(left)的前一个结点 head 和终止反转位置(rigtht)的后一个结点 pre。
在这里使用了 ret结点 作为头结点的前置结点，目的是便于找到反转链表的起始点。

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        if(head == nullptr || head -> next == nullptr || left == right) return head;
        ListNode ret(0,head), *hair = &ret, *pre = head;
        int m = left, n = right, cnt = n - m + 1;
        while(--m) hair = hair -> next;
        
        while(n){
            pre = pre -> next;
            n--;
        }
        
        ListNode *cur = hair -> next, *p = hair -> next -> next;
        while(cnt){
           cur -> next = pre;
            pre = cur;
            (cur = p) && (p = p -> next); 
            cnt--;
        } 
        hair -> next = pre;
        return ret.next;
    }
};

解法2：只需要调用上面的递归函数，并稍作修改。原函数的递归最底层为最后一个结点，现在为反转链表范围的最后结点

class Solution {
public:
    ListNode* reverseList(ListNode* head, int n) {
        if(n == 1) return head;
        ListNode *tail = head -> next, *p = reverseList(head -> next, --n);
        head -> next = tail -> next;
        tail -> next = head;
        return p;
    }
    
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        if(head == nullptr || head -> next == nullptr || left == right) return head;
        ListNode ret(0,head), *hair = &ret;
        int m = left, n = right, cnt = n - m + 1;
        while(--m) hair = hair -> next;
        hair -> next = reverseList(hair -> next, cnt);
        
        return ret.next;
    }
};

25. Reverse Nodes in K-Group

题目地址
完全是基于上边已有的代码，非常简单
reverseK() 函数中有一个小技巧，如果传入的链表长度小于规定的长度，直接返回原链表，然后 reverseKGroup(）中通过判断返回的链表头结点是否为原来的结点来决定是否跳出循环

class Solution {
public:
    ListNode* reverseList(ListNode* head, int n) {
        if(n == 1) return head;
        ListNode *tail = head -> next, *p = reverseList(head -> next, --n);
        head -> next = tail -> next;
        tail -> next = head;
        return p;
    }
    
    ListNode* reverseK(ListNode* head, int k) {
        ListNode *p = head;
        int cnt = k;
        while(--k && p) p = p -> next;
        if(p == nullptr) return head;
        return reverseList(head, cnt);
    }
    
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode ret(0, head), *p = &ret, *q = p -> next;
        while((p -> next = reverseK(q, k)) != q) {
            p = q;
            q = q -> next;
        }    
        return ret.next;
    }
};

61. Rotate List

题目地址
解题思路:
将链表首尾连接,寻找断点并断开

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(head == nullptr || head->next == nullptr) return head;
        int n = 1;
        ListNode*p = head;
        while(p->next){
            p = p->next, n++;
        }
        p->next = head;
        
        k %= n, k = n - k;
        while(k--) p = p->next;
        head = p->next;
        p->next = nullptr;
        return head;
    }
};

19. Remove Nth Node From End of List

地址

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode ret(0, head), *p = &ret, *q = head;
        while(n--) q = q->next;
        while(q != nullptr) p = p->next, q = q->next;
        p->next = p->next->next;
        return ret.next;
    }
};

83. Remove Duplicates from Sorted List

题目地址

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head == nullptr) return nullptr;
        ListNode *p = head;
        while(p->next){
            if(p->val == p->next->val){
                p->next = p->next->next;
            }else{
                p = p->next;
            }
        }
        return head;
    }
};

82. Remove Duplicates from Sorted List II

题目地址

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        
        if(head == nullptr || head->next == nullptr) return head;
        ListNode ret(0,head), *p = &ret, *q;
        while(p->next){
            if(p->next->next && p->next->val == p->next->next->val){
                q = p->next->next;
                while(q && q->val == p->next->val) q = q->next;
                p->next = q;
            }else{
                p = p->next;
            }
        }
        
        return ret.next;
    }
};

24. Swap Nodes in Pairs

地址

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == nullptr || head->next == nullptr) return head;
        ListNode ret(0, head), *q = &ret, *p = head;
        while(p && p->next){
            q->next = p->next;
            p->next = p->next->next;           
            q->next->next = p;
            q = q->next->next;
            p = p->next;
        }
        return ret.next;
    }
};

86. Partition List

地址

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        if(head == nullptr || head->next == nullptr) return head;
        ListNode ret(0, head), *p = &ret, *q = head, *m;
        while(q->next && p->next){
            while(p->next && p->next->val < x) p = p->next;
            q = p;
            while(q->next && q->next->val >= x) q = q->next;
            if(p->next && q->next){
                m = q->next;
                q->next = m->next;
                m->next = p->next;
                p->next = m;  
            }    
        }
        return ret.next;
    }
};

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode h1, h2, *p1 = &h1, *p2 = &h2;
        for(ListNode *p = head, *q; p != nullptr; p = q){
            q = p->next;
            p->next = nullptr;
            if(p->val < x){
                p1->next = p;
                p1 = p;
            }else{
                p2->next = p;
                p2 = p;
            }
        }
        p1->next = h2.next;
        return h1.next;
    }
};

138. Copy List with Random Pointer

地址
复制原链表，将原链表的random赋给random

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == nullptr) return head;
        Node *p = head, *q, *new_head;
        while(p){
            q = new Node(p->val);
            q->next = p->next;
            q->random = p->random;
            p->next = q;
            p = q->next;
        }
        p = head->next;
        while(p){
            if(p->random != NULL){
                p->random = p->random->next;
            }
            p = p->next;
            if(p) p = p->next;
        }
        new_head = head->next;
        p = head;
        while(p){
            q = p->next;
            p->next = q->next;
            if(p->next) q->next = p->next->next;
            p = p->next;
        }
        return new_head;
    }
};
dwfhahaha
关注
专栏目录
力扣刷题篇——链表篇
weixin_59796310的博客
05-22 920
力扣刷题篇——链表篇
力扣刷题：链表篇
轻松的小希
05-29 868
目录1290. 二进制链表转整数题目介绍题目实现138. 复制带随机指针的链表题目介绍[剑指 Offer 35. 复杂链表的复制](https://leetcode-cn.com/problems/fu-za-lian-biao-de-fu-zhi-lcof/)题目实现141. 环形链表题目介绍题目实现160. 相交链表题目介绍[面试题 02.07. 链表相交](https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/)[
力扣刷题总结（链表）
最新发布
m0_64267400的博客
03-18 159
有一个单链表的 head，我们想删除它其中的一个节点 node。给你一个需要删除的节点 node。你将 无法访问 第一个节点 head。链表的所有值都是 唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是：给定节点的值不应该存在于链表中。链表中的节点数应该减少 1。node 前面的所有值顺序相同。node 后面的所有值顺序相同。示例：输入：head = [4,5,1,9], node = 5。
力扣刷题总结之链表
橘嘉禾
03-24 657
2020/3/19：目前正在已经大体通学了（超不牢固），所以现在想重新复习一遍各大结构，顺便做一份笔记总结一些解题套路 1、链表 链表的定义（来自维基百科）： 在计算机科学中，链表作为一种基础的数据结构可以用来生成其它类型的数据结构。链表通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（"links"）。 链表...
学会链表了还不赶紧刷题（力扣刷题笔记）
m0_64770095的博客
06-01 469
C语言刷题笔记，还不会链表相关的，尽快来看看啦！
力扣刷题力扣刷题力扣刷题力扣刷题
07-16
"力扣刷题"通常指的是用户通过反复练习这些题目来提高自己的编程能力。 在力扣上刷题的过程中，你可以接触到以下几个核心知识点： 1. **数据结构**： - 数组：基础的数据结构，用于存储固定大小的同类型元素集合...
力扣刷题精选11111
03-23
《力扣刷题精选11111》是针对编程爱好者和准备面试的开发者们的一份宝贵资源，它聚焦于LeetCode平台上的算法题目，涵盖了数据结构与算法、职场技能和职业发展等多个方面。LeetCode作为全球知名的在线编程挑战平台，...
使用力扣刷题的经验.pdf
04-21
在使用力扣平台刷题提升编程和算法能力的过程中，需要把握几个关键的知识点，以及遵循一定的学习方法和策略。 首先，对于编程初学者来说，掌握一门编程语言是进行算法练习的前提。C语言和Java是比较常见的选择，...
力扣刷题算法截图汇总2021
04-02
2021年的力扣刷题算法截图汇总是一个珍贵的学习资源，它可能包含了当年力扣上的热门问题及其解决方案的截图。由于标签为"python"，我们可以推断这些截图主要涉及使用Python语言解决这些问题。 在Python编程中，解决...
Leetcode:记录力扣刷题之路
03-15
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为程序员提升技能和准备面试而设计。在这个平台上，你可以找到各种算法问题，涵盖数据结构、排序算法、搜索算法、图论等多个领域。本压缩包文件"Leetcode-...
[力扣刷题总结]（链表篇）
weixin_38800498的博客
12-30 1591
文章目录2. 两数相加解法1：链表 2. 两数相加 力扣连接 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例 1： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 示例 2： 输入：l1 = [0], l2 = [0] 输出：[0] 示例.
【21天考研算法带刷leetcode-141】链表双指针法判断子链表（链表匹配）、判断环形链表、判断公共尾部（9/21）
weixin_53118224的博客
09-09 282
【21天考研算法带刷leetcode-141】链表双指针法判断子链表（链表匹配）、判断环形链表、判断公共尾部（9/21）
环形链表
carpe_diem0的博客
10-10 160
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。 说明：不允许修改给定的链表。 public class Solution { public ListNode detectCycle(ListNode head) { ListNode fast
java链表ListNode删除特定值
zyzn1425077119的博客
10-24 1775
转自：qq_17525769的博客，网址：https://blog.csdn.net/qq_17525769/article/details/53915042     package algorithm; import java.lang.ref.WeakReference; /* 删除链表中等于给定值val的所有节点。 样例： 给出链表 1-&gt;2-&gt;3-&gt;3-&...
链表-刷题
m0_51332138的博客
06-06 171
链表 给一个链表的头节点 head 和一个整数 val ，删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 eg: public ListNode removeElements(ListNode head, int val) { while (head != null && head.val == val){ //特殊情况 第一个头节点即为删除的 head = head.next; } Li
leetcode算法题解整理之链表专题部分
weixin_43488529的博客
02-08 573
算法题解之链表专题 链表数据结构 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){} }; 19. 删除链表的倒数第 N 个结点 【题目描述】：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。 【分析
C语言实现删除链表的一个节点
NH4L的博客
01-24 2645
C语言实现删除链表的一个节点 节点表示 struct node { int data; node *next; }; 删除函数 //删除链表的一个节点 node *delete_node(node *head, int data) { node *p1, *p2; if (head == NULL) {//链表为空(head=NULL) printf("链表节点为空！\n"); return 0; } if (head->data == data) {//链表非空，删除表头。
力扣刷题链表总结
小吕的博客
11-13 355
ListNode list=new ListNode() 初始化一个空节点，无值,不提倡此种写法。 ListNode list=new ListNode(0) 初始化一个节点值为0的空节点，最常用最正规写法 ListNode list=null 为空，什么都没有，一般不这么写； 合并两个有序链表 /** *Definitionforsingly-linkedlist. *...
【LeetCode】141. 环形链表 & 142. 环形链表 II
jiiiiiaaaa的博客
10-09 469
题目 给定一个链表，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 如果链表中存在环，则返回 true 。 否则，返回 false 。 进阶： 你能用 O(1)（即，常量）内存解决此问题吗？ 示例 1： 输入：head = [
力扣刷题笔记：反转链表与LRU缓存
"力扣500题刷题笔记4，涉及两道LeetCode上的经典链表问题：206.反转链表和146.LRU缓存机制" 在这篇刷题笔记中，作者首先讨论了LeetCode上的第206题——反转链表。反转链表是一个常见的链表操作，其目标是将链表中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值