C++链表概念及基本操作

最新推荐文章于 2024-08-04 22:43:03 发布
最新推荐文章于 2024-08-04 22:43:03 发布
阅读量1k 收藏 15
点赞数 23
分类专栏： C++基础知识 文章标签： c++ 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maker_D/article/details/134344821
版权

文章目录

一、链表基础知识

1.1单链表构成

链表是一种可以动态存储分配的数据结构，它由多个元素组成，在单链表中每个元素称为“节点”，每个节点的定义如下：

typedef int DataType;
#define Node ElemType
#define ERROR NULL

//创建一个基本节点类
struct Node
{
	int Data;  //数据域
	Node* next;   //指针域
}

从代码中不难发现，每个节点由两部分构成
①数据域Data：整形变量（可定义为任意需要类型），存储本节点的数据元素。
②指针域*next：指向下一个节点。
多个节点通过Node->next表示的指针连接在一起，并且通常情况第0个节点作为标志节点，通常成为表头（head），一般情况下可作为特定链表的标识，这在一定程度上起到防止链表丢失的作用。

1.2性质对比

①动态内存分配：运行时可动态分配内存，不像数组在创建时确定大小。
②不连续存储：链表中的节点在内存中可以是不连续的，而数组元素在内存必须连续存储。
③插入和删除的高效性：尤其在节点间插入元素，只需调整指针指向，而不用移动大量元素。
④随机访问较慢：不能通过下表访问，只能从头遍历，效率低，时间复杂度为O(n)，n为链表长度。
⑤常见的链表：单链表、双链表、循环链表。（单链表：每个节点只含一个指向下个节点的指针。双链表：有上、下两个方向指向的指针。循环链表：尾部节点指向头结点，形成环状，可以是单或双链表）

二、链表的基本操作

2.1构建一个单链表类

 //构建一个单链表类 
class LinkList                      
{
public:
    LinkList();                      //构建一个单链表;
    ~LinkList();                  //销毁一个单链表;
    void CreateLinkList(int n);   //创建一个单链表
    void TravalLinkList();        //遍历线性表
    int GetLength();              //获取线性表长度
    bool IsEmpty();               //判断单链表是否为空
    ElemType * Find(DataType data); //查找节点
    void InsertElemAtEnd(DataType data);            //在尾部插入指定的元素
    void InsertElemAtIndex(DataType data,int n);    //在指定位置插入指定元素
    void InsertElemAtHead(DataType data);           //在头部插入指定元素
    void DeleteElemAtEnd();       //在尾部删除元素
    void DeleteAll();             //删除所有数据
    void DeleteElemAtPoint(DataType data);     //删除指定的数据
    void DeleteElemAtHead();      //在头部删除节点
private:
    ElemType * head;  //头结点，他作为私有成员变量，在各个成员函数中可被执行链表的各种操作
};

2.2类中针对单链表的相关操作函数

在对链表进行相关操作之前，首先给出初始化单链表和销毁单链表的代码。

//初始化单链表
LinkList::LinkList()
{
	head = new ElemType;
	head->data = 0;  //将头节点的数据定义为0
	head->next = NULL;    //头结点的下一个定义为NULL
}
//销毁单链表
LinkList::~LinkList()
{
	Node *temp;
	while(head->next != NULL)  //删除每个节点
	{
		temp=head;
		head=head->next;
		delete temp;
	}
	delete head; //删除头节点
}

注意：在析构函数中使用delete来删除对象，它对应的是通过new来动态分配的内存，都是C++中的操作符。
值得一提的是free函数，他用来释放通过malloc、calloc、realloc等函数动态分配的内存，与上述的new不能混合使用。

1.创建单链表

//创建一个单链表
void LinkList::CreateLinkList(int n)
{
    ElemType *pnew, *ptemp;
    ptemp = head;
    if (n < 0) {       //当输入的值有误时，处理异常
        cout << "输入的节点个数有误" << endl;
        exit(EXIT_FAILURE);
    }
    for (int i = 0; i < n;i++) {        //将值一个一个插入单链表中
        pnew = new ElemType;
        cout << "请输入第" << i + 1 << "个值: " ;
        cin >> pnew->data;
        pnew->next = NULL;          //新节点的下一个地址为NULL
        ptemp->next = pnew;         //当前结点的下一个地址设为新节点
        ptemp = ptemp->next;        //将当前节点向后移动一位，以达到逐个创建的需求
    }
}

2.遍历节点

//遍历单链表
void LinkList::TravalLinkList()
{
    if (head->next ==NULL) {
        cout << "链表为空表" << endl;
    }
    ElemType *p = head;                 //令指针指向头节点
    while (p->next != NULL)        //当指针的下一个地址不为空时，循环输出p的数据域
    {
        p = p->next;               //p指向p的下一个地址
        cout << p->data << " ";
    }
}

3.获取长度

