链表(List)及经典问题

已于 2022-06-07 16:23:34 修改
阅读量198 收藏
点赞数
文章标签： 链表 list 数据结构 算法
于 2022-06-06 23:36:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45061460/article/details/125126757
版权

链表基础知识

  • 链表中的每个节点至少包含两个部分: 数据域和指针域
  • 链表中的每个节点, 通过指针域的值, 形成一个线性结构
  • 查找节点 O(n), 插入节点O(1), 删除节点O(1)
  • 不适合快速的定位数据, 适合动态的插入和删除数据的应用场景

实现方式

实现方式1

struct Node {
   Node(int data) : data(data), next(NULL){}
   int data;
    Node *next;
}

int main(){
  Node *head = Null;
  head = new Node(1);
  head->next = new Node(2)
  head->next-> = new Node(3)
  head->next->next->next = new Node(4)
  //遍历
  Node *p = head
  while(p!=NULL){
     print("%d->",p=>data)  // 1->2->3->4->
     p=p->next
  }
  printf("\n")
  return 0;
}

实现方式2

int data[10]
int next[10]

void add(int ind, int p, int val){
   next[p] = next[ind];
   next[ind] = p;
   data[p] =val;
   return;
}
int main(){
   int head =3;
   data[3] = 0;
   add(3,5,1);
   add(5,2,2);
   add(2,7,3);
   add(7,9,100);
   
   int p = head;
   while(p != 0){
     printf("%d=>", data[p]);  //0->1->2->3->100->
     p = next[p];
   }
   printf("\n");
   return 0 ;
}

链表的典型应用场景

场景一: 操作系统内的动态内存分配
在这里插入图片描述
场景二:LRU缓存淘汰算法
在这里插入图片描述
假设1GB缓存仅能存储4个数据, 那么取数据的时候, 先在这4个数据中查找, 如果查找到了, 那么即 缓存命中, 如果查不到, 就把数据5添加到链表的尾部, 从头部删除数据1, 保持仍是4个数据。

经典面试题 - 链表的访问

141.环形链表

判断链表中是否有环

思路1: 哈希表

  • 依次遍历整个链表, 并创建一个哈希表来存储遍历过的节点
  • 在存入哈希表之前, 先判断哈希表中是否存在该节点。如果不存在, 则存入哈希表。如果已经存在,说明遍历到了重复的点, 则存在环形链表
  • 如果遇到next节点为null的节点, 说明没有环

思路2: 快慢指针

  • 定义两个指针(一个慢指针, 一个快指针)
  • 一开始, 慢指针指向head节点, 快指针指向head.next节点
  • 快指针每次向前移动两步, 慢指针每次向前移动一步, 进行遍历整个链表
  • 当快指针的next节点为null,或者快指针本身节点为null时, 说明该链表没有环, 遍历结束
  • 如果链表有环, 那么快慢指针一定会相遇, 指向同一个节点, 当指向同一节点时, 遍历结束
class Solustion {
public:
    bool hasCircle(listNode *head){
       while(head == nullptr) return false;
       //p 慢指针  q快指针
       ListNode *p = head, *q = head->next;
       while( p != q && q && q->next){
         p = p->next;
         q = q->next->next;
       }
       return q && q->next;
    }
};

142 环形链表2

在一个指针在相遇点, 一个指针回到起点, 同时走, 相遇的位置既是环形的初始点

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(head == nullptr) return nullptr;
        ListNode *p = head, *q = head->next;
       while( p != q && q && q->next){
         p = p->next;
         q = q->next->next;
       }
        if(q == nullptr || q->next == nullptr) return nullptr;
        p = q = head;
        do{
          p = p->next;
          q = q->next->next;
        } while(p != q);
        p = head;
        while(p != q){
          p = p->next;
          q = q->next;
        }
        return q;
    }
};

202 快乐数

一个数经过若干次变换规则(等于各位平方和), 若能变换到1, 即为1
题目可以转化为, 判断一个链表是否有环。
如果遍历某个节点为1, 说明没环, 就是快乐数。
如果遍历到重复的节点值, 说明有环, 就不是快乐数。

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

经典面试题 - 链表的反转

206 反转链表

