C++ 数据结构——链表（一）

已于 2024-07-24 13:19:15 修改
阅读量727 收藏 6
点赞数 19
分类专栏： C++ 文章标签： 数据结构 c++ 链表 算法 开发语言 leetcode
于 2024-07-24 13:04:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ahjol171/article/details/140660116
版权

 单链表

其实可以简单的理解为数组，但只要用的好，实际功能是远远大于数组的，再此次文章中，我们暂且可以简单理解为数组，但不要被误导，两者实际上还有很多的不同（比如说数组的随机访问时间复杂度为O(1)而单链表为O(n)等等等等）

举个简单的链表

list = [ 1, 2, 3, 4, 5]  // 我们可以将其画出来，就像这样

1 -> 2 -> 3 -> 4 -> 5 //这里的每个数组就是链表的节点并通过 " -> " 串在了一起

意思也就是说，我们只要能将一些零零散散的节点像烤串一样串在一起，那么就是实现了一个简单的链表

算法逻辑

第一步（节点）

节点中需要存放数据，并且要利用指针访问

class Node 
{
public:
    int data;
    Node* next;
};

第二步（连接链表）

链表的链接与节点数据的存放是辩证统一的，两者缺一不可。

一个最基础的链表，至少具有插入元素和输出元素的功能，不过在此我也会实现链表的一些其他功能（随机访问，随机插入，排序等等等等）

链表功能

插入节点

表尾插入

意思就是说，我们将从头开始遍历链表（链表头号元素不为空的时候），持续遍历到不存在下一个节点为止，当程序发现不存在下一个节点时，在此处插入新的节点

void insert(int data) 
{
    Node* new_node = new Node();
    new_node->data = data;
    new_node->next = nullptr;

    if (head == nullptr) 
    {
        head = new_node;
    }
    else {
        Node* current = head;
        while (current->next != nullptr) 
        {
            current = current->next;
        }
        current->next = new_node;
    }
}

随机插入

和上述方法类似，也会从头开始遍历链表，但不会一直遍历到表尾（除非插入位置的值大于链表的长度），当遍历链表直至num的位置时插入新的节点

num = 我们需要插入元素的位置，并在此位置的左侧插入新的节点

void rand_insert(int num, int data) 
{
    Node* new_node = new Node();
    new_node->data = data;
    new_node->next = nullptr;

    if (head == nullptr) 
    {
        head = new_node;
    }
    else 
    {
        Node* current = head;
        int count = 0;
        while (current->next != nullptr && count < num) 
        {
            current = current->next;
            count++;
        }
        if (current->next != nullptr) 
        {
            new_node->next = current->next;
            current->next = new_node;
        }
        else {
            current->next = new_node;
        }
    }
}

这里着重说明一些核心代码
new_node->next = current->next

这一行将新节点的下一个节点指向当前节点的下一个节点。这样做的目的是在当前节点和它的下一个节点之间插入新节点，使得新节点成为当前节点的下一个节点。

current->next = new_node

这一行将当前节点的下一个节点更新为新节点。这样，新节点就被正确地插入到了链表中

输出链表

或许看到这里你也已经明白怎么输出链表了，还是跟上述插入节点一样，从表头开始遍历链表，每遍历完一个节点就输出这个节点的值即可

void display() 
{
    if (head == nullptr) 
    {
        return;
    }
    else 
    {
        Node* current = head;
        while (current->next != nullptr) 
        {
            cout << current->data << "->";
            current = current->next;
        }
        cout << current->data << endl;
    }
}

删除节点

有链表的插入那么也就有节点的删除，这里将通过访问链表中节点的位置来删除节点，就跟数组类似，访问到目标节点时停止遍历，使指向该节点的指针指向下一个节点，从而“跳过”此节点直接访问下一个节点

void delete_node(int num)
{
    if (head == nullptr) 
    {
        return;
    }
    else 
    {
        if (num == 0)
        {
            Node* temp = head;
            head = head->next;
            delete temp;
            return;
        }
        Node* current = head;
        int count = 0;
        while (count < num - 1) 
        {
            current = current->next;
            count++;
        }
        Node* temp = current->next;
        current->next = current->next->next;
        delete temp;
    }
}