//获取单链表的长度
int LinkList::GetLength()
{
    int count = 0;                  //定义count计数
    ElemType *p = head->next;           //定义p指向头后的第一个节点
    while (p != NULL)                //当指针的下一个地址不为空时，count+1
    {
        count++;                  
        p = p->next;                //p指向p的下一个地址
    }
    return count;                   //返回count的数据
}

4.判断单链表是否为空

//判断单链表是否为空
bool LinkList::IsEmpty()
{
    if (head->next == NULL) {                 
        return true;
    }
    return false;
}

5.获取节点

//查找节点
ElemType * LinkList::Find(DataType data)
{
    ElemType * p = head->next;
    if (p == NULL) {                           //当为空表时，报异常
        cout << "此链表为空链表" << endl;
        return ERROR;
    }
    else
    {
        while (p != NULL)               //循环每一个节点
        {
            if (p->data == data) return p;        //返回指针域
            p = p->next;
        }
        return NULL;                           //未查询到结果
    }
}

6.在尾部插入指定元素

//在尾部插入指定的元素
void LinkList::InsertElemAtEnd(DataType data)
{
    ElemType * newNode = new ElemType;    //定义一个Node节点指针newNode
    newNode->next = NULL;         //定义newNode的数据域和指针域
    newNode->data = data;
    ElemType * p = head->next;              //定义指针p指向头节点后的第一个节点
    if (head == NULL)head = newNode;         //当头结点为空时，设置newNode为头结点
    while (p->next != NULL)p = p->next;
    p->next = newNode;
}

7.在指定位置插入指定元素

//在指定位置插入指定元素
void LinkList::InsertElemAtIndex(DataType data,int n)
{
    if (n<1 || n>GetLength())                   //输入有误报异常
        cout << "输入的值错误" << endl;
    else
    {
        ElemType * ptemp = new ElemType;        //创建一个新的节点
        ptemp->data = data;                     //定义数据域
        ElemType * p = head->next;                    //创建一个指针指向头节点
        int i = 1;
        while (n > i)                           //遍历到指定的位置
        {
            p = p->next;
            i++;
        }
        ptemp->next = p->next;                 //将新节点插入到指定位置
        p->next = ptemp;
    }
}

8.在头部插入指定元素

//在头部插入指定元素
void LinkList::InsertElemAtHead(DataType data)
{
    ElemType * newNode = new ElemType;    //定义一个Node节点指针newNode
    newNode->data = data;
    ElemType * p = head->next;              //定义指针p指向头节点后的第一个元素
    newNode->next = p;          //将新节点插入到指定位置
    head->next = newNode;
}

9.在尾部删除元素

//在尾部删除元素
void LinkList::DeleteElemAtEnd()
{
    ElemType * p = head->next;          //创建一个指针指向头节点后的第一个节点
    ElemType * ptemp = NULL;      //创建一个占位节点
    if (p == NULL) {        //判断链表是否为空
        cout << "单链表空" << endl;
    }
    else
    {
        while (p != NULL)   //循环到尾部的前一个
        {
            ptemp = p;            //将ptemp指向尾部的前一个节点
            p = p->next;          //p指向最后一个节点
        }
        delete p;                //删除尾部节点
        p = NULL;
        ptemp->next = NULL;
    }
}

10.删除所有元素

//删除所有数据
void LinkList::DeleteAll()
{
    ElemType * p = head->next;
    ElemType * ptemp = new ElemType;
    while (p != NULL)                    //在头结点的下一个节点逐个删除节点
    {
        ptemp = p;
        p = p->next;
        head->next = p;
        ptemp->next = NULL;
        delete ptemp;
    }
    head->next = NULL;                 //头结点的下一个节点指向NULL
}

11.删除指定元素

//删除指定的数据
void LinkList::DeleteElemAtPoint(DataType data)
{
    ElemType * ptemp = Find(data);    //查找到指定数据的节点位置
    if (ptemp == head->next) {        //判断是不是头节点的下一个节点，如果是就从头部删了它
        DeleteElemAtHead();
    }
    else
    {
        ElemType * p = head->next;          //p指向头节点后的第一个节点
        while (p != ptemp)p = p->next;      //p循环到指定位置的前一个节点
        p->next = ptemp->next;         //删除指定位置的节点
        delete ptemp;
        ptemp = NULL;               
    }
}

12.在头部删除元素

//在头部删除节点
void LinkList::DeleteElemAtHead()
{
    ElemType * p = head->next;
    if (p == NULL) {   //判断是否为空表，报异常
        cout << "该链表为空表" << endl;
    }
    else
    {
        ElemType * ptemp = NULL;      //创建一个占位节点
        p = p->next;
        ptemp = p->next;              //将头结点的下下个节点指向占位节点
        delete p;                     //删除头结点的下一个节点
        p = NULL;
        head->next = ptemp;           //头结点的指针更换
    }
}

小结

以上内容分析了链表的组成，相较于数组链表具有的优缺点，同时给出了链表常用的几种函数。欢迎各位小伙伴共同交流~

参考文章

