c++数据结构——链表

最新推荐文章于 2024-09-25 15:54:35 发布
最新推荐文章于 2024-09-25 15:54:35 发布
阅读量2.2w 收藏 421
点赞数 45
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35686734/article/details/117637265
版权

1.链表基础知识：

  1. 链表分类：单链表、双链表、循环链表
  2. 链表的存储：散乱分布，通过指针域的指针链接在一起
  3. 链表的定义：此处给出单链表的c++定义
struct ListNode {
   int val;  // 节点上存储的元素
   ListNode *next;  // 指向下一个节点的指针
   ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};
  1. 链表初始化及调用：
ListNode* head = new ListNode(5); //使用上述定义中的构造函数来初始化

ListNode* head = new ListNode(); //使用c++默认构造函数来初始化
head -> val = 5;

int a = head -> val;  //调用的方式
ListNode* temp = head;  //head其实是链表的首地址，有了首地址就有了整个链表
temp = head -> next;
  1. 链表的操作：删除节点、增加节点
    删除节点
    在这里插入图片描述
  2. 性能分析
    链表的查询都是要从头节点开始遍历的，所以时间复杂度是O(n)，但是空间复杂度较低，一般都是O(1)
    在这里插入图片描述

2.典型题

2.1删除节点

leetcode地址：https://leetcode-cn.com/problems/remove-linked-list-elements/

2.1.1 直接删除

直接用原链表进行删除操作（在删除头节点时需要一段单独的逻辑去判断和操作），注意在c++中内存是要自己释放的，用delete关键字。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        //删除头节点
        while((head != NULL)&&(head->val == val)){ //不是空链表且头节点的值与目标值相等
            ListNode* temp = head;
            head = head->next;
            delete temp;
        }
        //删除非头节点
        ListNode*  cur = head;  //头节点不动，
        while((cur != NULL)&&(cur->next != NULL)){//不是空链表且不是尾部节点
            if(cur->next->val == val){ //如果下一个节点的值等于目标值，跳过，且删除
                ListNode*  temp = cur->next; //
                cur->next = cur->next->next;
                delete temp; 
            }
            else{
                cur = cur->next;
            }
        }
        return head;
    }
};

2.1.2 虚拟头节点

设置一个虚拟头节点再进行删除操作。
在这里插入图片描述

class Solution {  //虚拟头节点的方法
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummynode = new ListNode(0); //新建一个链表，虚拟头节点
        dummynode->next = head;   
        ListNode* cur = dummynode; //
        while(cur->next != NULL){  
            if(cur->next->val == val){
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            }
            else{
                cur = cur->next;
            }
        }
        head = dummynode->next;  //改变链表头节点的位置，还原链表
        delete dummynode;   //虚拟的头节点要删除掉
        return head;       
    }
};

2.2设计链表

leetcode地址：https://leetcode-cn.com/problems/design-linked-list/
在这里插入图片描述
这道题目设计链表的五个接口：

  • 获取链表第index个节点的数值
  • 在链表的最前面插入一个节点
  • 在链表的最后面插入一个节点
  • 在链表第index个节点前面插入一个节点
  • 删除链表的第index个节点