基于迭代:

  • 定义指针pre, pre指向空
  • 定义cur,cur指向我们的头节点
  • 定义指针next,next指向cur所指向节点的下一个节点
  • 将cur指向pre, 然后移动指针pre到指针cur所在的位置, 移动cur到next所在的位置, 将next指针指西乡节点的下一个节点
  • 不断重复, 当cur指针指向null的时候就完成了整个链表的反转
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
       if(head == nullptr) return head;
       ListNode *pre = nullptr, *cur = head, *p = head->next;
       while(cur){
         cur->next = pre;
         pre = cur;
         (cur = p) && (p = p->next);
       }
       return pre;
    }
};

基于递归:

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
       if(head == nullptr || head->next == nullptr) return head;
       ListNode *tail = head->next, *p = reverseList(head->next);
       head->next = tail->next;
       tail->next = head;
       return p;
    }
};

92 反转链表2

将m到n区间的链表进行反转
技巧: 虚拟头节点

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

25 K个一组反转链表

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

61 旋转链表

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

经典面试题 - 链表节点的删除

19 删除链表的倒数第N个结点

q指针先走n步, 然后q指针和p指针一起走, 知道q指向最后一个null节点, p就走到了倒数第N个结点的前一个结点

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

83 删除排序列表的重复节点

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 删除排序链表中的重复元素2

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* 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;
    }
};

技巧: 什么时候需要使用虚拟头节点?
虚拟头节点用在链表的首地址有可能发生改变的情况

