【力扣探索】链表——经典问题

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量221 收藏
点赞数
分类专栏： Leetcode刷题笔记 文章标签： 链表 c++ 算法 leetcode 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dream98Kid/article/details/111880743
版权

写在前面的提示

  1. 通过一些测试用例可以节省您的时间
    使用链表时不易调试。因此，在编写代码之前，自己尝试几个不同的示例来验证您的算法总是很有用的。
  2. 你可以同时使用多个指针
    有时，当你为链表问题设计算法时，可能需要同时跟踪多个结点。您应该记住需要跟踪哪些结点，并且可以自由地使用几个不同的结点指针来同时跟踪这些结点。如果你使用多个指针，最好为它们指定适当的名称，以防将来必须调试或检查代码。
  3. 在许多情况下，你需要跟踪当前结点的前一个结点
    你无法追溯单链表中的前一个结点。因此，您不仅要存储当前结点，还要存储前一个结点。

练习

1. 反转链表

题目链接: 206.反转链表
解题思路：

  1. 迭代，时间复杂度O(n),空间复杂度O(1)
  2. 递归，时间复杂度O(n),空间复杂度O(n),由于使用递归，将会使用隐式栈空间。递归深度可能会达到 n 层
  3. 双指针，时间复杂度O(n),空间复杂度O(1)

建议食用题解中某大佬的思路展示，图文结合非常清晰here

代码：

//迭代版本，时间复杂度O(n),空间复杂度O(1)
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
    	if(head == NULL || head->next == NULL) return head;

    	ListNode *newhead = head;
    	while(head->next != NULL){
    		ListNode *p = head->next;
    		head->next = p->next;
    		p->next = newhead;
    		newhead = p;
    	}
    	return newhead;
    }
};

//递归版本，时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
    	if(head == NULL || head->next == NULL) return head;
    	ListNode *newhead = reverseList(head->next);
    	head->next->next = head;
    	head->next = NULL;
    	return newhead;
    }
};

2. 移除链表元素

题目链接: 203. 移除链表元素
解题思路：题目较简单，dummyhead的使用使得讨论的case大大减少。

  1. 迭代结合虚拟头节点，注意循环中当next需要被删除时，当前遍历到的r指针不能前进，否则会丢失处理对象。时间复杂度O(n),空间复杂度O(1)
  2. 递归实现，假设当前节点后面都已经处理好，转而判断当前节点val是否为目标val，进而返回对应结果

代码：

//递归版本
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
    	if(head == NULL) return head;
    	ListNode *ret = removeElements(head->next, val);
    	if(head->val == val) return ret;
    	head->next = ret;
    	return head;
    }
};

//迭代+虚拟头节点
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
    	if(head == NULL) return head;
    	ListNode *dummyhead = new ListNode(0);
    	dummyhead->next = head;

    	ListNode* r = dummyhead;
    	while(r->next != NULL){
    		if(r->next->val == val){
    			r->next = r->next->next;
    		}else{//此时若下一个节点需要删除，那么r应该保留位置，而不是前进
    			r = r->next;
    		}
    	}

    	return dummyhead->next;
    }
};

3. 奇偶链表

题目链接: 328. 奇偶链表
解题思路：

  1. 奇偶链表先拆分，后合并，思路简单清晰，到末尾的处理很关键，涉及while循环的终止条件，自己编程的结果明显想的复杂，虽通过，但不如题解中给出的简洁明了。

代码：

class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(head == NULL || head->next == NULL || head->next->next == NULL) return head;

        ListNode *oddhead = head, *oddp = head;
        ListNode *evenhead = head->next, *evenp = head->next;

        while(oddp->next != NULL && evenp->next != NULL){
        	if(oddp->next != NULL && oddp->next->next != NULL){
        		oddp->next = oddp->next->next;
        		oddp = oddp->next;
        	}
        	else if(oddp->next == NULL || oddp->next->next == NULL) oddp->next = NULL;

        	if(evenp->next != NULL && evenp->next->next != NULL){
        		evenp->next = evenp->next->next;
        		evenp = evenp->next;
        	}
        	else if(evenp->next == NULL || evenp->next->next == NULL) evenp->next = NULL;
        }

        oddp->next = evenhead;
        return oddhead;
    }
};
//官方题解
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(head == NULL || head->next == NULL || head->next->next == NULL) return head;

        ListNode *oddhead = head, *oddp = head;
        ListNode *evenhead = head->next, *evenp = head->next;

        while(evenp != NULL && evenp->next != NULL){
        	oddp->next = evenp->next;
        	oddp = oddp->next;
        	evenp->next = oddp->next;
        	evenp = evenp->next;
        }
        oddp->next = evenhead;	
        return oddhead;
    }
};

