链表（c++）

最新推荐文章于 2025-05-26 19:21:32 发布
最新推荐文章于 2025-05-26 19:21:32 发布
阅读量390 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构 链表 单链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/HUGOPIGS/article/details/103984281

数据结构--链表（c/c++）

一、线性表

线性表（linear list）属于数据结构中的线性结构，它是n个数据元素的有限序列，这里的元素含义各异，可以是一个数字、一个字符，也可以是更为复杂的信息。

（1）线性结构

线性结构的特点是：

  1. 只有一个头元素；
  2. 只有一个尾元素；
  3. 除头元素外，集合中每个数据元素只有一个前驱；
  4. 除尾元素外，集合中每个数据元素只有一个后继；

用通俗易懂的话来说就是你懂的！线性表也是这个特点。

（2）线性表的储存结构

线性表的储存结构包括顺序储存结构和链式储存结构。
顺序存储结构的特点是逻辑关系上相邻的元素在物理位置上也要相邻，因此它可以随机存取表中的任一元素。但是，这样的特性造成在进行插入或删除操作时，需要移动大量的元素。
链式储存结构的特点是用一组任意的储存单元储存数据元素，可以连续也可以不连续。使用链式储存结构的线性表就是我们常说的链表。

（3）链式储存结构—链表

为了表述链表中每个元素ai与其后继元素ai+1之间的逻辑关系，对ai来说，它需要储存本身的信息（数据域）以及指示后继位置的信息指针（指针域），这两部分加在一起成为结点。

1. 线性链表

上述链式储存结构的每个结点中只包含一个指针域，即指向后继元素的指针，故称之为线性链表或单链表。在单链表中也分为头结点为空（有空头链表）和头结点不为空（无空头链表）两种。这一章我们的代码主要围绕无空头链表！

1.1 结构体以及全局变量
#include <iostream>
#include <cstdlib> //malloc

using namespace std;
struct Node
{
    int a; //数据域
    struct Node *pNext; //指针域
};
//创建头尾节点
Node *pHead = NULL;
Node *pEnd = NULL;

为了便于增删改查的书写方便，我们将头尾结点设为全局变量。

1.2添加结点

添加结点有三种情况，分别是头添加、尾添加以及在链表任一位置添加。

//在链表的末端添加一个结点（尾添加）
void AddNodeToListTail(int a)
{
    //创建新结点
    Node *pTemp = (struct Node*)malloc(sizeof(Node));

    //结点数据进行赋值
    pTemp->a = a;
    pTemp->pNext = NULL; //important 如果没有做这一步，极有可能使该指针未初始化（0xcdcdcdcd）

    //链接
    if (NULL == pHead || NULL == pEnd)
    {
        //如果该链表为空，则新节点既是头结点也是尾结点
        pHead = pTemp;
        //pEnd  = pTemp;
    }
    else
    {
        //如多链表不空，则新结点指向尾节点的Next，再将尾结点移至最末
        pEnd->pNext = pTemp;
        //pEnd = pTemp; pEnd = pEnd->Next;
    }
    pEnd = pTemp;
}
//在链表的顶端添加一个结点（头添加）
void AddNodeToListHead(int a)
{
    //创建新结点
    Node * pTemp = (struct Node*)malloc(sizeof(Node));
    //结点数据赋值
    pTemp->a = a;
    pTemp->pNext = NULL;

    //链接
    if(NULL == pHead)
    {
        //如果该链表为空，则新结点既是头结点也是尾结点
        pHead = pTemp;
        pEnd = pTemp;
    }
    else
    {
        //如果链表不空，则新结点的Next指向头结点，再将新结点设为头结点
        pTemp->pNext = pHead;
        pHead = pTemp;
    }
}
/指定位置添加结点
void InsertNode(int index, int a)
{
    //链表为空
    if (NULL == pHead)
    {
        cout << "链表为空！" << endl;
        return;
    }
    //找位置
    Node *pt = SelectNode(index);
    if (NULL == pt)
    {
        cout << "木得指定结点" << endl;
        return;
    }
    //为a创建结点
    Node *pTemp = (struct Node *)malloc(sizeof(Node));
    //结点成员进行赋值
    pTemp->a = a;
    pTemp->pNext = NULL;

    //链接
    if (pt == pEnd)
    {
        //尾结点的Next指向新节点
        pEnd->pNext = pTemp;
        //新结点变成尾巴
        pEnd = pTemp;
    }
    else
    {
        //先连
        pTemp->pNext = pt->pNext;
        //后断
        pt->pNext = pTemp;
    }
}
1.3遍历链表

