链表及经典问题（船长系列）

已于 2023-07-12 23:40:23 修改
阅读量118 收藏
点赞数 1
文章标签： 链表 数据结构
于 2023-04-13 15:24:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53433446/article/details/129323584
版权

链表及经典问题

一、链表基础知识

链表的基本结构：数据域+指针域
查找结点O（n），插入节点O（1），删除节点O（1）
节点至少包括： 数据域 + 指针域
虚拟头节点的使用： 链表的头地址可能发生改变

1. 经典的链表实现方法

（一）
#include <iostream>
using namespace std;



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->next = new Node(3);
    Node* p = head; 
    while (p != NULL) {
        cout << p->data<<"->";
        p = p->next; 
    }

    return 0;
}
（二）
#include <iostream>
using namespace std;


int data[10]; // 数据域
int next[10]; // 指针域

// 在ind的节点后面 添加一个地址为p的节点，值为value
void add(int ind, int p, int val) { 
    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);

    int p = head; 
    while (p != 0) {
        cout << data[p] << "->"; 
        p = next[p]; 
    }

    return 0;
}

二、链表的典型应用场景

1. 操作系统内的动态内存分配

在这里插入图片描述
申请1GB内存
在这里插入图片描述

2. LRU缓存淘汰算法

在这里插入图片描述
在内存中CPU存取速度非常快，在硬盘中CPU读取速度较慢，因此将512GB的内容读取1GB在缓存中

缓存形象的维护方式（非底层真实方式）

在这里插入图片描述

三、经典面试题-链表的访问

1.环形链表

1）哈希表使用一片额外的存储区

在这里插入图片描述

在这里插入图片描述
这种做法需要一片额外的存储区，高效的存储：哈希表

2）快慢指针

在这里插入图片描述
在这里插入图片描述
如果链表有环，那么快慢指针一定会相遇，指向同一节点

求相遇节点

leetcode 141

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if (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 ; 

    }
};
求环的起始点

假设链表的起始点距离环的起始点，长度为a，则当满节点走到环的起始点时，快节点走了2a的长度。假设环的长度为a+x则快节点剩余的距离就是x，此时快节点想要追上慢节点，需要追x的距离。则当快节点追上慢节点时，慢节点在环里走了x步，则剩余的距离就是a。因此，相遇点距离环的起始点距离，与链表起始点距离环的起始点距离相同，都是a。
leetcode 142