4. 回文链表

题目链接: 234. 回文链表
解题思路：说几个比较推荐的解题思路

  1. 构造数组判断，由于链表的特性对元素的访问十分消耗时间，通过构建对应的数组，可以进一步使用双指针从两端逐一比对。缺点是空间复杂度达到了O(n)
  2. 在原数组上利用快慢指针，将链表一分为二，反转其中的一部分，再与另一部分进行比较，若完全相同则是回文链表，利用该方法可以实现O(1)的额外空间复杂度，另外要注意应恢复链表的结构，由于此题对此不要求，我的代码中没有恢复链表的结构。该题中关于快慢指针和反转的实现细节，题解中的大神提出了不同的方案：
    a. 传统方案，快慢指针和反转分为独立的两个部分，通过慢指针确定反转的位置, 这里反转的是后半部分的链表，然后再进行反转操作，最后与前半部分链表比较。
    b. 加鸡腿方案, 快慢指针的遍历和反转操作融合在一起,使用一个循环即可, 这里反转的是链表的前半部分, 当慢指针遍历的同时对前半部分进行反转操作, 慢指针遍历结束后的位置可确定后半部分链表的开始位置, 再比较即可.
  3. 哈希公式, 似乎利用公式对回文的处理非常快,码住会了回来补充!
  4. 暴力递归+暴力迭代 (逐对定位比较,很蠢)

代码：

//快慢指针反转后半部分链表进行比较，
class Solution {
public:
    bool isPalindrome(ListNode* head) {
    	if(head == NULL || head->next == NULL) return true;
    	ListNode *slow = head, *fast = head;
    	while(fast != NULL && fast->next != NULL && fast->next->next != NULL){
    		fast = fast->next->next;
    		slow =slow->next;
    	}
    	ListNode *cur = slow->next, *pre = NULL;
    	ListNode *save = cur->next;
    	while(save != NULL){
    		cur->next = pre;
    		pre = cur;
    		cur = save;
    		save = save->next;
    	}
    	cur->next = pre;    	
    	ListNode *p = cur;
    	ListNode *q = head;
    	while(p != NULL){
    		if(q->val != p->val) return false;
    		p = p->next;
    		q = q->next;
    	}
    	return true;
    }
};

//快慢指针遍历翻转一遍过，
class Solution {
public:
    bool isPalindrome(ListNode* head) {
    	if(head == NULL || head->next == NULL) return true;
    	if(head->next->next == NULL) return head->val == head->next->val;
    	ListNode *slow = head, *fast = head;
    	ListNode *pre = NULL, *save = head->next;
    	while(fast != NULL && fast->next != NULL && fast->next->next != NULL){
    		fast = fast->next->next;
    		slow->next = pre;
    		pre = slow;
    		slow = save;
    		save = save->next;
    	}
    	slow->next = pre;
    	if(fast->next == NULL) slow = slow->next;
    	while(save != NULL){
    		if(save->val != slow->val) return false;
    		save = save->next;
    		slow = slow->next;
    	}
    	return true;
    }
};

5. 合并两个有序链表

题目链接: 21. 合并两个有序链表
解题思路：
经典迭代的想法，两个指针从两个链表各自出发分别比较，每次迭代中符合条件的插入到新链表后面，时间复杂度O(m+n),空间复杂度O(1)
代码：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *p1 = l1, *p2 = l2;
        ListNode* resdummyhead = new ListNode(-1);
        ListNode* restail = resdummyhead;
        while(p1 != NULL && p2 != NULL){
        	if(p1->val < p2->val){
        		restail->next = p1;
        		restail = p1;
        		p1 = p1->next; 
        	}
        	else{
        		restail->next = p2;
        		restail = p2;
        		p2 = p2->next;
        	}
        }
        if(p1 == NULL) restail->next = p2;
        if(p2 == NULL) restail->next = p1;
        return resdummyhead->next;
    }
};