遍历链表的操作分为遍历整个链表，我们通常使用此方法打印链表元素；以及查找某一结点，此功能多用于任一位置结点的添加与删除。

//遍历整个链表
void ScanTheList()
{
    //定义中间指针记录头指针，不能使用pHead遍历，否则将会丢失头指针
    Node * pTemp = pHead;
    //bool变量的判断写成!temp,指针应该使用下列写法
    while (pTemp != NULL)
    {
        cout << pTemp->a << endl;
        pTemp = pTemp->pNext;
    }
}

//查询指定结点
struct Node* SelectNode(int a)
{
    Node * pTemp = pHead;
    while ( pTemp != NULL)
    {
        if (a == pTemp->a)
        {
            return pTemp;
        }
        pTemp = pTemp->pNext;
    }
    //未找到
    return NULL;
}

因为在单链表中，任何两个元素的储存位置没有固定的联系，所以想找到第i个元素就必须从头结点出发寻找，若有n个结点，最坏情况要遍历并比较n次，所以它的时间复杂度为O(n)。

1.4删除链表中的结点
//（头删除）
void DeleteListHead()
{
    //链表检测
    if (NULL == pHead)
    {
        cout << "链表为空！" << endl;
    }
    //不可以直接free(pHead)
    Node *pt = pHead;
    pHead = pHead->pNext;
    free(pt);
}

//（尾删除）
void DeleteListTail()
{
    //链表检测
    if (NULL == pHead)
    {
        cout << "链表为空！" << endl;
        return;
    }

    //判断结点数
    if(pHead == pEnd)
    {
        free(pHead);
        pHead = NULL;
        pEnd = NULL;
    }
    else //多结点
    {
        //
        Node *pTemp = pHead;
        while (pTemp->pNext != pEnd)
        {
            pTemp = pTemp->pNext;
        }
        //删除尾结点
        free(pEnd);
        pEnd = pTemp;
        pEnd->pNext = NULL;
    }

}

//删除指定结点
void DelectRandNode(int a)
{
    //链表检测
    if (NULL == pHead)
    {
        cout << "链表为空！" << endl;
        return;
    }
    Node *pTemp = SelectNode(a);
    if (NULL == pTemp)
    {
        cout << "查无此结点！" << endl;
        return;
    }
    //对结点数量讨论
    if (pEnd == pHead) //一个
    {
        //DeleteListHead();
        free(pHead);
        pHead = NULL;
        pEnd = NULL;
    }
    else if (pHead->pNext == pEnd) //两个
    {
        if (pTemp == pHead)
        {
            DeleteListHead();
        }
        else if (pTemp == pEnd)
        {
            DeleteListTail();
        }
    }
    else //多个
    {
        if (pTemp == pHead)
        {
            DeleteListHead();
        }
        else if (pTemp == pEnd)
        {
            DeleteListTail();
        }
        else
        {
            Node *pt = pHead;
            while ( pt->pNext != pTemp )
            {
                pt = pt->pNext;
            }
            pt->pNext = pTemp->pNext;
            free(pTemp);
        }
    }
}

删除结点和遍历结点类似，时间复杂度为O(n)。

1.5释放整个链表空间

为了防止内存泄漏，我们需要在使用结束后将链表清空。

//链表清空,防止内存泄漏
void FreeList()
{
    Node * pTemp = pHead;
    while ( pTemp != NULL)
    {
        Node * pt = pTemp; //禁止在此处使用free(pTemp)
        pTemp = pTemp->pNext;
        free(pt);
    }
    //清空头尾结点
    pHead = NULL;
    pEnd = NULL;
}
1.6注意事项

