C++数据结构之单链表

最新推荐文章于 2024-07-29 22:27:16 发布
最新推荐文章于 2024-07-29 22:27:16 发布
阅读量1.7k 收藏 18
点赞数 3
分类专栏： 数据结构，算法与思维 文章标签： c++ c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suren_jun/article/details/126855116
版权

废话不多说，直接上干货

这里我们比较头节点不存储数据和头节点存储数据两种情况下的结构特点

1.链表的结构定义

//头节点没有数据
typedef struct Node{
    int data;//存放数据
    Node* next;//指向下一个节点
    Node(): data(0),next(NULL){}  //头节点直接调用默认构造就可以了
    Node(int x): data(x),next(NULL){}
}*ListNode;

//头节点存储数据
typedef struct Node1{
    int data;//存放数据
    Node1* next;//指向下一个节点
    Node1(int x): data(x),next(NULL){}
}*ListNode1;

int main()
{
    ListNode head = new Node();
    cout << head->data << endl;
    ListNode1 head1 = new Node1(10);
    cout << head1->data << endl;
    system("pause");    // 防止运行后自动退出，需头文件stdlib.h
    return 0;
}

上述定义了一个单链表的节点，包含数据和后继指针，使用了两种方法，一种是头节点有数据，一种是头节点无数据。

  • 这里采用初始化列表的方式初始化Node，不仅仅是因为这样书写简洁方便，而是这种方式在有些时候是比在函数体里面初始化更加的高效，希望能养成习惯。
  • 使用typedef的方式在下方定义的*ListNode是一个结构体类型而不是一个变量。

2.建立一个线性链表

这里是将数组元素生成为一个单链表，复杂度为O(n)。

先采用头节点无数据的实现

template<typename T>
void CreateList(ListNode &link_list, T arr, int len){
    Node* p = link_list;
    for(int i=0; i<len; i++){
        p->next = new Node(arr[i]);
        p = p->next;
    }
}

void ShowList(const ListNode &link_list){
    Node* p = link_list->next;
    if(NULL == p) return;
    while(NULL != p->next){
        cout << p->data << "\t";
        p = p->next;
    }
    cout<<p->data << endl;
}

int main()
{
    vector<int> a = {1,2,3,4,5};
    int b[5] = {1,2,3,4,5};
    ListNode link_list = new Node();
    CreateList(link_list, a, a.size());
    ShowList(link_list);

    system("pause");    // 防止运行后自动退出，需头文件stdlib.h
    return 0;
}

对于链表的操作，常常需要定义一个额外的指针，用于指向链表这个数据结构，并进行数据的访问。

  • 这里CreateList采用了泛型，但是这里不想麻烦了，自己懂就可以了。
  • 这里因为头节点不存储数据，所以在输出时，就进行了一个判断。

下面是头节点存储数据的实现

template<typename T>
void CreateList(ListNode link_list, T arr, int len){
    if(len == 0) return;
    link_list = new Node(arr[0]);
    Node* p = link_list;
    for(int i=1; i<len; i++){
        p->next = new Node(arr[i]);
        p = p->next;
    }
}

void ShowList(const ListNode &link_list){
    Node* p = link_list;
    if(NULL == p) return;
    while(NULL != p->next){
        cout << p->data << "\t";
        p = p->next;
    }
    cout<<p->data << endl;
}

头节点有数据，在创建的时候，需要注意给link_list表创建头节点

3.求线性链表的长度

同样的，先是头节点无数据的

int LinkListLen(const ListNode &link_list){
    Node* p = link_list->next;
    if(NULL == p) return 0;
    int len = 1;
    while(NULL != p->next){
        p = p->next;
        len++;
    }
    return len;
}

接下来是头节点有数据的

int LinkListLen(const ListNode &link_list){
    Node* p = link_list;
    if(NULL == p) return 0;
    int len = 1;
    while(NULL != p->next){
        p = p->next;
        len++;
    }
    return len;
}

只需要修改最开始的初始指针就可以了。

4.查找元素