欢欢学编程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
解题笔记（13）——几个链表的问题
wuzhekai的专栏
07-25 4510
问题1：输入一个链表的头结点，反转该链表，并返回反转后链表的头结点。问题2：输入一个链表的头结点，从尾到头反过来输出每个结点的值。问题3：给定链表的头指针和一个结点指针，在O(1)时间删除该结点。问题4：两个单向链表，找出它们的第一个公共结点。
linux内核链表list.h
05-17
内核链表
【Redis基础知识 六】Redis底层数据编码之链表
MaoLin Tian's Blog
12-08 231
链表提供了高效的节点重排能力，以及顺序性的节点访问方式，并且可以通过增删节点来灵活地调整链表的长度，但是由于C语言没有链表的数据结构，所以Redis的链表是自己定义的结构。 链表的数据结构 链表单节点的数据结构如下，包含三部分属性，prev、next以及value，用来描述一个链表单节点的结构体： typedef struct listNode { // 前置节点 struct listNode *prev; // 后置节点 struct listNode *next; // 节点的值
链表list
qq_42394752的博客
02-24 272
链表list
链表List
热门推荐
游行天涯
05-19 3万+
链表 存储方式：离散存储 定义： 特点： ① n个节点离散分布。 ② 彼此通过指针相联系。 ③ 除头节点和尾节点外，每个节点只有一个前驱节点和一个后续节点。 ④ 头节点没有前驱节点，尾节点没有后续节点。 尾节点：最后一个有效节点。 头节点：第一个有效节点之前的那个节点。 注意： ① 头节点并不存放有效数据。 ② 加头节点的目的是为了方便对链表的操作，比如在链表头部进行节点的
双向链表list.c
01-23
为《仿照linux内核的链表构造并遍历》一文写的测试源文件，文章链接https://blog.csdn.net/eidolon_foot/article/details/112998927。 文件里面有链表声明和初始化、判断...在linux下用gcc list.c编译，./a.out运行。
QT代码实现list链表结构
03-23
在这个主题中，我们将深入探讨如何使用QT代码实现链表结构，特别是单向链表和双向链表。 首先，我们要理解链表的概念。链表是一种线性数据结构，与数组不同，它的元素在内存中并不连续存储。每个元素称为节点，包含...
danlianbiao.rar_Linked list_链表
09-23
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C#编程语言中，链表通常通过类和对象来实现，以模拟链式存储的概念。本项目“danlianbiao.rar”着重展示了如何用...
StudentList.zip_链表
09-24
在给定的“StudentList.zip”文件中，我们可以预想它包含了一个简单的单向链表实现，用于存储学生信息。这个链表可能是在Visual Studio（VS）环境下编写的，提供添加和删除节点的功能。 链表不同于数组，它不连续...
链表(Linked-list)
不浪漫罪名的博客
03-26 351
链表(linked-list) 链表是线性表的链式存储方式，链表的内存是不连续的，链表通过一个指向下一个元素地址的引用将所有的元素串起来。 链表的分类 单向链表 单向链表是最简单的链表形式。链表中最基本的元素称为节点（node）,每个节点包含了数据域和指向下一个节点的指针。 头结点 图中最上面的head结点，头结点可以不存储任何数据，头结点的指针域存放的是指向第一个结点的指...
list链表
m0_60492395的博客
09-12 481
list链表常见操作
链表相关的题目
2021wuwei
05-08 404
1.反转单链表：链接 思路一 struct ListNode* reverseList(struct ListNode* head){ // 翻转指针方向 if(head==NULL) { return NULL; } // 初始条件 struct ListNode*n1=NULL,*n2=head,*n3=head->next; // 结束条件 while(n2) { // 迭代过
List练习题
深圳_lujingjing的博客
10-09 452
list基础题 去重保留顺序 方法1： a = [3, 2, 1, 4, 2, 6, 1] b = [] for i in a: if i not in b: b.append(i) print(b) 方法2： a = [3, 2, 1, 4, 2, 6, 1] print(sorted(set(a),key=lambda x:a.index(x))) # [3, 2, 1, 4, 6] # 找出列表中出现次数最多的元素 a = [ 'my', 'skill
链表和list
wooovi的博客
02-07 759
链表和list链表和list优点缺点使用方法例list容器的创建list容器可用的成员函数 链表和list STL的list是数据结构中的双向链表。这意味着，list 容器中的元素可以分散存储在内存空间里，而不是必须存储在一整块连续的内存空间中。 优点 可以在序列已知的任何位置快速插入或删除元素（时间复杂度为O(1)）。并且在 list 容器中移动元素，也比其它容器的效率高。 缺点 它不能像 array 和 vector 那样，通过位置直接访问元素 使用方法 在使用该容器前需要包含下面两行代码 #inclu
1-1 链表（List）及经典问题
梧卫清
03-15 921
本文整理了链表相关的经典问题，采用C++实现。后续会慢慢补充。
数据结构——链表以及相关习题
weixin_48796138的博客
07-13 417
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。链表有以下三种特性为什么要重点讲解这一种结构呢?在实现链表之前,我们需要明确链表是由什么构成的,链表是由一个个节点构成的,节点有两个重要的属性 val值,next地址值然后不同的节点有每个节点的地址值串联在一起,像是珍珠由一根线串联在一起,这样一个完整的链表就组成了🍑 代码实现 头插法构造链表 尾插法构造链表 打印链表 寻找节点的位置 在链表对.
一篇解决链表（List）详解（三）
zhouhengzhe的博客
01-02 1733
文章目录1、单链表定义1.1、根据序号获取节点的操作（时间复杂度O(n)）1.2、根据序号删除节点的操作（时间复杂度O(1)）1.3、根据序号插入节点的操作（时间复杂度O(1)）1.4、顺序表（数组）和单链表（链表）的比较1.5单链表代码实现2、双链表定义2.1、特点2.2、单链表和双链表的区别2.3、双链表代码实现3、环形链表定义3.1、环形链表代码实现4、经典面试题4.1、如何设计一个LRU缓存淘汰算法？4.2、约瑟夫问题4.3、单链表的反转（反转链表）（https://leetcode-cn.com/
LeedCode种有关链表List题目总结一
小孟飞飞的博客
10-07 426
LeedCode种有关链表List题目总结一1.Reverse Linked List（将链表逆置） 思路：采用头插法，从第二个节点开始一个一个往最前面移动。2.Merge Two sorted lists（合并两个排序列表） 思路：对两个链表中的元素进行比较，然后移动即可。先建一个节点作为新链表的头结点，然后比较两个链表中的元素大小，一个一个连接起来，最后返回头结点的next;主要代码如下：
最为经典的链表list
最新发布
08-17
最经典的链表是单链表（Singly Linked List）和双链表（Doubly Linked List）。 单链表是由一系列节点组成的数据结构，每个节点包含一个数据元素和一个指向下一个节点的指针。它的优势在于插入和删除操作的时间...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值