全部都写在了注释里哦！！！

完整代码

//无空头链表的操作
#include <iostream>
#include <cstdlib> //malloc

using namespace std;
struct Node
{
    int a;
    struct Node *pNext;
};
//创建头尾节点
Node *pHead = NULL;
Node *pEnd = NULL;

//链表清空
void FreeList();
//在链表的末端添加一个节点（尾添加）
void AddNodeToListTail(int a);
//在链表的顶端添加一个节点（头添加）
void AddNodeToListHead(int a);
//指定位置添加节点
void InsertNode(int index, int a);
//遍历链表 查全部、查指定
void ScanTheList();
//查询指定节点
struct Node* SelectNode(int a);
//（头删除）
void DeleteListHead();
//（尾删除）
void DeleteListTail();
//（删除指定节点）
void DelectRandNode(int a);
//栈 头添加+头删除
//队列 头添加+尾删除/头删除+尾添加
int main()
{
    int a[10] = {1,2,3,4,5};
    //pHead;
    int i = 0;
    for( ; i < 10; i++ )
    {
        AddNodeToListTail(a[i]);
    }
    //ScanTheList();
    Node *pFind = SelectNode(15);
    if( pFind != NULL )
    {
        cout << pFind->a << endl;
    }
    else
    {
        cout << "没找到" <<endl;
    }
    cout << "Hello world!" << endl;
    system("pause");
    return 0;
}

//链表清空,防止内存泄露
void FreeList()
{
    Node * pTemp = pHead;
    while ( pTemp != NULL)
    {
        Node * pt = pTemp; //禁止在此处使用free(pTemp)
        pTemp = pTemp->pNext;
        free(pt);
    }
    //清空头尾节点
    pHead = NULL;
    pEnd = NULL;
}

//在链表的末端添加一个节点（尾添加）
void AddNodeToListTail(int a)
{
    //创建一个节点
    Node *pTemp = (struct Node*)malloc(sizeof(Node));

    //节点数据进行赋值
    pTemp->a = a;
    pTemp->pNext = NULL; //important 如果没有做这一步，极有可能使该指针未初始化（0xcdcdcdcd）

    //链接
    if (NULL == pHead || NULL == pEnd)
    {
        //如果该链表为空，则新节点既是头节点也是尾节点
        pHead = pTemp;
        //pEnd  = pTemp;
    }
    else
    {
        //如多链表不空，则新节点指向尾节点的Next，再将尾节点移至最末
        pEnd->pNext = pTemp;
        //pEnd = pTemp; pEnd = pEnd->Next;
    }
    pEnd = pTemp;

}

//在链表的顶端添加一个节点（头添加）
void AddNodeToListHead(int a)
{
    //创建新节点
    Node * pTemp = (struct Node*)malloc(sizeof(Node));
    //节点数据赋值
    pTemp->a = a;
    pTemp->pNext = NULL;

    //链接
    if(NULL == pHead)
    {
        //如果该链表为空，则新节点既是头节点也是尾节点
        pHead = pTemp;
        pEnd = pTemp;
    }
    else
    {
        //如果链表不空，则新节点的Next指向头结点，再将新节点设为头结点
        pTemp->pNext = pHead;
        pHead = pTemp;
    }

}
//指定位置添加节点
void InsertNode(int index, int a)
{
    //链表为空
    if (NULL == pHead)
    {
        cout << "链表为空！" << endl;
        return;
    }
    //找位置
    Node *pt = SelectNode(index);
    if (NULL == pt)
    {
        cout << "木得指定节点" << endl;
        return;
    }
    //为a创建节点
    Node *pTemp = (struct Node *)malloc(sizeof(Node));
    //节点成员进行赋值
    pTemp->a = a;
    pTemp->pNext = NULL;

    //链接
    if (pt == pEnd)
    {
        //尾节点的Next指向新节点
        pEnd->pNext = pTemp;
        //新节点变成尾巴
        pEnd = pTemp;
    }
    else
    {
        //先连
        pTemp->pNext = pt->pNext;
        //后短
        pt->pNext = pTemp;
    }
}