查找元素的话，链表不具有随机访问的特性，每次都不要从头节点进行遍历，所以时间复杂度为O(n)

Node* FindNode(const ListNode &link_list, int val){
    Node *p = link_list->next;
    if(NULL == p) return NULL;
    while(NULL != p->next){
        if(p->data == val) return p;
        p = p->next;
    }
    return NULL;
}

同样的，另一种实现方式如下

Node* FindNode(const ListNode &link_list, int val){
    Node *p = link_list;  //只需要修改此处即可
    if(NULL == p) return NULL;
    while(NULL != p->next){
        if(p->data == val) return p;
        p = p->next;
    }
    return NULL;
}

5.插入元素

  • 头部插入元素：在链表的第1个节点之前插入新节点O(1)
  • 尾部插入元素：在链表最后1个节点之后插入新节点O(n)
  • 链表中间插入元素：在第i个节点之前插入新节点O(n)

头节点不存储数据，那么头部插入和链表中间插入元素的方法是一样的，如下所示

void InsertRear(ListNode &link_list, int val){
    Node *p = link_list;
    while(NULL != p->next){
        p = p->next;
    }
    p->next = new Node(val);
}

void InsertInside(ListNode &link_list,int index, int val){
    int count = 0;
    Node *p = link_list;
    while(NULL != p){
        if(count == index){
            Node *temp = new Node(val);
            temp->next = p->next;
            p->next = temp;
            return;
        }
        p = p->next;
        count++;
    }
    cout<<"插入失败"<<endl;
}

下面我们再看头部存储数据

void InsertFront(ListNode &link_list, int val){
    Node *p = new Node(val);
    p->next = link_list;
    link_list = p;
}

void InsertRear(ListNode &link_list, int val){
    Node *p = link_list;
    while(NULL != p->next){
        p = p->next;
    }
    p->next = new Node(val);
}

void InsertInside(ListNode &link_list,int index, int val){
    if(index == 0){
        InsertFront(link_list, val);
        return;
    }
    int count = 0;
    Node *p = link_list;
    while(NULL != p){
        if(count == index-1){
            Node *temp = new Node(val);
            temp->next = p->next;
            p->next = temp;
            return;
        }
        p = p->next;
        count++;
    }
    cout<<"index超出索引"<<endl;
}

头部存储数据的话，则需要考虑三种情况，并且头部插入数据时，需要注意，这里是将新创建节点的指针赋值给原来的链表头节点。

如果是指针解引用的数值，你在函数中修改它，原来指针指向的数据就会改变，但是如果你修改指针的地址，那么这个指针变量属于“形参”，所以这里要么采用**的双重指针，或者加上&，使用引用（这里ListNode已经包含了一重指针）。

对于插入中间元素，如果采用头节点不存储数据，那么InsertInside就可以涵盖所有情况

而采用头节点存储数据，InsertInside还需要额外考虑头部的插入。

6.修改元素

将第i个元素的值修改为val，因为需要遍历，所以操作平均时间复杂度是 O(n)，所以该算法的时间复杂度是 O(n)。

void ChangeNode(ListNode &link_list,int index, int val){
    int count = 0;
    Node *p = link_list->next;
    if(NULL == p){
        cout << "链表为空" << endl;
        return;
    }
    while(NULL != p->next){
        if(count == index){
            p->data = val;
            return;
        }
        p = p->next;
        count++;
    }
    cout<<"修改失败"<<endl;
}

而对于头节点存储数据的话，也差不多

void ChangeNode(ListNode &link_list,int index, int val){
    int count = 0;
    Node *p = link_list;  //修改此处即可
    if(NULL == p){
        cout << "链表为空" << endl; 
        return;
    }
    while(NULL != p->next){
        if(count == index){
            p->data = val;
            return;
        }
        p = p->next;
        count++;
    }
    cout<<"index超出索引"<<endl;
}

7.删除元素

  • 链表头部删除元素：删除链表的第 1 个链节点。O(1)
  • 链表尾部删除元素：删除链表末尾最后 1 个链节点。O(n)
  • 链表中间删除元素：删除链表第 i 个链节点。O(n)