6. 两数相加

题目链接: 2. 两数相加
解题思路：

  1. 考虑到两个链表的低位在表头，所以可以依次从头开始对节点进行相加，同时注意用变量存储进位的情况，在两者都遍历完之后，若仍有进位，应该在结尾再补充一个节点。时间/空间复杂度O(max(m,n))
  2. 我尝试过用数值直接进行计算再分解的操作，这对于一些长度较小的链表是可行的，但是当树木变大，传统的int，long等类型无法存储那么大的数会导致算法崩溃。
    代码：
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *p1 = l1;
        ListNode *p2 = l2;
        ListNode *resdummyhead = new ListNode(-1);
        ListNode *resp = resdummyhead;
        int count = 0;
        while(p1 != nullptr || p2 != nullptr){
        	int addres;
        	if(p1 == nullptr) addres = p2->val + count;
        	else if(p2 == nullptr) addres = p1->val + count;
        	else addres = p1->val + p2->val + count;
        	count  = 0;
        	if(addres >= 10){
        		count = 1;
        		addres = addres - 10;
        	}
        	ListNode *r = new ListNode(addres);
        	resp->next = r;
        	resp = r;
        	if(p1) p1 = p1->next;
        	if(p2) p2 = p2->next;
        }
        if(count == 1){
        	ListNode *r = new ListNode(1);
        	resp->next = r;     		
        }
        p1 = resdummyhead->next;
        delete resdummyhead;
        return p1;
    }
};

7. 扁平化多级双向链表

题目链接: 430. 扁平化多级双向链表
解题思路：

  1. 递归解决，很容易想到，每次检测到某节点child不为null，假设指向的链表已经flaten，然后进行操作。由于用了递归其消耗的空间较大
  2. 利用while循环迭代解决，代码清晰，思路非常巧妙，能够成功的原因是每次p处理完了相应的child链表后，往前进的时候其实是会先遍历完原来的子链表，这样实际上就完成了一个深度遍历，推荐！
    代码：
//递归版本
class Solution {
public:
    Node* flatten(Node* head) {
    	if(head == NULL) return NULL;
        Node *p = head;
        while(p != NULL){
        	if(p->child != NULL){
        		Node *temp = flatten(p->child);
        		Node *r = temp;
        		while(r->next != NULL) r = r->next;
        		p->child = NULL;
        		temp->prev = p;
        		r->next = p->next;
        		p->next = temp;
        		if(r->next != NULL)
        			r->next->prev = r;
        		p = r->next;
        	}
        	else p = p->next;
        }
        return head;
    }
};
//迭代版本，推荐！
class Solution {
public:
    Node* flatten(Node* head) {
        Node *p = head;
        while(p != NULL){
        	if(p->child != NULL){
        		Node *child = p->child;
        		Node *next = p->next;
        		p->child =NULL;
        		child->prev = p;
        		p->next = child;      
        		while(child->next != NULL) child = child->next;
        		child->next = next;
        		if(next != NULL)
        			next->prev = child;
        	}
        	p = p->next;
        }
        return head;
    }
};

8.

题目链接: 138. 复制带随机指针的链表
解题思路：

  1. 遍历原链表复制每个节点在对应原节点的右边（next指针指向），生成一个2*N的链表，遍历的时候对于random不为空的节点可以依靠相对位置确定其右边节点的random指针指向的位置。此方法只用到O(1)的额外空间复杂度。
  2. 递归迭代解放见官方题解,第一种思路是其中第三种解法，前两种方法难懂且最后额外的空间复杂度为O(n)。
    代码：
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == NULL) return NULL;
        Node *p = head;
        while(p != NULL){
            Node *node = new Node(p->val);
            node->next = p->next;
            p->next = node;           
            p = p->next->next;
        } 
        p = head;
        while(p != NULL){
            if(p->random != NULL) p->next->random = p->random->next;
            p = p->next->next;
        }
        p = head;
        Node *newhead = head->next;
        Node *np = newhead;
        while(p != NULL){
            p->next = np->next;
            p = p->next;
            if(p != NULL){ 
                np->next = p->next;
                np = np->next;
            }         
        }
        return newhead;
    }
};