返回链表长度

无需多元，从头开始遍历，设定一个计数器count使每遍历完一个节点进行count += 1 的操作，最后返回的count的值即为链表的长度

int len() 
{
    if (head == nullptr) 
    {
        return 0;
    }
    else 
    {
        Node* current = head;
        int count = 1;
        while (current->next != nullptr) 
        {
            current = current->next;
            count++;
        }
        return count;
    }
}

随机访问

位置访问

跟数组一样，在下表上写上链表中元素的位置，程序就会给你返回此位置元素的值，原理还是跟上述方法一样，从头开始遍历，直至遍历到num时停止并返回此时遍历到的元素的值即可

num = 需要访问的元素的位置

int value(int num) 
{
    if (head == nullptr) 
    {
        return -1;
    }
    else 
    {
        Node* current = head;
        int count = 0;
        while (count < num) 
        {
            current = current->next;
            count++;
        }
        return current->data;
    }
}

查找元素

给定一个数，查看链表中是否有这个数。

一般情况下我们可以通过遍历链表来实现，这是最无脑且有效的办法，但如果题目中有一些特殊情况，比如已排序的链表之类的话，那么我们可以用二分查找等方式降低程序的时间复杂的

不过遍历链表查找元素的时间复杂度也不高，为O(n)

num = 我们要查找的元素的值

 void get(int num)
 {
     if (head == nullptr) 
     {
         return;
     }
     else 
     {
         for (int i = 0; i < len(); i++)
         {
             if (value(i) == num) 
             {
                 cout << "找到元素" << num << ",其位置为" << i << endl;
                 return;
             }
         }
         cout << "链表中不存在该元素" << endl;
     }
 }

链表的排序

就跟数组的排序一样，根据链表中节点的值或者一些其他要求进行排序，这里以冒泡排序为例，不过冒泡排序是一个时间复杂度相对较高O(n**2)的排序方式，也是最简单通俗易懂的排序方式，在此不会多讲，博主会在下一期文章中专门讲11中不同的排序方式。

链表排序的底层逻辑就是节点内数据的交换，至于怎么交换，那么就取决于使用了什么样的排序方式了

void bubble_sort() 
{
    if (head == nullptr) 
    {
        return;
    }
    else 
    {
        bool swapped = true;
        while (swapped) 
        {
            swapped = false;
            Node* current = head;
            while (current->next != nullptr)
            {
                if (current->data > current->next->data) 
                {
                    swap(current->data, current->next->data);
                    swapped = true;
                }
                current = current->next;
            }
        }
    }
}

完整代码

#include <iostream>
using namespace std;

class Node 
{
public:
    int data;
    Node* next;
};

class LinkedList 
{
public:
    Node* head;
    LinkedList() : head(nullptr) {}

    void insert(int data) 
    {
        Node* new_node = new Node();
        new_node->data = data;
        new_node->next = nullptr;

        if (head == nullptr) 
        {
            head = new_node;
        }
        else {
            Node* current = head;
            while (current->next != nullptr) 
            {
                current = current->next;
            }
            current->next = new_node;
        }
    }

    void display() 
    {
        if (head == nullptr) 
        {
            return;
        }
        else 
        {
            Node* current = head;
            while (current->next != nullptr) 
            {
                cout << current->data << "->";
                current = current->next;
            }
            cout << current->data << endl;
        }
    }

    int len() 
    {
        if (head == nullptr) 
        {
            return 0;
        }
        else 
        {
            Node* current = head;
            int count = 1;
            while (current->next != nullptr) 
            {
                current = current->next;
                count++;
            }
            return count;
        }
    }

    int value(int num) 
    {
        if (head == nullptr) 
        {
            return -1;
        }
        else 
        {
            Node* current = head;
            int count = 0;
            while (count < num) 
            {
                current = current->next;
                count++;
            }
            return current->data;
        }
    }