同样的，头节点不存储数据的话，插入元素不需要考虑头部插入和尾部插入

void RemoveRear(ListNode &link_list){
    Node *p = link_list->next;
    if(NULL == p){
        cout << "链表为空" << endl;
        return;
    }else if(NULL == p->next){
        delete p;
        link_list->next = NULL;
    }
    while(NULL != p->next->next){
        p = p->next;
    }
    delete p->next;
    p->next = NULL;
}

void RemoveInside(ListNode &link_list, int index){

    Node *p = link_list;
    int count = 0;
    while(NULL != p->next){
        if(count == index){
            Node* temp = p->next->next;
            delete p->next;
            p->next = temp;
            return;
        }
        p = p->next;
        count++;
    }
    cout << "index 超出索引" << endl;
}

如果头节点存储数据，那么还是需要讨论删除头节点的情况

void RemoveFront(ListNode &link_list){
    Node *p = link_list;
    if(NULL == p){
        cout << "链表为空" << endl;
        return;
    }
    Node* temp = p->next;
    delete link_list;
    link_list = temp;
}

void RemoveRear(ListNode &link_list){
    Node *p = link_list;
    if(NULL == p){
        cout << "链表为空" << endl;
        return;
    }else if(NULL == p->next){
        delete link_list;
        link_list = NULL;
    }
    while(NULL != p->next->next){
        p = p->next;
    }
    delete p->next;
    p->next = NULL;
}

void RemoveInside(ListNode &link_list, int index){
    if(index == 0){
        RemoveFront(link_list);
        return;
    }
    Node *p = link_list;
    int count = 0;
    if(NULL == p){
        cout << "链表为空" << endl;
        return;
    }
    while(NULL != p->next){
        if(count == index-1){
            Node* temp = p->next->next;
            delete p->next;
            p->next = temp;
            return;
        }
        p = p->next;
        count++;
    }
    cout << "index 超出索引" << endl;
}
单链表总结

链表最大的优点在于可以灵活添加和删除元素，进行头部插入、头部删除元素操作的时间复杂度是 O(1)，相比于数组而言

  • 数组的随机访问，即按索引访问能力强。
  • 数组的尾部插入和删除更快。

但是数组的插入和删除都伴随这多次的位移操作，而链表则只需要找准节点之后，操作一次即可。


老规矩，如果有用，希望大家的二连，感谢感谢！