class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    void addAtIndex(int index, int val) {
        if (index > _size) {
            return;
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;

};

2.3反转链表

leetcode地址：https://leetcode-cn.com/problems/reverse-linked-list/

2.3.1双指针法

初始化如下图，再定义一个中间链表节点temp，接收cur节点。cur做翻转节点，将next指向pre。
在这里插入图片描述

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = new ListNode();  //初始化一个 null指针的节点
        pre = nullptr;
        ListNode* cur = new ListNode();
        cur = head;
        ListNode* temp;
        while(cur != nullptr){
            temp = cur->next;  //
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

2.3.2递归法

2.4 两两交换链表中的节点

leetcode地址：https://leetcode-cn.com/problems/swap-nodes-in-pairs/在这里插入图片描述
还是要虚拟一个头节点比较好做，指向原始节点，这样就是以3个节点为一个单元进行操作。

class Solution {    //空间复杂度 O(1), 时间复杂度O(n) 
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* temp;
        ListNode* temp1;
        ListNode* dummynode = new ListNode(0);
        dummynode->next = head;  //虚拟头节点指向 原始头节点
        ListNode* cur = dummynode;
        while(cur->next!=nullptr && cur->next->next!=nullptr){
            temp = cur->next;  //保存临时节点
            temp1 = cur->next->next->next;
            
            cur->next = temp->next;   //step1
            cur->next->next = temp;  //step2
            temp->next = temp1;    //step3
            cur = temp;            //准备下一轮
        }
        return dummynode->next;
    }
};

2.5 删除倒数第n个节点

leetcode地址：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/
在这里插入图片描述

2.5.1 两次扫描

第一次计算节点个数，第二次删除节点

class Solution {   //空间复杂度 O(1), 时间复杂度O(n) 
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummynode = new ListNode(0);
        dummynode->next = head;  //还是要虚拟一个头节点，因为有可能删除的是头节点
        int count = 0;
        int time = 0;
        ListNode* temp = dummynode;  //第一轮计数用
        ListNode* temp2 = dummynode;  // 第二轮扫描
        ListNode* temp1; //删除节点用
        
        while(temp->next != nullptr){  //第一轮扫描确定链表元素个数
            temp = temp->next;
            count++;
        }
      //  printf("%d", count);  //测试计数值
        while(temp2->next != nullptr){
            time++;
            if(time == count-n+1){   
               // printf("%d", time); //测试判断是否正确
                temp1 = temp2->next;
                temp2->next = temp1->next;
                delete temp1;
            }
            else{
                temp2 = temp2->next;
            }
        }
        return dummynode->next;  
    }
};

2.5.2 单次扫描完成

双指针法，其实也不止扫描了一次，快指针一次，慢指针一次，但是在时间上是有所重叠的。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);  //虚拟头节点，便于删除真实头节点
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast != NULL) {  //fast指针走n步
            fast = fast->next;
        }
        fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        return dummyHead->next;  //有虚拟头节点的程序，返回的都应该是虚拟头节点下面一个指向
    }
};

2.6 链表相交

leetcoed地址：https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/
在这里插入图片描述
长链表与短链表头部对齐再往下对比是否相等。相交，即是同一节点，值、指针都相等才行。
在这里插入图片描述

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* temp = headA;
        ListNode* temp1 = headB;
        int lenA = 1, lenB = 1;
        while(temp != NULL && temp->next != NULL){ //计算链表A的长度，要判断空链表的情况
            lenA++;  
            temp = temp->next;
        }
        //printf("%d", lenA);
        while(temp1 != NULL &&temp1->next != NULL){  //计算链表B的长度，要判断空链表的情况
            lenB++;
            temp1 = temp1->next;
        }    
        //printf("%d", lenB);   
        temp = headA;
        temp1 = headB;
        if(lenB > lenA){
            swap(lenA,lenB);
            swap(temp,temp1);
        }
       int dlen = lenA-lenB;
        while(dlen--){
            temp = temp->next;
        }
        while(temp != NULL && temp1 != NULL){ //要一直走到空指针，空链表的判断一个都不能少。
            if(temp == temp1){
                return temp;
            }
            temp = temp->next;
            temp1 = temp1->next;
        }
        return 0;

    }
};

2.7 环形链表