    void rand_insert(int num, int data) 
    {
        Node* new_node = new Node();
        new_node->data = data;
        new_node->next = nullptr;

        if (head == nullptr) 
        {
            head = new_node;
        }
        else 
        {
            Node* current = head;
            int count = 0;
            while (current->next != nullptr && count < num) 
            {
                current = current->next;
                count++;
            }
            if (current->next != nullptr) 
            {
                new_node->next = current->next;
                current->next = new_node;
            }
            else {
                current->next = new_node;
            }
        }
    }

    void get(int num)
    {
        if (head == nullptr) 
        {
            return;
        }
        else 
        {
            for (int i = 0; i < len(); i++)
            {
                if (value(i) == num) 
                {
                    cout << "找到元素" << num << ",其位置为" << i << endl;
                    return;
                }
            }
            cout << "链表中不存在该元素" << endl;
        }
    }

    void delete_node(int num)
    {
        if (head == nullptr) 
        {
            return;
        }
        else 
        {
            if (num == 0)
            {
                Node* temp = head;
                head = head->next;
                delete temp;
                return;
            }
            Node* current = head;
            int count = 0;
            while (count < num - 1) 
            {
                current = current->next;
                count++;
            }
            Node* temp = current->next;
            current->next = current->next->next;
            delete temp;
        }
    }

    void bubble_sort() 
    {
        if (head == nullptr) 
        {
            return;
        }
        else 
        {
            bool swapped = true;
            while (swapped) 
            {
                swapped = false;
                Node* current = head;
                while (current->next != nullptr)
                {
                    if (current->data > current->next->data) 
                    {
                        swap(current->data, current->next->data);
                        swapped = true;
                    }
                    current = current->next;
                }
            }
        }
    }
};

int main() 
{
    LinkedList list;
    list.insert(5);
    list.insert(4);
    list.insert(3);
    list.insert(2);
    list.insert(1);
    cout << "链表初始化为：" << endl;
    list.display();
    int num = 4;
    list.delete_node(num);
    cout << "删除第" << num + 1 << "节点后" << endl;
    list.display();
    cout << "长度为：" << list.len() << endl;
    cout << "此位置元素值为：" << list.value(1) << endl;
    list.get(2);
    list.display();
    list.rand_insert(1, 9999); //在左侧插入
    list.display();
    list.bubble_sort();
    cout << "排序后的链表为：" << endl;
    list.display();
    return 0;
}

这就是本期文章的全部内容了，希望对你有帮助，在评论区留下自己的观点给博主提提建议。

当然，最重要的是，自己试试看吧，你会做的更好

