单链表(含头结点)实现增删查改功能

已于 2023-07-29 14:08:06 修改
阅读量266 收藏 1
点赞数 5
文章标签： c语言 ubuntu 链表 数据结构
于 2023-07-27 20:47:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43627093/article/details/131968187
版权

头结点无数据，头结点的指针域next指向第一个元素(此时last = 0) 

头指针初始指向头结点

通过遍历移动头指针来寻找结点

LinkList.c文件

包含头文件LinkList.h

函数定义

单链表初始化函数LL LLInit();
单链表长度函数int LLLength(LL H);
单链表插入函数int LLInsert(LL H , int post , LLNDataType data);
单链表打印函数void LLPrint(LL H);
单链表查找函数int LLFind(LL H, LLNDataType data);
单链表修改函数int LLModify(LL H, int post, LLNDataType data);
单链表删除函数(按位置)int LLDelete(LL H, int post);
单链表删除函数(按内容)void LLDeleteData(LL H,LLNDataType data);
单链表清空函数void LLClear(LL H);

单链表插入操作图解：

通过循环遍历让头指针H指向要插入位置(post)的前一个位置(post-1)




按图示顺序先定义一个PNew指针来保存要插入的新结点

PNew->next = NULL;

PNew->data = data;         //将要插入的数据存放到PNew的数据域PNew->data

将新结点的指针域next指向要被插入位置上的结点post

PNew->next = H->next;

然后将post-1结点与新结点相连

H->next = PNew;

#include "LinkList.h"

LL LLInit()
{
    LL H = (LL)malloc(sizeof(LLN));   //定义一个指向单链表类型的结构体指针，并为其开辟空间
    if (NULL == H)                    //判断是否成功开辟空间
    {
        printf("LLInit failed\n");    //打印失败信息
        return NULL;                  //返回空指针(返回值要与函数定义的返回值保持一致)
    }

    H->next = NULL;                   // 成功开辟空间后，将头结点的指针域赋空
    return H;                         //返回头指针
}

int LLLength(LL H)                    //定义单链表长度函数，返回int类型的长度
{
    int len = 0;                      //定义长度len并初始化为0
    while (H->next)                   //等价于while(H->next!=NULL) 头结点的next指向下标为0的第一个元素
    {
        H = H->next;                  //将头指针向后移动
        len++;                        //每次移动后长度计数加1,循环结束后len中得到单链表的长度
    }
    return len;                       //返回单链表的长度
}

int LLInsert(LL H, int post, LLNDataType data)     //定义单链表元素插入函数，三个形参 H是要传入的结构体指针(头指针)  元素插入位置post  要插入的数据data
{
    if (post < 0 || post > LLLength(H))    //判断插入位置是否存在(因为可以在最后一个元素之后进行插入，所以post>LLLength(H)插入位置可以是最后一个下标之后的位置，也就是下标等于长度 )
    {
        printf("LLInsert failed , post is illegal\n");   //如果插入位置无效，打印错误信息
        return -1;                                       //返回值int类型  -1表示非正常结束
    }
    for (int i = 0; i < post; i++)                       //因为单链表内存位置不连续，所以在找插入位置post时要通过for循环进行遍历
        H = H->next;                                //头指针向后遍历
    LL PNew = (LL)malloc(sizeof(LLN));              //开辟一个单链表结点PNew来存放要插入的数据，通过malloc实现(开辟堆空间要注意类型匹配问题，通过强制类型转换解决)
    if (NULL == PNew)                              //判断PNew是否开辟成功
    {
        printf("PNew malloc failed\n");            //如果开辟失败，打印错误信息
        return -1;                                 //返回值 -1
    }
    PNew->next = NULL;                             
    PNew->data = data;     //对创建的新结点进行赋值

    PNew->next = H->next;   //将新建的结点与单链表插入点进行连接(先连后再连前)因为其后部分链表无法找到，断开后丢失
    H->next = PNew;         //将新建结点与插入点的直接前驱进行连接(通过头指针)
    return 0;               //返回值 0  表示正常结束
}

