链表C++详解（知识点+相关LeetCode题目）

花火の云

已于 2023-09-19 09:22:31 修改

阅读量353

点赞数 1

分类专栏：数据结构文章标签：链表 leetcode 数据结构算法

于 2023-09-18 11:44:07 首次发布

本文链接：https://blog.csdn.net/qq_60831089/article/details/131276055

版权

数据结构专栏收录该内容

11 篇文章 1 订阅

订阅专栏

前言

主要阐述了数据结构中链表的相关知识，也包括了链表相关的经典力扣题目

一、链表是什么

链表可以分为单端链表和双端链表

链表特点写入快，读很慢

二、链表的操作时间复杂度

1.访问遍历链表 O（N）

2.搜索遍历链表 O（N）

3.插入 O（1） -->前提：知道具体节点

4.删除 O（1） -->前提：知道具体节点

三、链表操作解释

+-------+ +-----------+ +---------+

| | | | | |

| Node1 | ---> | Node2 | ---> | Node3 |

| | | | | |

+-------+ +----------+ +----------+

在链表的相关题目中，首先需要明白每一步的含义，才不会使得写代码时候产生不确定的情况，所以先对head=head->next这个操作进行详细的解释，对于Node1和Node2而言

设head是指向Node1的指针，那么head->next就是指向Node2的指针

所以实际的效果是将head这个指针更新为指向Node2，直观来说就是将指针从Node1的位置移动到Node2

如果基于此而不断执行这个函数，head所指向的节点就会从Node1变成Node2，接着Node3，接着Node4，接着Node5...... 这也就是我们一贯称呼的遍历列表。

四、链表中的头指针和头结点

头指针：一般用来标识一个链表，如果头指针为NULL的时候，说明这个链表是一个空链表，当链表非空的时候，头指针就会指向第一个节点

头结点：在单链表的第一个结点之前附加一个结点，就是头结点，头结点可以不设置任何的Data数值。

联系：若链表中带有头结点的，那么头指针会指向头结点的位置

五、链表经典力扣题目：

1.移除链表元素 203

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        while(head!= NULL && head->val == val){
            //当头指针的值是需要删除的点的时候，将head指向原本head的下一个节点
            head = head->next;
            //并且如果全是要删除的结点，就到不为为止，实在不行为空
        }
        ListNode* cur;
        cur = head;
        //若是当前点为空或者下个节点为空
        while(cur !=NULL && cur->next != NULL){
            //在目标前面的点判断，对目标前面的点操作
            if(cur->next->val == val){
                cur->next = cur->next->next;//原本的next指向了下下个节点
            }
            else{
                cur = cur->next;//cur的地址为下一个节点的地址，即为往下
            }
        }
        return head;

    }
};

知识点：

虚拟头结点定义一个结点指向头结点之后，下面的只需要重复之前“寻找前一个结点，指向改变”这样的操作就OK。这个结点就是虚拟头结点。

2.设计链表 707

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

MyLinkedList() 初始化 MyLinkedList 对象。
int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例：

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

class MyLinkedList {
public:
    //定义链表结构体
    struct ListedNode{
        int val;
        ListedNode* next;
        //定义构造函数 --:--{} 构造函数的一种书写方式
        ListedNode(int val):val(val),next(nullptr){}
    };

    //初始化链表
    MyLinkedList() {
        //初始化大小和虚拟头结点
        fakehead = new ListedNode(0);
        _size = 0;
    }
    
    // 获取链表中下标为 index 的节点的值
    int get(int index) {
        if(index >(_size-1) || index <0){
            return -1;
            //不能超过实际大小（从0开始_size已经是极限）
        }
        ListedNode* cur = fakehead->next;//为第一个结点下标为0的点
        while(index--){
            cur = cur->next;
        }

        return cur->val;
    }
    
    //将一个值为 val 的节点插入到链表中第一个元素之前
    void addAtHead(int val) {
        ListedNode* newNode = new ListedNode(val);
        newNode->next = fakehead->next;//一定要先指向，否则fakehead->next指向newNode
        fakehead->next = newNode;

        _size++;//别忘记扩充
    }
    
    //将一个值为 val 的节点追加到链表中作为链表的最后一个元素
    void addAtTail(int val) {
        ListedNode* cur = fakehead;//为第一个结点下标为0的点，因为有可能还没有插入结点
        while(cur->next != nullptr){
            //保证cur和尾结点平级
            cur = cur->next;
        }
        ListedNode* newNode = new ListedNode(val);
        cur->next = newNode;//到此结束，因为newNode默认为指向null

        _size++;//别忘记扩充
    }
    