我是阿核
关注
  • 19
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
C++——数组模拟链表
12-03
C++中的链表是数据结构中非常重要的一部分，而在链表中，我们可以使用数组来模拟链表的结构。今天，我们将讨论如何使用数组来模拟链表，并实现链表的插入和遍历操作。 首先，我们需要了解链表的基本结构。链表是一...
数据结构——链表的实现
12-29
在这个数据结构——链表的实现中，我们将深入探讨如何用C++来创建一个链表类，并实现搜索、删除、插入和查找等基本操作。 首先，链表的基本思想是使用节点（或称为元素）来存储数据，每个节点包含两部分：数据域和...
C++数据结构——栈.pdf
07-11
《C++数据结构——栈》 栈是一种在计算机科学中广泛应用的数据结构，它遵循“先进后出”（First In Last Out, FILO）的原则。在栈中，元素的插入（压栈）和删除（弹栈）操作只允许在栈顶进行。栈的主要特点在于其...
数据结构——链表合并
08-09
"链表合并"是一个常见的数据结构问题，特别是在处理动态数据集合时。本文将深入探讨链表合并的概念，以及如何通过C++来实现这个过程。 链表是一种线性数据结构，不同于数组，它的元素（节点）在内存中并不连续存放...
插入和选择排序
c23856的博客
07-20 535
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
【数据结构】搜索二叉树
dab112的博客
07-24 569
介绍了二叉搜索树的实现与模拟
数据结构（二叉树-1）
2401_83968713的博客
07-20 1077
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 959
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
《数据结构：栈和队列》
2401_83305953的博客
07-19 666
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行插入和删除操作的一端称为栈顶，另一端称为栈底。概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以由数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。：栈的插入操作叫做进栈/压栈/入栈/，入数据在栈顶。
数据结构——二叉树定义
鲸落博客
07-23 373
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
数据结构：栈
sparrowfart的博客
07-19 1173
满足栈的特性，只有先进后出的特性，不能遍历，也就不能遍历打印，也不能随机访问。
2024.7.24 作业
qq_64434282的博客
07-24 374
【代码】2024.7.24 作业。
数据结构的概念和术语
最新发布
2303_78660417的博客
07-24 364
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科。数据结构的基本数据结构包括两部分，线性结构跟非线性结构。
数据结构：二叉搜索树（简单C++代码实现）
2301_79171011的博客
07-22 830
本文将深入探讨二叉搜索树这一重要的数据结构。二叉搜索树不仅是一个功能强大的数据结构，而且在实际应用中展现出了极高的实用性。它以其独特的组织方式，使得查找、插入和删除操作都能在平均对数到线性时间内完成，从而大大提高了数据处理的效率。为了更好地理解二叉搜索树的工作原理，我们使用C++语言实现了一个简单的二叉搜索树。通过本文的阐述，相信你应该对二叉搜索树的基本概念、特性以及操作方法已经有了一定的了解。不过想要掌握这个数据结构，还需要亲自上手编写一个二叉搜索树的代码。通过编码实践，才能更深刻体会到内部的工作机制。
数据结构（1）
m0_63067779的博客
07-22 257
集合举例：候车室线性举例：排队问题，随着时间推移，后面不断地有人来，我慢慢往前挪树：图：网络节点，地图路线顺序存储：数组存链式：malloc申请空间，用链表存左边最好，右边最差。
初识数据结构中的“栈”
D1557329860的博客
07-21 218
除了入栈和出栈操作外，还可以对栈进行其他操作，如查看栈顶元素（peek）和判断栈是否为空等。此外，由于栈的后进先出特性，它也常被用于实现一些需要这种特性的算法，如深度优先搜索等。此外，在算法设计中，栈也常被用于实现一些复杂的逻辑，如表达式求值、括号匹配等。在栈中，数据的添加和移除都仅在栈顶进行，这种操作方式使得栈具有一种“后进先出”的特性。也就是说，最后一个被放入栈中的元素将会是第一个被取出的元素。总的来说，栈是一种非常有用的数据结构，它的后进先出特性和基本操作方式使得它在处理特定问题时具有独特的优势。
【手撕数据结构】把玩栈
apple_61439616的博客
07-21 192
栈(stack)，栈遵守先进后出的原则，即先入栈的数据后出栈，插入数据是在栈顶插入，被称为压栈。出栈也是与顺序表的尾删一样的，这里直接将top减减，不影响后面再次在那个位置插入数据，会直接覆盖.但需检测栈是否为空，若为空，则不能进行出栈操作。进行入栈操作前，我们需要检测栈的当前状态，若已满，则需要先对其进行增容，然后才能进行入栈操作。栈的内存空间是动态开辟出来的，当我们使用完后必须释放其内存空间，避免内存泄漏。因为栈也是一种线性表，并且在物理结构上也是连续的，所以我们底层采用数组(顺序表)实现。
（10）深入理解pandas的核心数据结构：DataFrame高效数据清洗技巧
架构筑梦的Cherry Yang的博客
07-20 1103
# 1. DataFrame数据清洗 在Python中，使用pandas库处理DataFrame时，高效的数据清洗是数据预处理的关键步骤之一。以下是一些高效的数据清洗技巧： ## 1.1 处理缺失值（NaNs） 在现实世界中，数据大多是杂乱无章的;它有多种形式和形状，并且有许多缺失值。有趣的是，根据 IBM Data Analytics 的数据，数据科学家花费高达 80% 的时间来查找、清理和组织数据。幸运的是，pandas 提供了许多强大、快速和高效的方法来检测、删除和替换 pandas DataFra
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值