LeetCode算法讲解——链表

最新推荐文章于 2023-02-24 10:16:18 发布
最新推荐文章于 2023-02-24 10:16:18 发布
阅读量394 收藏
点赞数 1
分类专栏： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37142091/article/details/99953755
版权

记录LeetCode算法讲解经典版，涉及相关数据结构和算法的经典题目及相关题目解题思想和代码实现。

目录

一、预备知识

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

二、例题

例1-a、链表逆序(easy)

  • 题目描述：
    在这里插入图片描述
  • 解题思路：
    在这里插入图片描述
    在这里插入图片描述
  • 代码实现：
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *new_head=NULL;
        ListNode *q;
        while(head!=NULL){
            q = head->next;
            head->next=new_head;
            new_head = head;
            head=q;
        }
        return new_head;
    }
};

例1-b、链表逆序2(medium)

  • 题目描述：
    在这里插入图片描述
  • 解题思路：
    在这里插入图片描述
    在这里插入图片描述
  • 代码实现：
/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
   ListNode* reverseBetween(ListNode* head, int m, int n) {
       ListNode* result = head;
       int number = n-m+1;
       ListNode* pre_head = NULL;
       //找到pre_head和head:head指向m位置，pre_head指向m前一个
       while(head&&--m){
           pre_head = head;
           head=head->next;
       }
       //modify_list_tail指向反向链表的尾节点
       ListNode* modify_list_tail = head;
       //new_head指向反转链表的头节点；
       ListNode* new_head = NULL;
       while(head&&number){
           ListNode* q = head->next;
           head->next = new_head;
           new_head=head;
           head = q;
           number--;
       }
       modify_list_tail->next = head;
       if(pre_head){
           pre_head->next = new_head;          
       }else{
       /*m=1的情况，没有pre_head*/
           result = new_head;
       }
       return result;
   }
};

例2、链表求交点(easy)

  • 题目描述：
    在这里插入图片描述
  • 解题思路：
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  • 代码实现:

方法一：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
#include<set>
using namespace std;
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        set<ListNode *> se;//用于保存headA各个节点地址的set
        // 把headA为头节点的链表各个节点放入set
        while(headA){
            se.insert(headA);
            headA = headA->next;
        }
        // 查找headB的各个头节点是否在set中
        while(headB){
            if(se.find(headB)!=se.end()){
                return headB;
            }
            headB=headB->next;
        }
        return NULL;
    }
};

方法二：

