数据结构（链表）

最新推荐文章于 2024-08-30 21:09:25 发布
最新推荐文章于 2024-08-30 21:09:25 发布
阅读量179 收藏
点赞数 1
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59342972/article/details/128855414
版权
该文详细介绍了单向链表的基本操作，包括创建空链表、在指定位置插入节点、删除指定位置节点、查找数据位置、遍历链表、转置链表以及清空链表等。同时，文中强调了错误处理和内存管理的重要性，确保链表操作的正确性和稳定性。
摘要由CSDN通过智能技术生成

数据结构（链表）

解决：长度固定的问题，插入和删除麻烦的问题

结构

逻辑结构：线性结构
存储结构：链式存储结构 在内存当中存储是连续的 数组

结构体

typedef int datatype;
typedef struct node_t
{
datatype data;//数据域
struct node_t *next;//指针域,指向自身结构体的指针
}link_node_t,*link_list_t;

创建一个空的单向链表(有头单向链表)

link_node_t *CreateEpLinkList()
{
    //思想：创建一个节点，作为头节点
    link_list_t p=(link_list_t)malloc(sizeof(link_node_t));
    if(p==NULL)
    {
        perror("CreateEpLinkList err");
        return NULL;
    }
    p->next=NULL;
    return p;
}

操作

在指定位置插入

1.容错判断（判越界）
2.创建一个新节点pnew用于存储数据
 link_list_t pnew =(link_list_t)malloc(sizeof(link_node_t));
    pnew->data=data
3.将头指针移动到插入位置的前一个节点
4.插入操作（先连后面再连前面）

求链表长度：（有头遍历）

int LengthLinkList(link_node_t *p)
{
    int len=0;
    while(p->next !=NULL)
    {
        p=p->next;
        len++;
    }
    return len;
}

容错判断：

if(post<0|| post>LengthLinkList(p))
    {
        perror("InsertIntoPostLinkList err");
        return -1;
    }

将头指针遍历到插入位置的前一个节点：

for (int i = 0; i < post; i++)
{
    p=p->next;
}

插入操作：

pnew->data=data;
pnew->next ==NULL;
pnew->next =p->next;
p->next=pnew;

分段代码：

//向单向链表的指定位置插入数据
//p 保存链表的头指针 post 插入的位置 data 插入的数据
int InsertIntoPostLinkList(link_node_t *p,int post, datatype data)
{
    link_list_t pnew = NULL;
    //1.容错判断
    if(post<0|| post>LengthLinkList(p))
    {
        perror("InsertIntoPostLinkList err");
        return -1;
    }
    //2.将头指针移动到插入位置的前一个节点
    for (int i = 0; i < post; i++)
    {
        p=p->next;
    }
    //3.创建新节点保存插入数据
    pnew =(link_list_t)malloc(sizeof(link_node_t));
    if(pnew ==NULL)
    {
        perror("pnew malloc err");
        return -1;
    }
    pnew->data=data;
    pnew->next ==NULL;
    //4.将新节点插入指定位置
    pnew->next =p->next;
    p->next=pnew;
    return 0;    
}

删除指定位置的数据

1.容错判断（判越界、判空）
2.创建一个删除指针pdel
3.定位到删除位置的前一个节点
4.删除操作

判断单向链表是否为空 1 代表空 0 代表非空

判断单向链表是否为空 1 代表空 0 代表非空
int IsEpLinkList(link_node_t *p)
{
    return p->next==NULL;
}

容错判断：

if(post<0 || post>=LengthLinkList(p) || IsEpLinkList(p))
{
    perror("DeletePostLinkList err");
    return -1;
}

将头指针遍历到删除位置的前一个节点：

for(int i=0;i<post;i++)
{
    p=p->next;
}

删除操作：

pdel=p->next;
//跨过被删除节点
p->next = pdel->next;
//释放被删除节点
free(pdel);
pdel=NULL;

分段代码

删除单向链表中指定位置的数据 post 代表的是删除的位置
int DeletePostLinkList(link_node_t *p, int post)
{
    //1.容错判断
    if(post<0 || post>=LengthLinkList(p) || IsEpLinkList(p))
    {
        perror("DeletePostLinkList err");
        return -1;
    }
    //2.遍历到删除位置前一个节点
    for(int i=0;i<post;i++)
    {
        p=p->next;
    }
    //3.定义一个指针指向被删除节点
    link_list_t pdel=p->next;
    //4.跨过被删除节点
    p->next = pdel->next;
    //5.释放被删除节点
    free(pdel);
    pdel=NULL;
}