//遍历整个链表
void ScanTheList()
{
    //定义中间指针记录头指针，不能使用pHead遍历，否则将会丢失头指针
    Node * pTemp = pHead;
    //bool变量的判断写成!temp,指针应该使用下列写法
    while (pTemp != NULL)
    {
        cout << pTemp->a << endl;
        pTemp = pTemp->pNext;
    }
}

//查询指定结点
struct Node* SelectNode(int a)
{
    Node * pTemp = pHead;
    while ( pTemp != NULL)
    {
        if (a == pTemp->a)
        {
            return pTemp;
        }
        pTemp = pTemp->pNext;
    }
    //未找到
    return NULL;
}

//（头删除）
void DeleteListHead()
{
    //链表检测
    if (NULL == pHead)
    {
        cout << "链表为空！" << endl;
    }
    //不可以直接free(pHead)
    Node *pt = pHead;
    pHead = pHead->pNext;
    free(pt);
}

//（尾删除）
void DeleteListTail()
{
    //链表检测
    if (NULL == pHead)
    {
        cout << "链表为空！" << endl;
        return;
    }

    //判断节点数
    if(pHead == pEnd)
    {
        free(pHead);
        pHead = NULL;
        pEnd = NULL;
    }
    else //多节点
    {
        //
        Node *pTemp = pHead;
        while (pTemp->pNext != pEnd)
        {
            pTemp = pTemp->pNext;
        }
        //删除尾节点
        free(pEnd);
        pEnd = pTemp;
        pEnd->pNext = NULL;
    }

}

//删除指定节点
void DelectRandNode(int a)
{
    //链表检测
    if (NULL == pHead)
    {
        cout << "链表为空！" << endl;
        return;
    }
    Node *pTemp = SelectNode(a);
    if (NULL == pTemp)
    {
        cout << "查无此节点！" << endl;
        return;
    }
    //对节点数量讨论
    if (pEnd == pHead) //一个
    {
        //DeleteListHead();
        free(pHead);
        pHead = NULL;
        pEnd = NULL;
    }
    else if (pHead->pNext == pEnd) //两个
    {
        if (pTemp == pHead)
        {
            DeleteListHead();
        }
        else if (pTemp == pEnd)
        {
            DeleteListTail();
        }
    }
    else //多个
    {
        if (pTemp == pHead)
        {
            DeleteListHead();
        }
        else if (pTemp == pEnd)
        {
            DeleteListTail();
        }
        else
        {
            Node *pt = pHead;
            while ( pt->pNext != pTemp )
            {
                pt = pt->pNext;
            }
            pt->pNext = pTemp->pNext;
            free(pTemp);
        }
    }
}
链表（C++）
2401_87345428的博客
03-29 1499
这是本人第二次学习链表，第一次学习链表是在大一上的C语言课上，首次接触，感到有些难；第二次是在大一下学习数据结构时（就是这次），使用C++再次理解链表。同时，这也是开启数据结构学习写的第一篇文章，但愿以后有时间一直写下去。当然，学习数据结构还是保持着学习计算机的基本素养——增、删、查、改。
【数据结构】双向链表 C++
m0_73020012的博客
04-04 2460
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。val：存储每个节点的权值；last：指向每个节点的前面的第一个节点；next：指向每个节点的后面的第一个节点；T value;value=0;
链表（c++)
朱家小旺
10-10 425
一、单链表实现： #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
c语言链表详解(超详细，图文并茂)
最新发布
数据结构和算法教程（C语言版）
05-26 1239
以上内容详细介绍了对链表中数据元素做"增删查改"的实现过程及 C 语言代码，最后给大家一段完整的代码，实现对有头结点链表的“增删查改”，大家可以去我的个人网站获取。静态链表做 "增删查改" 操作的完整实现代码，大家可以去我的个人网站获取。最后给大家双链表中对数据进行 "增删查改" 操作的完整实现代码，可以去我的个人网站获取。
链表(C++)
qq_33204297的博客
02-22 1149
链表：数据区加地址区 不好意思，吃饭去了，明天继续
单链表，循环链表，双链表及其基本操作（C++实现）
My vegetable has exploded.
07-16 8480
    最近在学习严蔚敏教授的《数据结构》，有一些感想，在这里写下来，留做笔记，希望能对以后学习有所帮助。     我们知道，线性表就是n个数据元素的有限序列，它有两种实现方式，其一为顺序表，即数组+伪指针的方式实现，另一为链表，采用的是指针的方式实现。由于顺序表的知识偏向基础且其应用灵活性不高，故在此不再介绍，本文主要说明几种常用的链表是如何实现的以及其基本操作。 1.单链表：     单...