void LLPrint(LL H)          //定义一个单链表打印(显示)函数  传递形参(传入单链表H)
{
    while (H->next)         //等价于while(H->next!=NULL) 头结点的next指向下标为0的第一个元素
    {
        H = H->next;        //头指针向后遍历
        printf("%d ", H->data);         //逐个打印单链表元素
    }
    putchar(10);            //换行
}

int LLFind(LL H, LLNDataType data)  // 定义单链表查找函数(传递单链表和要查找的数据)
{
    int post = 0;           //记录查找的初始位置post = 0
    while (H->next != NULL)     //通过while循环控制指针在单链表范围内(含头结点的单链表)
    {
        H = H->next;            //头指针向后遍历
        if (data == H->data)    //如果找到数据(此时头指针在数据所在结点位置)
            return post;        //返回位置信息(下标)
        post++;                 //下标随着遍历自增
    }

    return -1;          //查询不到要找的元素
}

int LLModify(LL H, int post, LLNDataType data)      //定义单链表修改函数(按位置进行修改)形参为单链表头指针，要修改位置下标，更改后的数据
{
    if (post < 0 || post >= LLLength(H))
    {
        printf("LLModify failed , post is illegal\n");
        return -1;
    }
    for (int i = 0; i <= post; i++)
        H = H->next;
    H->data = data;
    return 0;
}

int LLDelete(LL H, int post) //按位置删除单链表结点
{
    if (post < 0 || post >= LLLength(H))
    {
        printf("LLInsert failed , post is illegal\n");
        return -1;
    }

    for (int i = 0; i < post; i++)
        H = H->next;
    LL PDel = H->next;
    H->next = H->next->next;

    free(PDel);
    return 0;
}

void LLDeleteData(LL H, LLNDataType data) //按数据内容进行删除  删除从前向后遇到的第一个符合条件的元素
{
    LL PDel = NULL;                         //定义一个单链表指针并赋空
    while (H->next != NULL)                 //循环遍历
    {
        if (H->next->data == data)          //如果找到要删除的内容
        {
            PDel = H->next;                 //用PDel接收要删除的结点
            H->next = H->next->next;        //将删除后的单链表前后连接
            free(PDel);                     //释放PDel(单链表指针占用的空间)
            PDel = NULL;                    //PDel赋空  避免出现野指针
        }
        else
        {
            H = H->next;                    //继续向后遍历，删除表内所有data元素
        }
    }
}

void LLClear(LL H)                          //单链表清空函数(保留头结点，销毁需要删除头结点)
{
    LL PDel = NULL;                           //定义一个接收删除结点的单链表指针
    while (H->next != NULL)                  //循环遍历
    {
        PDel = H->next;                    
        H->next = H->next->next;            
        free(PDel);                         //循环删除每个结点
        PDel = NULL;                         //指针赋空避免出现野指针
    }
}

头文件LinkList.h

使用结构体对有头单链表进行定义，存放函数声明并使用 #ifndef 防止重复包含

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

#include<stdio.h>
#include<stdlib.h>
typedef int LLNDataType;
typedef struct LinkListNode
{
    LLNDataType data;
    struct LinkListNode *next;
}LLN, *LL;


LL LLInit();
int LLLength(LL H);
int LLInsert(LL H , int post , LLNDataType data);
void LLPrint(LL H);
int LLFind(LL H, LLNDataType data);
int LLModify(LL H, int post, LLNDataType data);
int LLDelete(LL H, int post);
void LLDeleteData(LL H,LLNDataType data);
void LLClear(LL H);

#endif

主函数test.c

测试功能：函数调用
1.创建一个空的有头单向链表LL H = LLInit();
2.向单链表的0~4号位置分别插入10、11、12、13、14并打印链表验证

 LLInsert(H,0,10);
 LLInsert(H,1,11);

 LLInsert(H,2,12);
 LLInsert(H,3,13);
 LLInsert(H,4,14);

3.打印链表长度printf("单链表长度是 %d\n",LLLength(H));
4.查找12在单链表的位置并输出到终端printf("元素12在单链表中的位置(下标)是:%d",LLFind(H,12));
5.修改0号位置数据为14并打印链表验证LLModify(H,0,14);
6．删除1号位置数据并打印链表验证LLDelete(H,1);
7．删除所有数据为14的结点并打印验证LLDeleteData(H,14);
8.  清空链表并打印验证LLClear(H);