/**
* 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) {
       int lenA = 0;
       int lenB = 0;
       ListNode* A = headA;
       ListNode* B = headB;
       while(A){
           A = A->next;
           lenA++;
       }
       while(B){
           B = B->next;
           lenB++;
       }
       if(lenB>=lenA){
           int temp = lenB-lenA;
           while(temp){
               headB=headB->next;
               temp--;
           }
       }else{
           int temp = lenA-lenB;
           while(temp){
               headA=headA->next;
               temp--;
           }
       }
       while(headA&&headB){
           if(headA!=headB){
               headA=headA->next;
               headB=headB->next;
           }else{
               return headA;
           }
       }
       return NULL;
   }
};

例3、链表求环(medium)

  • 题目描述：
    在这里插入图片描述
  • 解题思路：
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  • 代码实现：
    方法一：
#include<set>
using namespace std;
/**
 - 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) {
        set<ListNode *> que;
        while(head){
            que.insert(head);
            head=head->next;
            if(que.find(head)!=que.end()){
                return head;
            }
        }
        return NULL;
        
    }
};

方法二：

/**
 - 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 *slow = head;
        ListNode *fast = head;
        ListNode *meet = NULL;
        while(fast){
            fast = fast->next;
            slow = slow->next;
            if(fast){
                fast = fast->next;
            }
            if(fast==slow){
                meet = fast;
                break;
            }
        }
        if(fast==NULL){
            return NULL;
        }
        while(head&&meet){
            if(head==meet){
                return head;
            }
            head=head->next;
            meet=meet->next;
        }
        return NULL;

    }
};

例4、链表划分(medium)

  • 题目描述：
    在这里插入图片描述
  • 解题思路：
    在这里插入图片描述
    思路二：利用两个队列，把小于x的入small队列，大于等于x的入big队列，连接两个链表，更新每个节点的值，让其等于small队列和big队列中元素的值，其中small队列先入，big队列后入。
  • 代码实现：
    方法一：
#include<queue>
using namespace std;
/**
 - Definition for singly-linked list.
 - struct ListNode {
 -     int val;
 -     ListNode *next;
 -     ListNode(int x) : val(x), next(NULL) {}
 - };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        //创建一个小于x的链表头和大于等于x的链表头
        ListNode small(0);
        ListNode big(0);
        ListNode *small_head_move = &small;
        ListNode *big_head_move = &big;
        ListNode *small_head = &small;
        ListNode *big_head = &big;
        while(head){
            ListNode* q = head->next;
            if(head->val<x){
                small_head_move->next = head; 
                small_head_move =head;
            }else{
                big_head_move->next = head;
                big_head_move = head;
            }
            head = q;
        }

             // 让big和small最后指向都为空
            big_head_move->next = NULL;
            big_head = big_head->next;
            // 连接small和big
            small_head_move->next = big_head;
            // 移到头节点的下一个节点
            small_head = small_head->next;
            return small_head;
        
    }
};

方法二：

#include<queue>
using namespace std;
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        queue<int> small_que;
        queue<int> big_que;
        ListNode* start=head;
        ListNode* result=head;
        while(head){
            if(head->val<x){
                small_que.push(head->val);
            }else{
                big_que.push(head->val);
            }
            head = head->next;
        }
        while(start){
            while(!small_que.empty()){
                if(start==NULL){
                    break;
                }
                int top = small_que.front();
                small_que.pop();
                start->val=top;
                start = start->next;
            }
            while(!big_que.empty()){
                if(start==NULL){
                    break;
                }
                int top = big_que.front();
                big_que.pop();
                start->val=top;
                start = start->next;
            }
        }
        return result;
    }
};

例5、复杂链表的复制(hard)

  • 题目描述：
    在这里插入图片描述
  • 解题思路：
    在这里插入图片描述
    在这里插入图片描述
  • 代码实现：
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;

    Node() {}

    Node(int _val, Node* _next, Node* _random) {
        val = _val;
        next = _next;
        random = _random;
    }
};
*/
#include<map>
#include<vector>
using namespace std;
class Solution {
public:
    Node* copyRandomList(Node* head) {
        map<Node*,int> loc_id;
        vector<Node*> vec;
        Node *start = head;
        int i = 0;
        while(start){
            vec.push_back(new Node(start->val,NULL,NULL));
            loc_id[start]=i;
            i++;
            start = start->next;
        }
        vec.push_back(0);
        Node *result = head;
         i = 0;
        while(result){
            vec[i]->next =vec[i+1];
            if(result->random){
                int id = loc_id[result->random];
                vec[i]->random = vec[id];   
            }
            result=result->next;
            i++;
        }
        return vec[0];
    }
};

例6-a、2个排序链表归并(easy)

  • 题目描述：
    在这里插入图片描述
  • 解题思路：
    在这里插入图片描述
  • 代码实现：