C++之链表
gghhb12的博客
04-05 3216
C++之链表
数据结构单双链表c++版
07-14
在这个"数据结构单双链表C++版"的压缩包中，我们主要关注的是两种基本的数据结构——单链表和双链表，它们在C++编程环境下被实现。这两种链表都是线性数据结构的实例，是数组的延伸，特别适用于处理动态变化大小的...
循环链表c++
06-10
使用c++语言实现的循环链表，功能齐全，包括插入、删除、寻找等功能
链表C++实现
07-05
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在C++这样的编程语言中。链表与数组不同，不依赖于连续的内存空间，而是通过节点之间的指针连接形成线性序列。在C++中，链表可以用于实现...
二叉链表的应用c++代码_二叉链表c++代码_
09-30
本文将深入探讨二叉链表的概念、特点以及如何使用C++编程语言实现其应用。 二叉链表，又称为二叉链式存储结构，是二叉树的一种存储方式。与数组或静态链表不同，二叉链表中的每个节点包含两个指针，分别指向它的左...
c++链表
123456
08-14 1099
如果插入位置大于0，遍历到插入位置的前一个节点，将新节点的next指针指向前一个节点的next节点，然后将前一个节点的next指针指向新节点。如果删除位置大于0，遍历到删除位置的前一个节点，将前一个节点的next指针指向待删除节点的下一个节点，然后删除待删除节点。链表有头节点和尾节点，头节点用于记录链表的开头，尾节点用于记录链表的结尾。在主函数中演示了链表的基本操作，首先在链表末尾添加了三个节点，然后在链表的特定位置插入了两个节点，最后从链表中删除了两个节点，并打印出了最终的链表结果。
C++链表
Foools的博客
11-17 1438
文章目录前言一、动态链表存储二、建立和遍历列表三、插入节点四、删除节点 前言 链表相对于列表，数组来说，访问不方便，长度可变，插入新元素方便。本文仅介绍单向列表。 一、动态链表存储 每个节点都需要存储后继节点的地址，让一个个元素串联起来，这样就能形成一个单向链表。 综上，单项列表的数据元素是一个结构： struct Node { char name[20]; double salary; Node * next; }; 二、建立和遍历列表 建立单向列表的过程可以描述为： 生成头结点； whil.
链表C++
qq_39114788的博客
03-14 133
一、链表的基础操作 1.创建链表 #include<stdio.h> #include <stdlib.h> struct node{ node *nextt; int data; }; node *create(int Array[]) { node *head,pre,p; head=new node; head->next=N...
【C++ 链表】
qq_45602618的博客
07-15 258
反转链表1（LeetCode 206.） class Solution { public: ListNode* reverseList(ListNode* head) { ListNode *new_head = NULL; while(head){ ListNode *next = head->next; head->next = new_head; new_head = hea.
C++的链表
weixin_64558254的博客
05-27 589
由于c++没有LinkedList，要用链表很不方便，所以我就自己写了个，思路是把链表的每个结点放到数组里。 需要可以直接复制去用。 目前只有add添加，show输出链表，reverse倒置链表 三个功能，有需要的留言，我把剩下的增删查改也写了。 #include<iostream> using namespace std; class Node { public: Node* pre; string value; Node* next; static ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值