9. 旋转链表

题目链接: 61. 旋转链表
解题思路：

  1. 注意到旋转次数到达链表长度的时候i相当于没有旋转，因此实际旋转的效果=k%length的结果，可以将原链表的尾部next链接到原链表head，由k与length计算出应该切断的地方，找到即可。时间复杂度O(n),空间复杂度O(1)

代码：

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
    	if(head == nullptr || head->next == nullptr) return head; 
    	int length = 1;
    	ListNode *p = head;
    	while(p->next != nullptr){
    		p = p->next;
    		length++;
    	}
    	p->next = head;
    	k = k % length;
    	p = head;
    	for(int i = 0; i < length-k-1; ++i){
    		p = p->next;
    	}
    	head = p->next;
    	p->next = nullptr;
    	return head;
    }
};
唉嗳君
关注
专栏目录
LeetCode解题心得——反转链表（python）
12-21
在LeetCode中，反转链表是一个常见的数据结构问题，它主要考察了对链表操作的理解以及递归或迭代解决问题的能力。本题的目标是反转给定的单链表，例如，对于输入1->2->3->4->5->NULL，期望得到的输出是5->4->3->2->1...
用递归计算一个数字每一位相加的结果。_leetcode 2 两数相加(c++)
weixin_39663378的博客
11-28 393
两种解法，第一种是在原有的两个链表中选择更长的那个作为结果返回，虽然节约了空间，但是增加了时间复杂度，而且没有用到如何设置链表的增加与删除，第二种看起来清爽很多，逻辑也清晰。### 题目给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 ...
leetcode经典例题（详细思路及代码注释）
zhangpupu320的博客
04-02 4420
141.给定一个链表，判断链表中是否有环。 public class Solution { public boolean hasCycle(ListNode head) { if(headnull||head.nextnull){ //若链表为空,或链表中只有一个元素，则一定无环； return false; } ListNode fast=head; ListNode slow=head; wh...
本地IDE调试LeetCode中链表相关问题
hesongzefairy的博客
03-05 2548
当我们想在本地的IDE调试LeetCode代码时，直接复制代码来调试肯定会出问题，链表相关的问题在LeetCode上内部封装了其节点类，所以我们在本地调试的时候，需要自己添加节点类才能正常调试。 首先看LeetCode上关于链表的题目是如何给的： /** * Definition for singly-linked list. * public class ListNode { * ...
链表的几个经典问题
weixin_34273479的博客
03-27 162
下面是几个关于链表的非常经典的问题与实现，是在《程序员面试攻略》中看到的，由于实在是太经典了，所以忍不住在这里贴下。 问题1：给定一个单项链表，设计一个时间优化并且时间优化的算法，找出该链表的倒数第m个元素。当m=0时，返回链表的最后一个元素。[分析：用双指针来实现，两指针间隔m。同步移动两指针，当前一个指针为该链表tail时，后一个指针就为要...
redis c语言 list例子,Redis的双向链表一文全知道
weixin_35231383的博客
05-22 269
本文转载自微信公众号「学习Java的小姐姐」，作者学习Java的小姐姐0618 。转载本文请联系学习Java的小姐姐公众号。前言hello，又见面了。不要问为什么，问就是勤劳。马上要开启爆更模式啦。在Redis中链表List的应用非常广泛，但是Redis是采用C语言来写，底层采用双向链表实现(这边提一嘴，如果是科班出身或者大学有学过数据结构的同学，可以划走啦)。我们今天的重点就是双向链表。API使...
[力扣] 203.移除链表元素
12-23
移除链表元素" 是一个典型的链表操作问题，主要涉及链表节点的删除操作。题目要求从链表中删除所有值等于给定值 `val` 的节点。 链表删除操作通常分为两种情况：删除头节点和删除非头节点。在处理这个问题时，我们...
[力扣]141. 环形链表
01-20
给定一个链表，判断链表中是否有环。为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 该题目来自力扣题库 示例 示例1： 输入：...
环形链表介绍以及题目解析-力扣141、142
01-05
这种结构在某些算法问题中有着广泛的应用，例如力扣（LeetCode）上的题目141和142就涉及到环形链表的判断和处理。 在环形链表中，判断是否存在环的常用方法是使用快慢指针。快慢指针的概念是设置两个指针，一个称为...
力扣刷题集-更新至链表
06-21
力扣刷题集-更新至链表 本资源摘要信息主要涉及算法领域，着重于数组、链表、排序算法、二分查找等知识点。 数组 数组是存放在连续内存空间上的相同类型数据的集合。数组可以方便地通过下标索引的方式获取到下标...
合并有序链表
zfr143816的博客
08-06 177
合并有序链表 /* 剑指offer25：合并两个排序链表 * 题目描述：输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 * 解题思路：设两链表分别为L1、L2，P1、P2分别指向L1的第一、第二个结点，q指向L2的第一个结点 * 若q小于p1将q的后继设为p1，p1指向q p2指向p1，q指向后继 * 若q大于等于p1且小于p2将q插入p1 p2中，q指向后继，p1不动、p2指向q * 若q大于p2，p1指向p2，p
约瑟夫问题，双向链表实现
孙小小子的博客
11-03 1220
问题描述：N个人围城一圈，从第一个人开始报数，第M个被杀掉，最后剩下一个人，其余人都排除 /* 链表 */ #include #include using namespace std; //双向链表 template class dnode{ public: T nodeValue; dnode *prev; dnode *next; dnode() { next =
双向链表的操作问题
向着曙光前进的博客
04-17 851
建立一个长度为n的带头结点的双向链表，使得该链表中的数据元素递增有序排列。（必须使用双向链表完成，数据类型为整型。）输入第一行：双向表的长度； 第二行：链表中的数据元素。输出输出双向链表中的数据元素的值。样例输入10 2 4 6 3 5 8 10 21 12 9 样例输出2 3 4 5 6 8 9 10 12 21#include&lt;iostream&gt; #include&lt;cstr...
简单的双向链表题目（可是T哭了！！）（这个题目给自己提个醒吧）
ACMerdsb的博客
10-27 531
答案： #include &lt;iostream&gt; #include &lt;bits/stdc++.h&gt; using namespace std; struct node {     char data;     struct node *last;     struct node *next; }; char str[1000005]; int main() {     i...
单链表反转（逆置）——（四种方法实现）
热门推荐
m0_58397166的博客
04-19 7万+
链表逆置就是把最后以一个提到坐前面，倒数第二个放到第二个……直到第一个到最后一个。 由于链表没有下标，所以不能借助下表来实行数据的逆置，要靠空间的转移来完成链表的逆置 这里采用没有头节点的链表来实现逆置。 第一种——头插法 算法思想：逆置链表初始为空，表中节点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空。 #include <stdio.h> #include <stdli...
LeetCode力扣链表算法题——题解与思路
DwyaneQiang的博客
06-16 1227
目录 链表双指针模版 1.设计链表 2.环形链表 3.环形链表 II 4.相交链表 5.删除链表的倒数第N个节点 6.反转链表 7.移除链表元素 8.奇偶链表 9.回文链表 10.设计链表(双链表) 11.合并两个有序链表 12.两数相加 13.旋转链表 14.复制带随机指针的链表(深拷贝) 15.扁平化多级双向链表 链表双指针模版 // Initialize slow & fast pointers ListNode slow = head; ListNo..
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 330
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1131
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
C++与QML的数据交互
qq_50679120的博客
09-11 543
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
力扣反转链表python
05-16
以下是反转链表的 Python 代码示例： ```python class ListNode: def __init__(self, x): self.val = x self.next = None def reverseList(head): """ :type head: ListNode :rtype: ListNode """ prev = ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值