#include"LinkList.h"

int main(int argc, char const *argv[])
{
    LL H = LLInit();
    printf("单链表初始长度是 %d\n",LLLength(H));
    LLInsert(H,0,10);
    LLInsert(H,1,11);
    LLInsert(H,2,12);
    LLInsert(H,3,13);
    LLInsert(H,4,14);

    printf("单链表长度是 %d\n",LLLength(H));

    printf("单链表为：\n");
    LLPrint(H);
    printf("元素12在单链表中的位置(下标)是:%d",LLFind(H,12));
    putchar(10);
    LLModify(H,0,14);
    printf("单链表更改为：\n");
    LLPrint(H);

    LLDelete(H,1);
    printf("单链表删除1号位置之后为：\n");
    LLPrint(H);

    printf("单链表删除元素'14'后为：\n");
    LLDeleteData(H,14);
    LLPrint(H);

    LLClear(H);
    printf("清空后的单链表长度为%d\n",LLLength(H));

    free(H);
    return 0;
}

打印结果：

makefile文件

CC=gcc
OBJS=test.o LinkList.o
CFLAGS=-c -g -Wall
test:$(OBJS)
	$(CC) $(OBJS) -o $@
%.o:%.c
	$(CC) $(CFLAGS) $< -o $@
.PHONY:clean
clean:
	$(RM) *.o test

# test:test.c LinkList.c
# 	gcc $^ -o $@
# clean:
# 	rm test

