1. 链表

最新推荐文章于 2023-01-09 14:23:48 发布
最新推荐文章于 2023-01-09 14:23:48 发布
阅读量387 收藏 1
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54135264/article/details/125699753
版权

文章目录

一、什么是链表？

线性表是很常用的数据结构，分为顺序表和链表。
按照正常方式定义以一个数组，计算机会从内存中取出一块连续的地址来存放给定长度的数组；而链表则由若干个节点组成，且结点在内存中的存储位置不连续，链表的两个节点之间一半由一个指针从一个结点指向另一个结点，故链表结点由两部分组成：即数据域和指针域。

程序内部
在这里插入图片描述

  1. 链表中的每个节点至少包含 数据域 和指针域
  2. 链表中的每个节点，通过指针域的值，形成一个线性结构
  3. 查找节点 O(n)，插入节点 O(1)，删除节点 O(1)
  4. 不适合快速的定位数据，适合动态插入和删除的场景

单向链表与数组
单向链表：必须挨个查找元素 ——>>查找节点 O(n)，插入节点 O(1)，删除节点 O(1)
数组：可以随机访问元素——>>查找节点 O(1)，插入节点 O(n)，删除节点 O(n)

二、经典的链表实现方法

struct Node {
	Node(int data):data(data),next(NULL){} //node构造函数
	int data;
	int *next;
};


int data[10];
int next[10];

//ind 后添加节点 p ，节点p中值为val
void add(int ind, int p, int val) {
	next[ind] = p;
	data[p] = val;
	return ;
}

三、应用场景

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

原有4G , malloc（1GB),分块后以链表链接
在这里插入图片描述

2.LRU缓存淘汰算法

插入数据5，插入到尾部，删除数据1
在这里插入图片描述

四、经典面试题

1. 链表的访问

环形链表
在这里插入图片描述
a.如何判定链表有环
方法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;
        ListNode *p = head,*q = head->next;
        while(p != q && q && q->next){
            p = p->next;
            q = q->next->next;
        }
        return q && q->next;
    }
};

b.如何判定环的起始位置
将一个指针放在链表起始位置，另一个指针放在相遇位置，两个指针一起朝后走，相遇位置就是环的起始位置

LeetCode 142.环形链表Ⅱ