删除指定数据

1.定义一个代替指针q指向p的next
   定义一个删除指针pdel
2.用q无头遍历
3.if（q->data==data)
         执行删除操作
          q指针指向下一个节点
  p指向下一个节点
  q指向p下一个节点

分段代码

//删除单向链表中出现的指定数据,data 代表将单向链表中出现的所有 data 数据删除
int DeleteDataLinkList(link_node_t *p, datatype data)
{
    //1.定义指针q，q指向p的next
    link_list_t q =p->next;
    link_list_t pdel =NULL;
    //2.用q遍历无头链表
    while(q != NULL)
    {
        if(q->data == data)
        {
            pdel=q;//1.将pedl指向被删除节点
            p->next=pdel->next;//2.跨过被删除节点
            free(pdel);//3.释放被删除节点
            pdel=NULL;
            q=p->next;//4.q指向链表删除后的下一个节点
        }
        else
        {
            p=p->next;//p走向下一个节点
            q=p->next;//q重新指向p的下一个节点
        }
        
    }
    return 0;
}

修改指定位置的数据

1.容错判断(判越界）
2.for遍历到修改节点的位置
3.修改操作

用头指针遍历到修改节点位置：

for(int i=0;i<=post;i++)
    {
        p=p->next;
    }

修改操作：

p->data = data;

分段代码

//修改指定位置的数据 post 被修改的位置 data 修改成的数据
int ChangePostLinkList(link_node_t *p, int post, datatype data)
{
    //1.容错判断
    if(post<0 || post>=LengthLinkList(p))
    {
        perror("ChangePostLinkList err");
        return -1;
    }
    //2.遍历到修改的节点位置
    for(int i=0;i<=post;i++)
    {
        p=p->next;
    }
    //3.修改数据
    p->data = data;
    return 0;
}

查找指定数据出现的位置

1.定义一个下标指针post
2.有头遍历
3.判断p->data==data
3.计数post++

分段代码

查找指定数据出现的位置 data 被查找的数据 //search 查找
int SearchDataLinkList(link_node_t *p, datatype data)
{
    int post =0;
    while(p->next != NULL)          
    {                              
        p=p->next;                       
        if(p->data==data)
            return post;
        post++;
    }
    return -1;
}

遍历

1.有头遍历

分段代码

//遍历单向链表
void ShowLinkList(link_node_t *p)
{
    p=p->next;
    while(p != NULL)
	{
        
		printf("%d ",p->data);
		p = p->next;
	}
	printf("\n");
}

转置

1.创建替代指针q
   创建临时指针temp存放q的下一个节点
2.断头操作
3.遍历无头链表
4.转置操作（先连后面再连前面）
5.将q指向temp存储的q的下一个节点

断头操作：

p->next=null

转置操作：

q->next=p->next
p->next=q转置操作：
q->next=p->next
p->next=q

分段代码

转置链表
void ReverseLinkList(link_node_t *p)
{
    //1.断开前保存头节点的下一个节点的地址
    link_list_t q =p->next;
    link_list_t temp =NULL;
    //2.断开链表
    p->next=NULL;
    //3.遍历无头链表
    while(q != NULL)
    {
        //提前保存q的下一个节点
        temp =q->next;
        //先连后面再连前面
        q->next=p->next;
        p->next=q;
        //将q移动到无头链表的下一个节点
        q=temp;
    }
}

清空链表

1.定义一个删除指针pdel
2.有头遍历
3.清空操作

分段代码

//清空单向链表
void ClearLinkList(link_node_t *p)
{
    link_list_t pdel =NULL;
    while (p->next !=NULL)//遍历一遍
    {
        pdel=p->next;//pdel指向当前节点
        p->next=pdel->next;//进到下一个节点
        //3.释放被删除节点
        free(pdel);
        pdel=NULL;
    }    
}

总代码

//1.创建一个空的单向链表(有头单向链表)
link_node_t *CreateEpLinkList()
{
    //思想：创建一个节点，作为头节点
    link_list_t p=(link_list_t)malloc(sizeof(link_node_t));
    if(p==NULL)
    {
        perror("CreateEpLinkList err");
        return NULL;
    }
    p->next=NULL;
    return p;
}

//2.求单向链表长度的函数
int LengthLinkList(link_node_t *p)
{
    int len=0;
    while(p->next !=NULL)
    {
        p=p->next;
        len++;
    }
    return len;
}

//3.向单向链表的指定位置插入数据
//p 保存链表的头指针 post 插入的位置 data 插入的数据
int InsertIntoPostLinkList(link_node_t *p,int post, datatype data)
{
    link_list_t pnew = NULL;
    //1.容错判断
    if(post<0|| post>LengthLinkList(p))
    {
        perror("InsertIntoPostLinkList err");
        return -1;
    }
    //2.将头指针移动到插入位置的前一个节点
    for (int i = 0; i < post; i++)
    {
        p=p->next;
    }
    //3.创建新节点保存插入数据
    pnew =(link_list_t)malloc(sizeof(link_node_t));
    if(pnew ==NULL)
    {
        perror("pnew malloc err");
        return -1;
    }
    pnew->data=data;
    pnew->next ==NULL;
    //4.将新节点插入指定位置
    pnew->next =p->next;
    p->next=pnew;
    return 0;    
}

//4.判断单向链表是否为空 1 代表空 0 代表非空
int IsEpLinkList(link_node_t *p)
{
    return p->next==NULL;
}

//5.删除单向链表中指定位置的数据 post 代表的是删除的位置
int DeletePostLinkList(link_node_t *p, int post)
{
    //1.容错判断
    if(post<0 || post>=LengthLinkList(p) || IsEpLinkList(p))
    {
        perror("DeletePostLinkList err");
        return -1;
    }
    //2.遍历到删除位置前一个节点
    for(int i=0;i<post;i++)
    {
        p=p->next;
    }
    //3.定义一个指针指向被删除节点
    link_list_t pdel=p->next;
    //4.跨过被删除节点
    p->next = pdel->next;
    //5.释放被删除节点
    free(pdel);
    pdel=NULL;
}

//6.遍历单向链表
void ShowLinkList(link_node_t *p)
{
    p=p->next;
    while(p != NULL)
	{
        
		printf("%d ",p->data);
		p = p->next;
	}
	printf("\n");
}

//7.修改指定位置的数据 post 被修改的位置 data 修改成的数据
int ChangePostLinkList(link_node_t *p, int post, datatype data)
{
    //1.容错判断
    if(post<0 || post>=LengthLinkList(p))
    {
        perror("ChangePostLinkList err");
        return -1;
    }
    //2.遍历到修改的节点位置
    for(int i=0;i<=post;i++)
    {
        p=p->next;
    }
    //3.修改数据
    p->data = data;
    return 0;
}

//8.查找指定数据出现的位置 data 被查找的数据 //search 查找
int SearchDataLinkList(link_node_t *p, datatype data)
{
    int post =0;
    while(p->next != NULL)          
    {                              
        p=p->next;                       
        if(p->data==data)
            return post;
        post++;
    }
    return -1;
}

//9.删除单向链表中出现的指定数据,data 代表将单向链表中出现的所有 data 数据删除
int DeleteDataLinkList(link_node_t *p, datatype data)
{
    //1.定义指针q，q指向p的next
    link_list_t q =p->next;
    link_list_t pdel =NULL;
    //2.用q遍历无头链表
    while(q != NULL)
    {
        if(q->data == data)
        {
            pdel=q;//1.将pedl指向被删除节点
            p->next=pdel->next;//2.跨过被删除节点
            free(pdel);//3.释放被删除节点
            pdel=NULL;
            q=p->next;//4.q指向链表删除后的下一个节点
        }
        else
        {
            p=p->next;//p走向下一个节点
            q=p->next;//q重新指向p的下一个节点
        }
        
    }
    return 0;
}

//10.转置链表
void ReverseLinkList(link_node_t *p)
{
    //1.断开前保存头节点的下一个节点的地址
    link_list_t q =p->next;
    link_list_t temp =NULL;
    //2.断开链表
    p->next=NULL;
    //3.遍历无头链表
    while(q != NULL)
    {
        //提前保存q的下一个节点
        temp =q->next;
        //先连后面再连前面
        q->next=p->next;
        p->next=q;
        //将q移动到无头链表的下一个节点
        q=temp;
    }
}

//11.清空单向链表
void ClearLinkList(link_node_t *p)
{
    link_list_t pdel =NULL;
    while (p->next !=NULL)//遍历一遍
    {
        pdel=p->next;//pdel指向当前节点
        p->next=pdel->next;//进到下一个节点
        //3.释放被删除节点
        free(pdel);
        pdel=NULL;
    }
    
}
壹玖揪
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构之——链表
xqx_999的博客
10-06 4666
链表的介绍，单链表和双向链表的接口实现。
C语言 数据结构链表的实例（十九种操作）
08-29
C语言数据结构链表的实例（十九种操作） 在计算机科学中，数据结构是指计算机中存储、组织和管理数据的方式。链表是一种基本的数据结构，广泛应用于计算机科学和软件开发中。今天，我们将讨论C语言中的数据结构链表...
链表
weixin_30527323的博客
08-02 99
题1：已知链表的头节点head,写一个函数把这个链表逆序 #include<iostream> using namespace std; typedef struct Node { int data; struct Node *next; }Node; Node* CreatList(int n) { //创建链表 ...
数据结构——链表及链表功能实现
weixin_53747689的博客
02-17 1021
链表 将线性表L=(a0,a1,……,an-1)中各元素分布在存储器的不同存储块，称为结点，通过地址或指针建立元素之间的联系。 线性表的链式存储结构 结点的data域存放数据元素ai，而next域是一个指针，指向ai的直接后继ai+1所在的结点。 带头结点的单链表： 结点类型描述： typedef struct node { data_t data; //结点的数据域// struct node *next; //结点的后继指针域// }listnode
链表修改数据（附完整代码）
Discod_lim的博客
03-17 1425
链表修改数据（附完整代码）
数据结构之单向有头链表的操作(纯代码及代码解释)
m0_68210771的博客
08-13 513
单向有头链表的详细代码和程序思路
【数据结构】链表
热门推荐
knous
03-13 6万+
链表
数据结构链表的创建
雾的博客
05-11 4377
实现链表的创建、遍历、排序、插入、删除 。
数据结构 -- 链表详解
hu_143的博客
04-27 2475
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
数据结构之链表
CSDN全栈领域优秀博主，阿里云博客专家，工信部权威认证物联网技术开发工程师，曾30分钟高分通过C语言二级，两天手撸代码完成EasyX飞机大战，靠接软件私活一个月换苹果电脑
01-18 4107
数据结构之链表
Educoder头歌数据结构链表及其应用
qq_50848214的博客
11-05 1万+
头歌实践平台答案educoder 数据结构-链表及其应用 第1关：链表的实现之查找功能 /************************************************************* 链表的实现之查找功能 实现文件 更新于2020年4月21日 **************************************************************/ void LL_GetAt(LinkList L, int i, ElemType &amp
湖南大学数据结构链表实验1.zip
03-08
在本实验中，我们将深入探讨数据结构中的一个重要概念——链表。链表是一种线性数据结构，与数组不同，它不连续存储元素。在链表中，每个元素（称为节点）包含两部分：数据和指向下一个节点的指针。这个实验来自湖南...
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
lb.rar_数据结构 链表
09-20
本资源"lb.rar_数据结构 链表"提供了一些关于链表的C++实现，对学习数据结构的初学者尤其有帮助。 链表是一种线性数据结构，与数组不同，它的元素并不在内存中连续存储。每个元素（节点）包含两部分：数据域，用于...
pp.zip_数据结构链表实验
09-21
在"pp.zip_数据结构链表实验"中，我们聚焦于一个具体的应用场景——学生信息管理。这个实验旨在帮助学生深入理解链表的运作机制，并能够实际操作链表来解决实际问题。 链表是一种线性数据结构，与数组不同，它的...
树、二叉树
最新发布
2301_79909332的博客
08-30 116
1、满二叉树：满二叉树是一种特殊的二叉树，其中每个层级的节点数都是最大值，即每个层级都是完全填充的。深度： 从根节点出发到达节点的分支节点个数称为该节点的深度。高度：从叶子节点出发到该节点最大的节点个数称为该节点的高度。树的高度：整个树形结构中高度最高的节点的高度称为树的高度。树的深度：整个树形结构中深度最深的节点的深度称为树的深度。3、二叉树特点：叶子节点、只有左孩子、只有右孩子、左右孩子都有。树的层数 == 树的高度 == 树的深度。3.叶子节点：没有后继的节点。节点的度： 叶子节点度数为0。
【数据结构】—— 树和二叉树
mist的博客
08-26 1483
树和二叉树、堆（顺序结构）、二叉树链式结构
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1216
KMP算法：理解next[]表
集合及数据结构第十三节（下）———— 枚举与Lambda表达式
2301_79418684的博客
08-27 1118
枚举与枚举的使用 1. 什么是C语言 2. 数据类型 3. 变量、常量 4. 字符串+转义字符+注释 5. 选择语句 6. 循环语句 7. 函数 8. 数组 9. 操作符 10. 常见关键字 11. define 定义常量和宏 12. 指针 13. 结构体
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值