leetcode地址：https://leetcode-cn.com/problems/linked-list-cycle-ii/
在这里插入图片描述
解题分析链接：https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.md

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};
C++链表
Foools的博客
11-17 1344
文章目录前言一、动态链表存储二、建立和遍历列表三、插入节点四、删除节点 前言 链表相对于列表，数组来说，访问不方便，长度可变，插入新元素方便。本文仅介绍单向列表。 一、动态链表存储 每个节点都需要存储后继节点的地址，让一个个元素串联起来，这样就能形成一个单向链表。 综上，单项列表的数据元素是一个结构： struct Node { char name[20]; double salary; Node * next; }; 二、建立和遍历列表 建立单向列表的过程可以描述为： 生成头结点； whil.
单链表
SCUT 段九鼎(C/C++学生)
08-01 387
C++之链表
gghhb12的博客
04-05 3164
C++之链表
C/C++中的链表数据结构实战
最新发布
weixin_35762258的博客
09-25 1000
本文还有配套的精品资源，点击获取 简介：链表是计算机科学中的基础数据结构，尤其在C/C++编程中。它通过节点和指针链接数据，与数组不同，不依赖于连续内存地址。本教程涵盖链表的基本概念、创建过程、基本操作（插入、删除、遍历、查找），以及双向链表和循环链表的介绍。掌握链表的实现是深入学习数据结构和算法的基础。 1. 链表基本概念 链表是一种常见的基础数据结构，它...
链表详解（C++）
qq_59747679的博客
05-29 305
简单易懂实用的链表使用方法C++
c++链表
2301_76461941的博客
02-14 928
c++链表
C++ 链表
热门推荐
m0_62175410的博客
07-26 3万+
C++链表笔记
单链表，循环链表，双链表及其基本操作（C++实现）
My vegetable has exploded.
07-16 8315
    最近在学习严蔚敏教授的《数据结构》，有一些感想，在这里写下来，留做笔记，希望能对以后学习有所帮助。     我们知道，线性表就是n个数据元素的有限序列，它有两种实现方式，其一为顺序表，即数组+伪指针的方式实现，另一为链表，采用的是指针的方式实现。由于顺序表的知识偏向基础且其应用灵活性不高，故在此不再介绍，本文主要说明几种常用的链表是如何实现的以及其基本操作。 1.单链表：     单...
c++中的链表
liujassin的博客
06-09 552
本文主要简介了链表的原理在c++中的主要作用和使用方法和一些经典的例题
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
数据结构——链表的实现
12-29
在这个数据结构——链表的实现中，我们将深入探讨如何用C++来创建一个链表类，并实现搜索、删除、插入和查找等基本操作。 首先，链表的基本思想是使用节点（或称为元素）来存储数据，每个节点包含两部分：数据域和...
C++数据结构——栈.pdf
07-11
《C++数据结构——栈》 栈是一种在计算机科学中广泛应用的数据结构，它遵循“先进后出”（First In Last Out, FILO）的原则。在栈中，元素的插入（压栈）和删除（弹栈）操作只允许在栈顶进行。栈的主要特点在于其...
C++ 数据结构——链表实现
zlb666的博客
08-23 3343
最近使用C++实现数据结构链表，记录一下方便以后复习，若有错误，敬请指正， 1、创建头结点 链表的基本节点是Node，首先手动创建一个Node struct Node { int data; Node *next; Node(const int&amp; da) :data(da), next(nullptr){} ...
数据结构 —— 链表
Labrador_Katie的博客
08-28 1167
链表线性表链表的分类单向链表双向链表循环链表 线性表 线性表：由零个或多个数据元素组成的有限序列。 线性表有两种存储方式： 顺序存储结构——即数组 链式存储结构——即链表 线性表强调： 它是一个序列，元素之间有个先来个后到； 若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他元素有且只有一个前驱和后继； 线性表强调是有限的。 链表的分类 单向链表 单向链表是最简单的链表形式。我们将链表中最基本的数据称为节点(node)，每一个节点包含了数据块和指向下一个节点的指针。 特点：用一组任意的存储
链表（c++）
HUGOPIGS的博客
01-15 324
数据结构--链表（c/c++）一、线性表（1）线性结构（2）合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 一、线性表 线性表（...
链表（c++)
朱家小旺
10-10 381
一、单链表实现： #include<iostream> #include<vector> using namespace std; class intSLLnode { public: intSLLnode(){ next = 0; } intSLLnode(int i,intSLLnode *in = 0){info = i;next = in;} //private: int info; //用于存储信息 intSLLn
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值