//8ms
/**
 * 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;
    }
};

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

    }
};

LeetCode 202.快乐数

[快乐数] 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false

在这里插入图片描述
题目转化为：判断链表是否有环
如果遍历某个节点为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;
    }
};

2. 链表反转

  1. cur——> null
    在这里插入图片描述
  2. pre移动到cur所在位置，移动cur到next所在位置，next也后移（ pre 指向反转头，cur指向未反转头）

在这里插入图片描述
在这里插入图片描述
3.重复上述操作

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 head;
        ListNode *pre = nullptr, *cur = head, *p = head->next;
        while(cur){//未翻转部分不为空时
            cur->next = pre;
            pre = cur;
            (cur = p) && (p = p->next);
        }
        return pre;
    }
};

递归实现

/**
 * 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 || 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 = reverse(head->next,n-1);
	head->next = tail->next;
	tail->next = head;
	return p;
}

LeetCode 92.翻转从m到n的链表

采用虚拟头节点
找到要反转的第一个节点，以此为新链表翻转前m-n+1位，再将第一个节点指向头节点。

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 left, int right) {
        ListNode ret(0,head),*p = &ret;
        int cnt = right - left + 1;
        while(--left) p = p->next;
        p->next = reverseN(p->next, cnt);
        return ret.next;
    }
};

LeetCode 25.K个一组翻转链表

1.加虚拟头，p->虚拟头，q = p->next

/**
 * 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* __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;
    }
};

LeetCode 61.旋转链表

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

3. 链表删除操作

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

设置两个指针，q先走N步，然后p,q一起走直到q指向null时，p指向删除节点的前一个结点

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

LeetCode 83. 删除排序链表中的重复元素

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

LeetCode 82. 删除排序链表中的重复元素 II

/**
 * 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* deleteDuplicates(ListNode* head) {
        if(head == nullptr) return nullptr;
        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;
    }
};

4.什么时候使用虚拟头指针？

  • 链表的头地址可能发生改变时使用虚拟头指针
Crazy_张老板
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
1-5 LC25 K个一组翻转链表 LC61 旋转链表 LC24 两两交换链表中的节点 Java力扣刷题笔记
一碗菜粥的博客
04-24 248
LC25 K个一组翻转链表 LC61 旋转链表 LC24 两两交换链表中的节点
一、基础数据结构-1.链表-2.静态链表
最新发布
01-17
一、基础数据结构-1.链表-2.静态链表
数据结构中的链表
jiangjunyuan168的博客
12-01 1018
什么是链表 链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。 相对于数组，链表有以下优点： 内存空间不是必须连续的，可以充分利用计算机的内存，实现灵活的内存动态管理。 链表不必在创建时就确定大小，并且大小可以无限的延申下去。 链表在插入和删除数据时，时间复杂度可以达到O(1)，相对数组效率高很多。 相对于数组，链表有以下缺点： 链表访问任何一个位置的元素时，都需要从头开始访问（无法跳过第一个元素访问链表中的其他元素
访问链表中的某个元素（快慢指针）
Turing_Sheep的博客
10-30 731
本题可以帮助大家了解快慢指针在不同场景下的应用，同时帮助大家更好地理解链表。
【数据结构】关于顺序表和链表的区别及访问方式
m0_49442965的博客
07-01 1286
顺序表和链表的区别1.顺序表和链表都具有增、删、查、改的相同功能，但算法复杂度却不相同。增： a) 顺序表往指定位置，不覆盖的添加一个值，后面的值日要往后移动，算法复杂度为O(n)； b) 链表往指定位置添加一个节点，需要从表头遍历到指定位置，算法复杂度为O(n)，如果带有索引的节点，算法复杂度为O(1)。 删： a) 顺序表指定位置，删除一个值时，需要将后面的值向前移动，算法复杂度为O(n); b) 链表指定一个位置，删除一个时，如果没有对指定节点进行索引，需要从表头遍历到指定位置，然后将指定节点删除，算
C语言链表---访问链表（3）
naturly的博客
05-06 1113
访问链表主要是对链表的数据进行访问 例如; 求链表数据的平均值 struct node { int data ; struct node *next; }; 注意：head 一般是不能动的，因此我们要定义指针P，指向第一个结点 struct node { int data ; struct node *next; }; struct node *p; i...
20.链表中倒数第k个节点1
08-03
解答一遍历链表两次，第一次获得长度，第二个走(n-k+1)步ListNode* findK(ListNode* head,unsigned int k)解答二双
4. 链表-最简单的递归结构1
08-03
答案隐藏在了题干中: 小青蛙每次能跳1阶或者2阶如果小青蛙第一次跳了1阶，那么还剩下n-1阶如果小青蛙第一次跳了2阶，那么还剩下n-2阶实现递归的关键就在于如何
2. 链表-一根绳上的蚂蚱1
08-03
链表定义链表（Linked List）是一种线性表数据结构，使用非连续的内存空间，存储相同或者不同类型的元素，但不要求元素大小相等使用链表存储不同的元素视具体语
22.反转链表1
08-03
22.反转链表1
单链表的访问。
头秃程序员的日常
04-30 3209
单链表的访问： 只要我有头指针head，就可以通过其成员next继而找到下一个结点，以此类推可以访问所有的结点。 所谓的访问可以理解为取各个结点数据域的值进行一系列的操作，输出单向链表各个结点的数据域是最简单的访问链表的操作。 将链表中各个结点数据一次输出的步骤主要如下： （1），找到链表的头指针 （2），若链表非空，则输出结点的成员值。否则退出 （3），寻找下一个结点 （4），转到...
算法-访问链表中间元素
谈谈1974
09-03 844
1. 获取链表中间元素 一次遍历获取到链表长度（n）的中间元素（n/2）。 如链表为 ：1->6->4->5->7->4, 链表长度为6，则其中间元素为 list.get(3) 2. 解法 快慢指针,当快指针到达链表尾部时,慢指针到达链表中部 public ListNode findMidNode(ListNode root) { if (root ==...
链表
weixin_40805537的博客
03-09 128
数组需要一块连续的内存空间来存储，对内存的要求比较高。当内存中没有连续的，足够大的存储空间时，即便内存的剩余总可用空间大于需要的空间，仍然会申请失败。 而链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针"将一组零散的内存块串联起来使用。 单链表 其中，我们把内存块称为链表的“结点”。为了将所有的结点串起来，每个链表的结点除了存储数据之外，还需要记录链上的下一个结点的地址。我们把这个记录下...
C语言链表的任意访问与快速排序
aliveriver的博客
01-09 86
基于链表任意访问的链表快排
头插法建立单链表
淹不死的狐狸的博客
07-30 713
windows vc6.0++下通过 输入数字，-1结束； #include<stdio.h> typedef struct link//定义一个结构体，里面只有一个int数据 *next用来存放下一个节点的地址 { int data; struct link *next; }LINK; //////////////////////////////////////单链表的...
关于单链表 访问的思考
boshuzhang的专栏
07-30 188
ListNode* FindFirstCommonNode(ListNode* pHead1, ListNode* pHead2) { ListNode* p1 = pHead1; ListNode* p2 = pHead2; int len1 = 0; int len2 = 0; int diff; while(p1) { l...
【程序员面试金典】删除单向链表中间的某个结点，假定你只能访问该结点。
Twinkle
07-20 507
题目描述 实现一个算法，删除单向链表中间的某个结点，假定你只能访问该结点。 给定待删除的节点，请执行删除操作，若该节点为尾节点，返回false，否则返回true 直接吧=把下一个节点的地址给当前的节点地址。 /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), ...
【Linux】list.h中链表的结构与访问方式（与双循环链表对比）
sky_011的博客
03-17 1262
内核结构体与我们常使用的双向链表有什么区别？ 内核结构体是如何访问下一个节点的数据的呢？
指针访问链表的问题
陈刚编程心得与知识集
04-29 520
具体代码如下： fun的功能是连接两个单链表。 void fun(node *la,node *lb) {     while(la != NULL)     {         la=la->next;     }//找到第一个链表的最后一个值     la =lb->next;//第一个链表的最后一个节点 指向lb的非头节点 } int _tmain(int argc,
用C或C++编程编译运行实现一个链表，链表主函数功能菜单需要实现以下功能1.创建链表2.链表的按位查找3.链表的按位插入和按位删除4.实现两个有序链表的合并操作
10-28
1. 定义链表节点的结构体，包含数据和指向下一个节点的指针。 2. 定义链表的头指针，并初始化为空。 3. 实现创建链表的函数，通过循环输入数据并创建节点，将节点插入链表中。 4. 实现按位查找链表节点的函数，通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值