    //将一个值为 val 的节点插入到链表中下标为 index 的节点之前
    void addAtIndex(int index, int val) {
        if(index >(_size) || index<0){return;}//默认size为长度，按照题意来

        ListedNode* cur = fakehead;//cur为虚拟结点，next指向第一个结点
        ListedNode* newNode = new ListedNode(val);
        while(index--){
            cur = cur->next;
        }
        //此时返回的是目标节点前面一个点
        newNode->next = cur->next;
        cur->next = newNode;

        _size++;//别忘记扩充
    
    }
    
    //如果下标有效，则删除链表中下标为 index 的节点
    void deleteAtIndex(int index) {
        if(index >(_size-1) || index<0){return;}
        ListedNode* cur = fakehead;//cur为虚拟结点，next指向第一个结点
        while(index--){
            cur = cur->next;
        }
        //此时返回的是目标节点前面一个点
        ListedNode* temp = cur->next;
        cur ->next = cur->next->next;
        delete temp;//删除内存
        temp = nullptr;//去除野指针

        _size--;//别忘记减小
    }

private:
    //定义只在类中变化的值
    int _size;
    ListedNode* fakehead;//虚拟头结点
};

知识点：（待）

3.反转链表 206

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head;
        ListNode* pre = nullptr;
        //双指针，让cur指向pre
        while(cur!=nullptr){
            //最后一个节点指向完后，cur会指向null
            ListNode* temp = cur->next;
            cur->next = pre;
            pre=cur;//移动到下一个节点
            cur=temp;//移动到下一个节点
        }

        return pre;//最后一个节点指向完后，pre会指向最后一个节点
    }
};

知识点：（待）

4. 两两交换链表中的节点 24

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        //使用双指针思路
        ListNode* fakeNode = new ListNode(0);//虚拟头结点
        fakeNode ->next = head;//要交换一定要知道前面一个点
        ListNode* cur=fakeNode;//进行遍历的点

        while(cur->next != nullptr && cur->next->next != nullptr){
            //分奇数和偶数的情况
            ListNode* node1 = cur->next;//保存节点1
            ListNode* node3 = cur->next->next->next;//保存节点3
            cur->next = cur->next->next;//指向节点2
            cur->next->next = node1;//节点2指向节点1
            node1->next= node3;//节点1指向3
            //链表是在连接着，cur为当前节点12的前置节点
            cur=cur->next->next;//cur往后移两格，成为节点3的前置节点
        }

        return fakeNode->next;//返回真正头结点

    }
};

知识点：

为什么不能直接声明 ListNode* fakeNode; 而要实例化一个新的 ListNode 对象呢？

这是因为在 C++ 中，对指针进行声明时，如果不初始化它，它会成为一个悬空指针（dangling pointer），指向不确定的内存区域。如果在后续的代码中尝试使用悬空指针，会导致不可预测的行为和错误。

通过实例化一个新的 ListNode 对象，并将其指针赋值给 fakeNode，我们确保了 fakeNode 不是悬空指针，而是指向有效的内存地址的指针。这使得我们可以在后续的代码中正确地使用 fakeNode，而不会导致问题。

因此，在这段代码中，为了创建一个有效的虚拟头节点，需要实例化一个新的 ListNode 对象，并将其指针赋值给 fakeNode 变量。

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

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* fakehead = new ListNode(0);
        fakehead->next = head;
        ListNode* fast = fakehead;
        ListNode* slow = fakehead;
        while(n-- && fast!=nullptr){
            //让fast指针移动n次
            fast = fast->next;         
        }
        //同时移动，让slow位于目标结点的前置结点
        while(fast->next != nullptr){
            //同时移动size-n-1次--少移动一次
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* temp = slow->next;
        slow->next = slow->next->next;
        //删除内存，去除指针
        delete temp;
        temp=nullptr;

        return fakehead->next;
        
    }
};

知识点：（待）

6.环形链表 142

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast!= nullptr&&fast->next != nullptr){
            //两步长，所以双判定
            fast=fast->next->next;
            slow = slow->next;
            if(slow == fast){
                //相遇
                ListNode* node1 = fast;//定义点
                ListNode* node2 = head;
                //模拟回退过程x=（n-1）（y+z）+z
                while(node1!=node2){
                    node1 = node1->next;//在圈内不断的转
                    node2 = node2->next;
                    //相遇点到连接点的距离，一定等于头部点到连接点的距离 x=z的意思是不管多套了几圈，两个点终究会在连接点相遇，因为x=（n-1）（y+z）+z
                }
                return node1;
            }
        }

        return nullptr;
    }
};

题解：

推理fast两步长速度，slow一步长速度，双指针同时移动
到fast和slow相遇的时候，slow走了x+y的距离，fast走了x+y+n(y+z)的距离，slow一定走不到一圈就被追上，因为fast比slow快了正好一个步长，也就是说即使隔了一整圈，在slow跑完一圈之前，就会被fast追上。
由于fast速度是slow的两倍，所以可以列出等式2（x+y）=x+y+n（y+z），分析x=（n-1）（y+z）+z，详情结合代码分析，这只是个规律