L.Messi
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单链表实现增删改查
博客
06-07 95
Node类 单链表类
单链表的增删查改
weixin_46031570的博客
12-09 200
1.SList.c文件 #include"SList.h" SListNode*BuySListNode(SListDataType x) { SListNode* newNode = (SListNode*)malloc(sizeof(SListNode)); if (newNode == NULL) { printf("申请结点失败\n"); exit(-1); } newNode->data = x; newNode->next = NULL; return ne
(超详细！)【C语言】单链表的增删查改（附图解，源码）
qq_74641564的博客
03-04 1954
本文为我对链表学习的过程与理解，适合新手学习交流。内容如题，我将结合画图和截图带领大家更好的理解单链表结构，学习和使用它增删查改的功能！
数据结构：链表实现增删查改的基本功能【内含详细代码，建议收藏】
weixin_53472920的博客
09-15 3508
hello，大家好，这期文章继续用来更新数据结构方面的知识——链表。。这期文章依旧是对之前的文章[数据结构：红玫瑰与白玫瑰之争](https://blog.csdn.net/weixin_53472920/article/details/115463675)的补充，希望对大家有所帮助。我们在之前的文章中已经介绍过顺序表，链表和顺序表有很大的不同，相对于顺序表，链表无疑是更加灵活的。顺序表在实现过程中头部插入数据时需要挪动数据，在增容的过程中也会消耗性能，并且以倍数的方式增容也会造成空间的浪费。链表 ...
数据结构之链表，实现单链表的增删查改
jolly0514的博客
04-07 1127
本文主要介绍了链表，以及对链表的操作：增删查改等，如有错误，敬请指正。
链表的实现之增删功能
最新发布
m0_64562382的博客
01-11 523
链表的实现之增删功能
链表的增删查改功能的实现
MacondoMayor的博客
04-05 2528
链表增删改查功能的实现
【数据结构】---单链表____增删查改
weixin_52563203的博客
07-29 434
单链表概念，结构，功能
数据结构——不带头结点的单链表增删查改的C语言实现
m0_46657980的博客
07-26 347
1、slist.h #ifndef _slist_h_ #define _slist_h_ #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<stdbool.h> #include<memory.h> #include<vld.h> #pragma warning(disable:4996) #define ElemType int typedef
单链表的增删查改操作
m0_67198282的博客
03-17 1502
单链表——只能单向访问的链表 每个结点中存放数据和下个结点的地址 我们今天来实现单链表简单的增删查改操作 1.准备工作 在开始前我们首先创建一个包含数据和地址的结构体结点 typedef int Slisttype;//使得数据类型修改方便 typedef struct SlistNode { Slisttype data;//结点中存储的数据 struct SlistNode* next;//下个结点的地址 }SlistNode; 然后我们再创建第一个结点（NULL） .
单链表的增删查改详解（代码加图解）
LCW0102的博客
10-25 786
单链表的特点是只能从头开始向后遍历，所以我们在增删查改的过程中都要考虑从头开始的问题，单链表的临界情况是对于头结点的操作，我们需要对头节点多加考虑。 class NodePractice{ //存储结点的内容 int data; //存储下一个结点的地址 NodePractice next; public NodePractice(int data) { this.data = data; } } public class SingleLi
关于单链表的增删查改等操作（c语言版）
BUDAXIHUANCHICU的博客
08-09 2797
单链表的一系列操作（含菜单）
链表实现增删查改
zhengyawen666的博客
04-26 1180
一 链表的特点 1 按需申请空间 由于每一块物理空间都是单独申请的，因此需要考虑如何关联每一个内存块 -》用指针关联（每个节点存放两个东西：内容和指向下一个内存块的指针） 相比于顺序表空间浪费较小：一次开辟两倍，过多浪费；频繁开辟那么频繁访问内存，效率低下。 2 效率更高 头部或者中间插入删除，不需要挪动数据（顺序表需要），相对于顺序表效率更高，因为顺序表再头部或者中间插入的话，需要挪动数据。 总结：链表与顺序表优势互补，各有特点。 二 链表的结构 对于单向不循环链表 每个节点包括所
C语言实现单链表(图解增删查改+代码)
m0_50655389的博客
10-22 1251
上面文章用C语言实现了顺序表的增删查改，本片文章继续用C语言来实现另一种线性存储结构——单链表。
单链表---实现基本的增删改查功能
为梦而生_
10-08 594
作为掌握C语言基本语法知识之后的拓展延伸，数据结构再合适不过，首先我们将接触到链表的使用。 在此将以 如下程序样例 分段解析 链表的具体使用方法 首先是程序头部分,其包含如下 1-所需头文件 2-宏定义初始链表成员数量 3-定义链表的数据类型 4-声明各类函数 #include<stdio.h> #include<stdlib.h> #define _CRT_SECURE_NO_WARNINGS #define Num 5 typedef struct stu {
C语言链表——增删改查
weixin_54859557的博客
03-20 2796
链表是一种数据结构，是一种数据存放的思想
C语言实现单链表-增删改查
05-28 799
链表是由一连串节点组成的数据结构，每个节点包含一个数据值和一个指向下一个节点的指针。链表可以在头部和尾部插入和删除节点，因此可以在任何地方插入和删除节点，从而使其变得灵活和易于实现。
c语言单链表的实现（增，删，改，查等功能）
m0_64862267的博客
04-25 184
总结：本代码为没有哨兵位的单链表所以要传二级指针，只要遇到要操作第一个节点都要传二级指针，还要注意在增删情况下，大部分要考虑链表为空，链表只有一个节点的情况，在学习链表的时候，要多画图。SList.h结构体函数声明文件。SList.c函数实现文件。test.c测试函数文件。
保姆级基于C语言实现单链表的增删查改（内附源码）
2301_79165368的博客
11-23 120
/菜单//选择--------------------------------------------方式////选择插入方式，头插还是尾插//选择删除方式，头插还是尾插还是任意删//API---------------------------------------------插口////插入新学生信息（头插）//插入新学生信息（尾插）//删除学生信息（头删）//删除学生信息（尾删）//任意插//插在想要插入的学生之前//任意删//删掉该学生信息//修改学生。
C语言单链表操作详解：增删查改与内存管理
本文主要探讨了C语言中单链表数据结构的增删查改操作。单链表是一种动态数据结构，它在物理存储上是非连续和非顺序的，数据元素的逻辑顺序通过链表中的指针链接来实现。这种特性使得链表在处理插入和删除操作时相对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值