addict_jun
关注
专栏目录
C++单链表
wfanyue的博客
05-31 226
#include <iostream> using namespace std; class LinkNode { friend class List; private: //int *link; 错误，需要指向新节点，即LinkNode； LinkNode *link; //须改为指向LinkNode的指针； int data; public...
单链表-C++数据结构之单链表实现.zip
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
数据结构-单链表(c++)超全超详细
Abieai的博客
11-26 7828
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、单链表是什么？二、单链表上基本操作的实现1.定义单链表2.单链表初始化3.头插法4.尾插法5.任意位置插入6.按位取值7.按值取位8.删除结点9.打印链表10.销毁链表三、完整代码(功能过多，建议注释一部分使用)总结 前言 顺序表可以随时存取表中的任意一个元素，它的存储位置可以用一个简单直观的公式表示，但插入和删除操作需要移动大量元素。链式存储线性表时，不需要使用地址的连续存储单元，即不要求逻辑上相邻元素在物理地址上也相邻
单链表 C++
weixin_34220623的博客
10-28 237
单链表 C++ 题目 1、创建单链表2、初始化单链表3、释放单链表4、获取单链表中元素的数量5、输出单链表中的所有数据6、获取单链表中指定位置的元素7、根据键值查找指定元素8、采用头插法向单链表中插入一个元素9、采用尾插法向单链表中插入一个元素10、向单链表中的指定位置插入一个元素11、删除指定位置的元素 设计类图 文件结构 效果 ...
C/C++数据结构之单链表
最新发布
2301_80102396的博客
07-29 1312
显然这里要使得实参的头节点在链接一个节点，就是使得实参改变，它本身就是一个指针，所以形参我们就需要二级指针来接受实参，进行传址来改变实参。思路：头删比较简单，我们只需要把头节点的下一个节点用一个变量储存起来，然后我们把头节点释放，然后把头节点指向我们刚才变量存起来的那个地址即可；我们next是结构体类型指针，因为我们的next指向的是下一个节点，下一个节点也是结构体，所以我们需要使用结构体类型指针。在进行基本操作前提都是需要节点的，所以我们能将开辟节点的操作写为一个函数，这样在每次使用前调用即可。
C++ 单链表
vivian_ll的博客
10-22 1735
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)，简单来说链表并不像数组那样将数组存储在一个连续的内存地址空间里，它们可以不是连续的因为他们每个节点保存着下一个节点的引用（地址），所以较之数组来说这是一个优势。 ...
c++ 单链表
m0_62292821的博客
12-18 1987
单链表及其结点 链表是一种数据结构。它是通过动态分配内存、结构体与指针的配合来实现的。 链表是一系列的存储数据元素的单元通过指针串接起来形成的，因此每个单元至少有两个域，数据域用于数据元素的存储，指针域是指向其他单元的指针。具有一个数据域和多个指针域的存储单元通常称为结点。 此外，链表要有一个指向链表的起始结点的头指针变量head。 在结点中数据域用来存储数据元素，指针域用于指向下一个具有相同结构的结点。因为只有一个指针结点，称为单链表，如图所示： 单链表“结点”结构的一般声明形式： /.
单链表（C++）
qq_62761353的博客
09-26 663
C++实现单链表
C++数据结构之单链表实现
09-18
单链表是一种线性数据结构，其中每个元素（称为节点）包含两部分：数据域和指针域。数据域存储实际的数据，而指针域指向下一个节点。链表的最后一个节点的指针域通常为NULL，表示链表的结束。 接下来，我们将通过...
使用C++实现链表数据结构之单链表.zip
03-13
总的来说，理解和实现链表数据结构是学习数据结构和算法的基础，而C++提供了强大的工具来实现这些抽象概念。单链表是链表的一个简单但实用的形式，它能帮助你理解更复杂链表结构，如双向链表和循环链表。通过实践...
数据结构单链表的基本操作及实现(C/C++)
06-03
数据结构单链表的基本操作及实现(C/C++)，包括初始化、创建链表、插入元素、删除元素、获取指定位置的元素等
数据结构单链表
01-08
数据结构的一些讲解，供学习者参考，也顺带作为复习需要源代码的欢迎下载，免积分，共同学习，家下来每天都会分享一篇，持续一个星期
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（1）掌握线性表的顺序存储结构； （2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； ...
C++数据结构单链表实验：学生信息管理系统，源代码+实验报告.zip
11-14
对学生信息的单链表已经实现以下操作： //初始化 Status InitList(LinkList& L);...包含实验目的，实验分析，实验源程序，实验结果，适合数据结构中单链表的作业提交和学习，注释较多，适合基础人群学习。
单链表(C++)
落的博客
10-14 564
数据结构—单链表(C++) #include using namespace std; /*单链表 */ struct Node { //结点定义 int data; //数据域 Node *next; //指针域 }; Node *head; //定义单链表的头结点为全局变量 void Create(int n){ //创建含n个结点的单链表 Node *NewNode,rear; //NewNode为新结点,rear为尾结点 for(int i=1;i&
C++ 数据结构 单链表
qq_47168663的博客
09-22 393
C++，数据结构，单链表，线性表
c++数据结构单链表
qq_45569601的博客
02-24 391
c++数据结构单链表 一:提要: 链表是线性表的链式存储方式,链表的构成: 数据域和指针域,指针指向下一个节点的内存地址,是链式线性结构;方便增加元素和删除元素. 二,链表的定义: //链表定义 typedef struct LINKLIST{ int data; //数据域 struct LINKLIST *next;//指针域//指向下一个节点 }linkList,linkNode;//...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值