本文参考下文扩展而来：https://blog.csdn.net/ccblogger/article/details/81176338

maker_D
关注
  • 23
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++完成双向链表的创建及其它基本操作
qq_63035929的博客
03-27 4654
​ /*双链表结构体为： typedef struct { int num; /学号 char name[10]; /姓名 } student； 分别建立包含3~5个数据元素的链式存储线性表； (3）实现功能 a) 构造空表，直接从键盘输入数据元素 b) 插入、删除、一般查找（给定某一学号x，找到并显示该学生信息）、显示，等函数功能 */ #include<iostr.
数据结构经典面试之链表——C#和C++篇
qq_35320456的博客
06-21 802
链表是一种常见的基础数据结构，它由一系列节点组成，每个节点包含数据域和指向下一个节点的指针。链表与数组不同，它不要求节点在内存中连续存储，这使得链表在插入和删除操作时具有较高的效率
链表的概念以及相关基础操作
qq_61597023的博客
03-10 973
链表的定义，初始化，创建，打印，插入，删除，合并，反转操作实现
链表c++语言 解析,C++ 单链表的基本操作(详解)
weixin_33420201的博客
05-22 1355
链表一直是面试的高频题，今天先总结一下单链表的使用，下节再总结双向链表的。本文主要有单链表的创建、插入、删除节点等。1、概念单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素 + 指针，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。如下图：2、链表的基本操作SingleList.cpp:#include ...
手写链表C++
整理ing
11-11 1290
c++ 手写链表
C++链表
编程为业，务实前行，持续学习，技术宅一枚。
07-24 371
C++链表是一种灵活且高效的数据结构，特别适用于需要频繁插入和删除操作但较少进行随机访问的场景。通过掌握链表的基本概念、类型、特点和基本操作，可以更好地理解和应用链表来解决实际问题。
C++链表操作入门
博樽
04-23 523
链表是一种强大且灵活的数据结构体，学习链表的插入删除查找等方法
C++ list容器-52-链表基本概念和构造函数/赋值
Anthony_tester的博客
08-04 1082
前面学习的容器或叫数据结构都是连续存储的空间。例如数组和vector都是在一块连续的内存空间去存储数据。既然有连续存储当然也就有非连续存储。这里开始学习非连续存储的数据结构，list，也叫链表 1.list的基本概念 list是一种将数据进行链式存储的数据结构，也叫链表。list是一种物理存储单元上非连续的存储结构，将数据元素的逻辑顺序是通过链表中的指针链接实现的。 链表的组成：链表由一系列结点组成。 结点的组成：一个存储数据元素的数据域，另一个是存储下一个结点地址的指针域 链表有单链表和双.
实验3、链表的基本操作
于笨笨的博客
08-27 1431
实验3、链表的基本操作 （1）实验目的 通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。和实验3对比，掌握线性结构两种不同存储方式的区别。 （2）实验内容 编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。 （3）参考界面 （4）验收/测试用例  没有初始化前进行其他操作，程序是否能控制住；  初始化一个顺序表；  插入数据(位置， 数据)，要测插入位置不合法的情况（0,1）、（2,1），
C++ STL 库 list 链表的基本定义及操作
weixin_45897672的博客
01-11 4646
文章目录一，list二，forward_list 一，list 二，forward_list
C++ 双链表的基本操作(详解)
08-31
1. 双链表概念 双链表（Double Linked List）每个节点包含两个指针，一个指向前一个节点（prior），另一个指向后一个节点（next）。这样的设计使得我们可以从任一节点出发，方便地访问其前驱和后继节点。通常，我们...
c++链表的基本操作
09-25
链表是一种重要的数据结构，它在计算机科学中...理解和掌握链表的基本操作对于学习和使用C++至关重要，尤其对于处理动态数据和高效算法设计。通过不断练习和实践，你可以更深入地理解指针和链表，提升你的编程技能。
C++ 单链表的基本操作(详解)
12-31
链表一直是面试的高频题，今天先总结一下单链表的使用，下节再总结双向链表的。...2、链表的基本操作 SingleList.cpp: #include stdafx.h #include SingleList.h #include #include #include <string.h
C++实现链表版本通讯录
08-25
链表基本概念 链表是一种数据结构，它由一系列节点组成，每个节点包含一个值和一个指向下一个节点的指针。链表可以用于实现动态数组、栈、队列等数据结构。 C++实现链表 在C++中，可以使用类（Class）来实现链表...
C++ STL copy_backward, move_backward 用法
08-04 164
此处需要解释一下：从后向前并不是逆序，它的意思是: 源容器和目标容器都从尾部开始，然后向前迭代，执行拷贝/移动操作。反向（从后向前的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
【C语言】Top K问题【建小堆】
2301_80840905的博客
08-04 309
在我们生活中，经常会遇到TopK问题。建小堆解决
C++ STL copy, move 用法
08-04 139
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
OD C卷 - 中庸行者
最新发布
weixin_45228198的博客
08-04 101
DFS
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值