/**
 * 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) {
        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  = head ->next  ;
        q = head ->next ->next;
        while ( p !=  q ){
            p = p->next; 
            q = q->next->next  ;
        }
        p = head;
        while ( p!= q) {
            p = p->next ; 
            q = q->next ; 
        }
        return q ; 
    }
};

/**
 * 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) {
        if (head == nullptr )return  nullptr; 
        ListNode *p  = head , *q = head ;
        if (q->next == nullptr )return nullptr ;
        p = p->next ; q= q->next ->next ;
        while (  p!= q && q && q->next ){
            p = p->next  ;
            q = q->next->next ;
        } 
        if (q == nullptr || q->next == nullptr ) return nullptr ; 
        p = head ; 
        while ( p != q ){
            p = p->next ; 
            q = q->next ;
        }
        return q ;

    }
};

leetcode202
链表判环问题

class Solution {
public:
    int getnext( int n ){
        int z = 0 ;
        while(n){
            z +=  (n % 10 ) * (n % 10) ;
            n /= 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 ;
    }
};

四、经典面试题-链表的反转

1.链表的反转

在这里插入图片描述
在这里插入图片描述
首先，令cur指针所指向的节点指向pre指针所指向的节点
然后移动指针pre到cur所在的位置，移动cur到next所在的位置
注：cur指向已反转部分的头结点，pre指向未反转部分的头结点
leetcode 206

/**
 * Definition for singly-linked list.
 * 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) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr )return nullptr ;
        ListNode *pre  = nullptr , *cur = head ,*p = cur->next ;
        while(cur ){
            cur->next = pre;
            pre = cur ;
            (cur = p ) && (p = p -> next) ; // 当cur指向nullptr时，p就不指向下一位了         
        }
        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 ;
    }
};

反转链表的头n个节点

Node * reverse (Node *head , int n){
    if (n == 1) return head ;
    Node *tail  = head->next; *p = revrese (head->next ,n-1) ;
    head ->next = tail ->next ;
    tail ->next = head
    return p ;  
}

2. 给出链表反转区间

leetcode 92

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 ; // p 节点指向待反转区域的前一个结点// 虚拟头节点 
        int cnt = n-m+1; 
        while ( --m  )  p = p->next;
        p->next = reverseN(p->next , cnt  );
        return ret.next ;
    }
};

3. k个一组反转链表

leetcode 25

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) {
        // 节点p为虚拟头节点，即待反转节点的前一个结点         节点q为待反转的头节点， 即反转之后的尾节点
         ListNode ret (0 ,head ), *p = &ret ,*q =p->next ;
         while ((p->next = reverseN(q ,k))  != q ){
             p  =  q ;
             q  =  p->next ; 
         } 
         return ret.next; 
    }
};

4. 旋转链表

在这里插入图片描述

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 ++ ;
        p->next = head ; 
        k %= n ; 
        k = n - k ; 
        while( k-- ) p = p->next ; 
        head = p->next ; 
        p->next = nullptr ; 
        return head  ; 

    }
};

五、经典面试题-链表的删除

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

leeetcode 19

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 ; 
    }
};

2. 删除排序链表中的重复节点

leetcode 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 ;
    }
};

3.把链表中重复的节点全部删除

*leetcode 82 *

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode ret(0 , head) ,*p = &ret,*q = head ;
        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 ; 
    }
};
计算小法师
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
链表经典问题汇总
vivi的技术博客
08-09 1万+
收集了一下链表常见的面试为题： 1、如何判断一个单链表有环 2、如何判断一个环的入口点在哪里 3、如何知道环的长度 4、如何知道两个单链表（无环）是否相交 5、如果两个单链表（无环）相交，如何知道它们相交的第一个节点是什么 6、如何知道两个单链
链表问题
qq_39597583的博客
08-20 116
1判断链表中是否有环 设置一个快指针，慢指针，当存在环的情况下就会出现快慢指针相等的情况 public ListNode isLoop(ListNode head){//判断是否有环 ，快慢指针相遇，有环，         ListNode slow = head;         ListNode fast = head;         while(fast!=null &amp;&amp...
完全搞懂链表的常见的问题以及解法
最新发布
weixin_45765910的博客
05-11 538
你要是还对链表的各种问题搞不懂，不妨我们一起整，哈哈哈哈哈
各种数据结构存储方式记录一下
熊仙森滴Blog
04-11 355
1.vector 底层数据结构为数组 ，支持快速随机访问 2.list 底层数据结构为双向链表，支持快速增删 3.deque 底层数据结构为一个中央控制器和多个缓冲区，详细见STL源码剖析P146，支持首尾（中间不能）快速增删，也支持随机访问 4.stack 底层一般用23实现，封闭头部即可，不用vector的原因应该是容量大小有限制，扩容耗时 5.queue ...
十八道经典链表问题
04-06
经典链表问题，包含十八道题，包含递归问题等，是读懂链表的经典例题
简单的关于c++链表问题
11-06
简单的C++链表问题，欢迎大家下载
php基于环形链表解决约瑟夫环问题示例
10-19
`countChild`函数则是解决约瑟夫环问题的核心，它接受三个参数：链表的起始节点`$first`，开始报数的位置`$m`（即第几个人开始），以及报数后被淘汰的数`$k`。这个函数通过循环找到报数到`$k`的人，然后将其从链表中...
php使用环形链表解决约瑟夫问题完整示例
12-20
【约瑟夫问题】是一个经典的计算机科学问题，它源于一个假设的古代犹太人的故事，人们围成一圈，按照一定的规则淘汰，直到只剩一个人。在这个问题中，每个人都有一个唯一的编号，从1到n，从编号为k的人开始报数，数...
【链表及其经典问题】
chenjunheaixuexi的博客
07-20 279
假设head节点距离环的起点为a，当慢指针走到环的起点时，快指针距离环的起点也为a，假设此时快指针正向距离环的起点为x，那么当快指针向前走2x步，慢指针走x步时，他们两个相遇。顺序遍历链表，将其中的节点依次存入哈希表中，如果要存入的节点已经存在于哈希表中，则说明有环，遍历结束。因为环的总长度为a+x，因此此时他们距离环的起点距离为a，与起始点到环起点的距离相同。如果链表有环，那么快慢指针一定会相遇，指向同一个节点，当向同一个节点时，遍历结束。链表中的每个节点，通过指针域的值，形成一个线性结构。...
链表问题（1）
min_xi的博客
07-02 92
两个链表相交的一系列问题 1）判断单链表是否有环 有环返回第一个入环节点 无环返回NULL #include<iostream> #include<hash_set> using namespace std; typedef struct Node { int data; Node* next; }; typedef struct { Node* head...
链表相关问题
jing1008-wang的博客
08-31 163
今日份要点，叮~~ 链表的创建和遍历，统计节点个数，查找倒数第k个节点（查找中间节点于此类似），合并两个链表（个人感觉有点归并的意思），单链表从尾到头打印（使用栈和递归方法） package lianbiao; import java.util.Stack; class Node{     int data;//数据域     Node next;//指针域     public Node...
链表常见问题
weixin_43817702的博客
02-26 1008
链表常见的问题有这几种： 1、链表反转； 2、以一定顺序插入节点； 3、判断回文； 4、循环链表； 5、链表重排； 链表问题的解决方案无非就这几种： 1、双指针，用来删除倒数第几个节点，或者是寻找中间节点，或者是判断是否有环； 2、链表反转； 3、链表合并； ...
链表问题汇总
weixin_42438346的博客
08-26 165
//快慢指针 class Solution { public: ListNode* reverseList(ListNode* head) { if(head == NULL) return head; ListNode* pre = NULL, *cur = head, *tmp; while(cur != NULL){ tmp = cur->next; cur-&gt.
常见链表问题（整理）
weixin_53235104的博客
04-19 251
一、数组与链表 作为线性表的两种存储方式 —— 链表和数组，这对相爱相杀的好朋友有着各自的优缺点。接下来，我们梳理一下这两种方式。 数组，所有元素都连续的存储于一段内存中，且每个元素占用的内存大小相同。这使得数组具备了通过下标快速访问数据的能力。但连续存储的缺点也很明显，增加容量，增删元素的成本很高，时间复杂度均为 O(n)。 增加数组容量需要先申请一块新的内存，然后复制原有的元素。如果需要的话，可能还要删除原先的内存。 删除元素时需要移动被删除
链表的常见问题
李孟的博客
07-18 1842
链表指针转动，很容易转晕，介绍其中有几个常见的技巧。 一.指针/引用含义 指针/引用，实际上都是存储所指对象内存。 将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过来说，指针中存储了这个变量的内存地址，指向了这个变量，通过指针就能找到这个变量。 二.指针丢失和内存泄漏 插入节点时，注意操作顺序。 删除节点时，注意释放空间。 三.哨兵 哨兵结点的链表叫做带头链表，这样节省判断head == null 四.边界条件 如果链表为空时，代码是否能正常工作？ 如果链表只包含一个结点时，代码是否能

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值