/**
 - Definition for singly-linked list.
 - struct ListNode {
 -     int val;
 -     ListNode *next;
 -     ListNode(int x) : val(x), next(NULL) {}
 - };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode start(0);
        ListNode *new_head = &start;
        ListNode *result = &start;
        while(l1&&l2){
            if(l1->val<=l2->val){
                new_head->next = l1;
                new_head=l1;
                l1=l1->next;
            }else{
                new_head->next = l2;
                new_head=l2;
                l2=l2->next;
            }
        }
        if(l1==NULL){
            new_head->next = l2;
        }
        if(l2==NULL){
            new_head->next = l1;
        }
        return result->next;
    }
};

例6-b、k个排序链表归并(hard)

  • 题目描述：
    在这里插入图片描述
  • 解题思路：
    在这里插入图片描述
    在这里插入图片描述
  • 代码实现：
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
#include<vector>
#include<algorithm>

bool cmp(const ListNode *a,const ListNode *b){
    return a->val < b->val;
}

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        vector<ListNode *> vec;
        for( int i = 0;i<lists.size();i++){
            while(lists[i]){
                vec.push_back(lists[i]);
                lists[i]=lists[i]->next;
            }
        }
        if(vec.size()==0){
            return NULL;
        }
        sort(vec.begin(),vec.end(),cmp);
        for(int i = 1;i<vec.size();i++){
            vec[i-1]->next = vec[i];
        }
        vec[vec.size()-1]->next=NULL;
        return vec[0];
    }
};
瞳のメロディ
关注
专栏目录
⚡考研面试⚡leetcode每天练——两数相加
肥学的博客
08-04 821
题目： 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 示例 2： 输入：l1 = [0], l2 = [0] 输出：[0] 示例
算法通关村第二关——链表反转笔记（青铜挑战）
最新发布
Hai_Helloyou的博客
07-20 358
链表反转实现的详细过程，通过图与代码结合说明，本次包括递归的实现三要素结合代码和图详细的讲解
leetcode数据结构算法框架——回溯
iwtbs
10-20 245
回溯法 实际上回溯算法就是一个 N 叉树的前序遍历加上后序遍历而已，而且回溯算法是有模板的，一旦掌握，就能秒杀相关问题。下面，我们来循序渐进地理解。 // 二叉树遍历框架 def traverse(root): if root is None: return # 前序遍历代码写在这 traverse(root.left) # 中序遍历代码写在这 trave...
LeetCode算法讲解——栈、队列、堆
qq_37142091的博客
08-21 427
记录LeetCode算法讲解经典版，涉及相关数据结构和算法的经典题目及相关题目解题思想和代码实现。 目录一、预备知识二、例题例1、使用队列实现栈(easy)(栈、队列)例2、使用栈实现队列(easy)(栈、队列)例3、包含min函数的栈(easy)(栈)例4、合法的出栈序列(medium)(栈、队列)例5、数组中第K大的数(easy)(堆)例6、寻找中位数(hard)(堆) 一、预备知识 栈...
Leetcode算法系列二（链表）
weixin_44337475的博客
10-16 405
1.8道经典链表常考题目 例1-a：反转链表 例1-b：反转链表2 例2：链表求交点 例3：链表求环 例4：链表划分 例5：复杂链表的复制 例6-a：2个排序链表归并 例6-b：K个排序链表归并 206.反转链表 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ public class Solution {
C++中单向链表相关知识
sunprice的博客
10-02 2667
struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; 其中，  ListNode(int x) : val(x), next(NULL) {}  是结构体的构造函数，与类的构造函数相同，冒号后面的是初始化列表，也就是给成员val初始化为传入的参...
ListNode链表结构超详细解析，LeetCode题解
weixin_39033058的博客
12-16 1万+
链表由数据+指针构造的，指针指向下一个节点。 一个链表结构数据：1 -> 2 -> 3 -> 4········ class ListNode{ int value; ListNode next; }
LeetCode算法挑战解析
"转置数字——解决溢出的思路"和"atoi——培养严谨的思路"则涉及数学和逻辑推理，讲解如何处理溢出和正负号的问题。 回文数字的处理，如"回文数字巧解"，是数字处理的一个经典主题。位运算在"位运算实现除法"中扮演...
LeetCode算法详解：动态规划与数据结构实战
"这篇资源是关于LeetCode算法的详细讲解，包括多个具体案例和详细的解题步骤。内容涵盖动态规划、回溯算法、BFS算法等，并提供了多种问题的解题框架和套路。作者还分享了针对LeetCode股票买卖、打家劫舍和nSum等问题...
LeetCode146——LRU缓存机制
清风阁
01-09 1万+
我的LeetCode代码仓：https://github.com/617076674/LeetCode 原题链接：https://leetcode-cn.com/problems/lru-cache/description/ 题目描述： 知识点：哈希表、双向链表、LRU缓存机制 思路一：用哈希表记录键值对，用双向链表处理LRU缓存机制 用示例来说明我们算法的流程，为了防止对null节...
LeetCode----ListNode语法及基本操作
qq_41142785的博客
04-17 9085
ListNode相关要点 前言 最近在刷LeetCode，遇到一些似曾相识但又模棱两可的知识点，这里做一下总结，本文是Java中ListNode语法及操作的梳理。 类结构如下 public class ListNode { int val; //结点值 ListNode next; //用来指向下一个结点的ListNode对象 ListNode() {} ListNode(int val) { this.val = val; } ListNode(int val, ListNod
LeetCode力扣刷题——指针三剑客之一：链表
指北针_N的博客
11-13 1290
单链表，链表是由节点和指针构成的数据结构，每个节点存有一个值，和一个指向下一个节点 的指针，因此很多链表问题可以用递归来处理。不同于数组，链表并不能直接获取任意节点的值， 必须要通过指针找到该节点后才能获取其值。同理，在未遍历到链表结尾时，我们也无法知道链 表的长度，除非依赖其他数据结构储存长度。LeetCode 默认的链表表示方法如下。int val;};由于在进行链表操作时，尤其是删除节点时，经常会因为对当前节点进行操作而导致内存或 指针出现问题。
java链表的头插法和尾插法
m566666的博客
12-04 5477
链表是由值和地址 头插法看如下代码： public void startAdd(int n) { Listnode listnode=new Listnode(n); listnode.next=head; head=listnode; } 尾插法看如下代码： public void endAdd(int n) { Listnode listnode=new Listnode(n); if(head==null) { head=listnode; return;
leetcode 中的链表简单题 python3
Luckycat0215的博客
09-06 356
之前没有学过链表，leetcode最近在做简单题，才发现链表的定义，元素之间是通过节点连接的。链表类定义以后的函数调用解释： # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = val # self.next = next p = ListNode() l1: ListNode #l1 就是链表里的
Python实现常见的链表问题
Matrix_cc的博客
03-27 815
1.环形列表 class Solution: def hasCycle(self, head: ListNode) -> bool: if not head or not head.next : return False slow = head fast = head while (fas...
面试金典16（Python）—— 链表相交（简单）
热门推荐
m0_61661179的博客
11-03 5万+
概述：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。题目数据 保证 整个链式结构中不存在环。
三、JAVA链表的实现——ListNode
humor2020的博客
03-23 1万+
三、JAVA链表的实现——ListNode 1.链表概念 链表是一种数据结构：由数据和指针构成，链表的指针指向下一个节点。 链表 是用Java自定义实现的链表结构，在Java中用需要自己定义一个ListNode类来生成链表对象。 2.ListNode 编程题当中，当需要用到ListNode的时候需要这样初始化，同时，下面的代码默认ListNode中装的是int，这里的int也可以改为其他，如char，string 在节点ListNode定义中，定义为节点为结构变量。 节点存储了两个变量：value 和 n
链表oj刷题——6道进阶题目
Ll_R_lL的博客
05-13 1459
目录 1.链表分割 题目： 思路： 2.链表的回文结构 题目： 思路： 3. 输入两个链表，找出它们的第一个公共结点。 题目： 思路一： 思路二： 思路三： 4. 给定一个链表，判断链表中是否有环 题目： 思路： 5. 给定一个链表，返回链表开始入环的第一个结点。 如果链表无环，则返回 NULL 题目： 思路： 6. 给定一个链表，每个结点包含一个额外增加的随机指针，该指针可以指向链表中的任何结点或空结点。 题目： 思路： 1.链表分割
LeetCode 热题 C++ 141. 环形链表 142. 环形链表 II（详解！）
做题记录
02-24 466
给你一个链表的头节点head，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪next指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数pos来表示链表尾连接到链表中的位置（索引从 0 开始）。pos。仅仅是为了标识链表的实际情况。如果链表中存在环，则返回true。否则，返回false。true链表中有一个环，其尾部连接到第二个节点。true链表中有一个环，其尾部连接到第一个节点。false链表中没有环。-1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值