C语言实现单链表的增删查改

最新推荐文章于 2024-09-19 12:27:10 发布
最新推荐文章于 2024-09-19 12:27:10 发布
阅读量1.7w 收藏 36
点赞数 17
分类专栏： c语言 数据结构 线性表 单链表 数据结构 文章标签： 线性表 单链表 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40927789/article/details/79686922
版权

链表：一种链式存储的线性表，用一组地址任意的存储单元存放线性表的数据元素，称存储单元为一个节点。
链表分类：

单链表
双链表
双向循环链表

代码实现单链表的增删查改：
linklist.h文件

#pragma once

#include<stddef.h>

typedef char LType;

typedef struct LinkNode
{
    //数据域
    LType data;
    //指针域
    struct LinkNode* next;
}LinkNode;

LinkNode *head;

//初始化
void linklistInit(LinkNode **head);
//节点销毁
void DestroyNode(LinkNode *node);

//打印链表
void linklistPrint(LinkNode *head);
//逆序打印链表（递归）
void linklistReversePrint(LinkNode *head);

//尾插
LinkNode *linklistPushBack(LinkNode **head,LType value);
//尾删
void linklistPopBack(LinkNode **head);

//头插
void linklistPushFront(LinkNode **head,LType value);
//头删
void linklistPopFront(LinkNode **head);

//查找指定元素的下标，返回元素地址
LinkNode *linklistFind(LinkNode *head,LType to_find);

//指定位置之前插入指定元素（遍历）
void linklistInsertBefore(LinkNode **head,LinkNode*pos,LType value);
//指定位置之前插入指定元素（不遍历）
void linklistInsertBefore1(LinkNode**head,LinkNode*pos,LType value);
//指定位置之后插入指定元素（遍历）
void linklistInsertAfter(LinkNode **head,LinkNode *pos,LType value);

//删除指定元素（遍历）
void linklistErase(LinkNode **head,LinkNode *pos);
//删除指定元素（不遍历）
void linklistErase2(LinkNode **head,LinkNode *pos);

//删除指定元素，若有多个该元素则删除第一个
void linklistRemove(LinkNode **head,LType to_delete);

//判断链表是否为空，空则返回0否则返回1
int linklistEmpty(LinkNode *head);
//求链表元素个数
size_t linklistSize(LinkNode *head);

linklist.c文件

#include<stdio.h>
#include<stdlib.h>
#include"linklist.h"

#define Test_Header printf("\n-----%s-----\n",__FUNCTION__);

//初始化函数
void linklistInit(LinkNode **head)
{
    *head = NULL;
}
//创建新节点函数
LinkNode *CreateNode(LType value)
{
    //为新节点申请空间
    LinkNode *new_node = (LinkNode*)malloc(sizeof(LinkNode));
    //给新节点赋值
    new_node->data = value;
    //将新节点的next指向空
    new_node->next = NULL;
    return new_node;
}
//销毁一个节点
void DestroyNode(LinkNode *node)
{
    free(node);
}
//顺序打印链表元素
void linklistPrint(LinkNode *head)
{
    if(head == NULL)
    {
        //空链表无需打印
        return;
    }
    LinkNode *cur = head;
    //遍历链表
    while(cur != NULL)
    {
        //打印元素和其对应的地址
        printf("%c|%p\n",cur->data,cur);
        //移动cur,以达到遍历链表的目的
        cur = cur->next;
    }
    printf("\n\n");
}
//逆序打印链表（递归思想）
void linklistReversePrint(LinkNode *head)
{
    if(head == NULL)
    {
        //空链表无需打印，也是递归的出口
        return;
    }   
    linklistReversePrint(head->next);
    printf("%c|%p ",head->data,head);
    printf("\n");
}
//尾插函数
LinkNode *linklistPushBack(LinkNode **head,LType value)
{
    //非法输入
    if(head == NULL)
    {
        return NULL;
    }
    //空链表
    if(*head == NULL)
    {
        //直接创建一个新的节点完成元素插入
        *head = CreateNode(value);
        return NULL;
    }
    else
    {
        LinkNode *cur = *head;
        //遍历链表，让cur指向最后一个元素
        while(cur->next != NULL)
        {
            cur = cur->next;
        }
        //创建一个新节点
        LinkNode *new_node = CreateNode(value);
        //将最后一个元素的next指向新节点
        cur->next = new_node;
        return new_node;
    }
}
//尾删函数
void linklistPopBack(LinkNode **head)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表没有可删除的元素
    if(*head == NULL)
    {
        return;
    }
    //只有一个元素
    if((*head)->next == NULL)
    {
        //直接删除节点
        DestroyNode(*head);
        //将头结点置空
        *head = NULL;
        return;
    }
    else
    {
        LinkNode *cur = *head;
        //遍历链表，使cur指向倒数第二个元素
        while(cur->next->next != NULL)
        {
            cur = cur->next;
        }
        //创建指针指向最后一个元素，即我们需要删除的元素
        LinkNode *to_delete = cur->next;
        //将该节点销毁
        DestroyNode(to_delete);
        //将倒数第二个元素的next指向空
        cur->next = NULL;
    }
    return;
}
//头插函数
void linklistPushFront(LinkNode **head,LType value)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表
    if(*head == NULL)
    {
        //直接创建一个新节点完成插入
        *head = CreateNode(value);
        return;
    }
    else
    {
        //创建一个新的指针指向头结点
        LinkNode *new_node = *head;
        //创建一个新的头结点
        *head = CreateNode(value);
        //将新的头结点的next指向旧的头结点
        (*head)->next = new_node;
    }
    return;
}
//头删函数
void linklistPopFront(LinkNode **head)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表没有可删除的元素
    if(*head == NULL)
    {
        return;
    }
    else
    {
        //创建一个新的指针指向第二个元素
        LinkNode *new_node = (*head)->next;
        //将头结点的next指向空
        (*head)->next = NULL;
        //删除该头结点
        DestroyNode(*head);
        //将第二个元素设置成新的头结点
        *head = new_node;
    }
    return;
}
//查找链表中指定元素的地址
LinkNode *linklistFind(LinkNode *head,LType to_find)
{
    int count = 0;
    LinkNode *find = head;
    //空链表
    if(head == NULL)
    {
        return;
    }
    else
    {
        //循环遍历链表
        for(;find->next != NULL;find = find->next)
        {
            if(find->data == to_find)
            {
                count++;
                //找到了返回该元素的地址
                return find;
            }
        }
    }
    //如果count计数为0，说明没有链表中不存在想要查找的元素
    if(count == 0)
    {
        printf("this value is non-existence\n");
    }
    //没找到返回空
    return NULL;
}

//在指定位置之前插入指定元素（遍历）函数
//时间复杂度为O(n)
void linklistInsertBefore(LinkNode **head,LinkNode *pos,LType value)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表
    if(*head == NULL)
    {
        //直接创建一个新的节点
        *head = CreateNode(value);
        return;
    }
    //如果是头结点位置
    if(pos == *head)
    {
        //则进行头插
        linklistPushFront(head,value);
        return;
    }
    //如果为空
    if(pos == NULL)
    {
        //则进行尾插
        linklistPushBack(head,value);
        return;
    }
    else
    {
        LinkNode *cur = *head;
        //遍历链表
        while(cur->next != NULL)
        {
            //cur的下一个位置就是pos
            if(cur->next == pos)
            {
                //创建一个指针，以value值创建节点
                LinkNode *pre = CreateNode(value);
                //将cur的next修改指向新的节点的位置
                cur->next = pre;
                //将新节点的next指向pos，就在pos位置之前插入了新元素
                pre->next = pos;
                return;
            }
            //将cur移向下一个元素，以达到遍历链表的目的   
            cur = cur->next;
        }
    }
}
//在指定位置之前插入指定元素（不遍历）函数
//时间复杂度为O(1)
void linklistInsertBefore1(LinkNode **head,LinkNode *pos,LType value)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表
    if(*head == NULL)
    {
        //直接创建一个新的节点
        *head = CreateNode(value);
        return;
    }
    //如果是头结点位置
    if(pos == *head)
    {
        //则进行头插
        linklistPushFront(head,value);
        return;
    }
    //如果位置为空
    if(pos == NULL)
    {
        //则进行尾插
        linklistPushBack(head,value);
        return;
    }
    else
    {
        //定义一个新指针指向pos的下一个位置
        LinkNode *cur = pos->next;
        //用pos位置的值创建一个新的节点
        LinkNode *new_node = CreateNode(pos->data);
        //将pos位置的值修改为value
        pos->data = value;
        //将pos的next指向新的节点
        pos->next = new_node;
        //将新节点的next指向pos的next，即指向cur
        new_node->next = cur;
    }
}
//在指定位置之后插入指定元素
void linklistInsertAfter(LinkNode **head,LinkNode *pos,LType value)
{
    //非法输入
    if(head ==NULL)
    {
        return;
    }
    //空链表
    if((*head) == NULL)
    {
        //直接以value值创建一个头结点
        *head = CreateNode(value);
        return;
    }
    //如果pos位置为空
    if(pos == NULL)
    {
        //则进行尾插
        linklistPushBack(head,value);
        return;
    }
    //如果pos为头结点的位置
    if(pos == *head)
    {
        //则进行头插
        linklistPushFront(head,value);
        return;
    }
    else
    {
        //创建一个新的指针指向头结点
        LinkNode *cur = *head;
        //遍历链表
        while(cur->next != NULL)
        {
            //cur的下一个位置就是pos
            if(cur->next == pos)
            {
                //以value值创建一个新的节点
                LinkNode *new_node = CreateNode(value);
                //新节点的next指向pos位置的next
                new_node->next = pos->next;
                //pos的next修改指向新的节点
                pos->next = new_node;
            }
            //移动cur
            cur = cur->next;
        }
    }
}
//删除指定位置的元素（遍历）函数
//时间复杂度为O（n）
void linklistErase(LinkNode **head,LinkNode *pos)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表
    if(*head == NULL)
    {
        return;
    }
    //如果pos位置为空
    if(pos == NULL)
    {
        //则进行尾删
        linklistPopBack(head);
        return;
    }
    //如果pos为头结点的位置
    if(pos == *head)
    {
        //则进行头删
        linklistPopFront(head);
        return;
    }
    else
    {
        //创建新的指针指向头结点
        LinkNode *cur = *head;
        //遍历链表，遍历完成以后cur的下一个位置就是pos
        while(cur->next != pos)
        {
            cur = cur->next;
        }
        //将cur的next指向pos的next
        cur->next = pos->next;
        //销毁pos节点
        DestroyNode(pos);
    }
}
删除指定位置的元素（遍历）函数
//时间复杂度为O(1)
void linklistErase2(LinkNode **head,LinkNode *pos)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表无法删除
    if(*head == NULL)
    {
        return;
    }
    //如果pos位置为空
    if(pos == NULL)
    {
        //则进行尾删
        linklistPopBack(head);
        return;
    }
    //如果pos为头结点位置
    if(pos == *head)
    {
        //则进行头删
        linklistPopFront(head);
        return;
    }
    else
    {
        //创建一个新的指针指向pos的next
        LinkNode *to_delete = pos->next;
        //将pos的下一个位置的元素赋给pos
        pos->data = to_delete->data;
        //再将pos的next指向其下一个元素的next
        pos->next = to_delete->next;
        //将pos的下一个位置节点删除
        DestroyNode(to_delete);
    }
}
//删除指定元素，若存在多个元素则只删除第一个函数
void linklistRemove(LinkNode **head,LType to_delete)
{
    //非法输入
    if(head == NULL)
    {
        return;
    }
    //空链表没有可删除的元素
    if(*head == NULL)
    {
        return;
    }
    //如果头结点的元素是要删除的元素
    if((*head)->data == to_delete)
    {
        //则进行头删
        linklistPopFront(head);
        return;
    }
    LinkNode *cur = *head;
    //遍历链表
    while(cur != NULL && cur->next != NULL)
    {
        //要删除的元素是cur的下一个元素
        if(cur->next->data == to_delete)
        {
            //定义一个新的指针指向cur的下一个元素（待删除元素）的位置
            LinkNode *to_remove = cur->next;
            //将cur的next指向其下一个元素（待删除元素）的下一个位置
            cur->next = to_remove->next;
            //删除新的节点（即一开始定义的指向待删除元素的指针）
            DestroyNode(to_remove);
            return;
        }
        cur = cur->next;
    }
}
//判断链表是否为空链表
int linklistEmpty(LinkNode *head)
{
    //为空返回0否则返回1
    return head == NULL?0:1;
}
//求链表中元素个数，返回元素个数
size_t linklistSize(LinkNode *head)
{
    //空链表返回0
    if(head == NULL)
    {
        return 0;
    }
    size_t count = 0;
    LinkNode *cur = head;
    //遍历链表
    for(;cur != NULL;cur = cur->next)
    {
        count++;
    }
    return count;
}

//尾插的测试函数
void TestPushBack()
{
    Test_Header;
    //初始化链表
    linklistInit(&head);
    //尾插a b c d
    linklistPushBack(&head,'a');
    linklistPushBack(&head,'b');
    linklistPushBack(&head,'c');
    linklistPushBack(&head,'d');
    linklistPrint(head);
}
//尾删的测试函数
void TestPopBack()
{
    Test_Header;
    //尾删3次
    linklistPopBack(&head);
    linklistPopBack(&head);
    linklistPopBack(&head);
    linklistPrint(head);
}
//头插的测试函数
void TestPushFront()
{
    Test_Header;
    //头插b c d
    linklistPushFront(&head,'b');
    linklistPushFront(&head,'c');
    linklistPushFront(&head,'d');
    linklistPrint(head);
}
//头删的测试函数
void TestPopFront()
{
    Test_Header;
    //头删3次
    linklistPopFront(&head);
    linklistPopFront(&head);
    linklistPopFront(&head);
    linklistPrint(head);
}

测试结果如图：
这里写图片描述

//查找指定元素的地址的测试函数
void TestFind()
{
    Test_Header;
    //尾插一个b
    linklistPushBack(&head,'b');
    printf("链表中的元素为:\n")
    linklistPrint(head);
    //查找元素a和c在链表中的地址
    LinkNode *ret1 = linklistFind(head,'a');
    LinkNode *ret2 = linklistFind(head,'c');
    printf("find address:a->%p c->%p\n",ret1,ret2);
}

测试结果如图：
这里写图片描述

/在指定位置之前插入指定元素（遍历）的测试函数
void TestInsertBefore()
{
    Test_Header;
    //期待打印出的链表元素
    printf("A a b x c d e\n");
    //尾插入一个c和d
    linklistPushBack(&head,'c');
    linklistPushBack(&head,'d');
    //指定位置为空时插入e（进行尾插）
    linklistInsertBefore(&head,NULL,'e');
    //指定位置为第一个位置时插入A（进行头插）
    linklistInsertBefore(&head,head,'A');
    //找到c元素的地址
    LinkNode *pos = linklistFind(head,'c');
    //在c位置之前插入x
    linklistInsertBefore(&head,pos,'x');
    linklistPrint(head);
}
//在指定位置之前插入指定元素（不遍历）的测试函数
void TestInsertBefore1()
{
    Test_Header;
    //期待打印出的链表元素
    printf("m A a b x n c d e o\n");
    //指定位置为空时插入o（进行尾插）
    linklistInsertBefore1(&head,NULL,'o');
    //指定位置为第一个位置时插入m（进行头插）
    linklistInsertBefore1(&head,head,'m');
    //找到c元素的地址
    LinkNode *pos = linklistFind(head,'c');
    //在c位置之前插入y
    linklistInsertBefore1(&head,pos,'n');
    linklistPrint(head);
}

测试结果如下：
这里写图片描述

//在指定位置之后插入指定元素的测试函数
void TestInsertAfter()
{
    Test_Header;
    //期待打印出的链表元素
    printf("B m A a b x n c y d e o E\n");
    //指定位置为空时插入E（进行尾插）
    linklistInsertAfter(&head,NULL,'E');
    //指定位置为第一个位置时插入B（进行头插）
    linklistInsertAfter(&head,head,'B');
    //找到c元素的地址
    LinkNode *pos = linklistFind(head,'c');
    //在c位置之后插入y
    linklistInsertAfter(&head,pos,'y');
    linklistPrint(head);
}

测试结果如图：
这里写图片描述

//删除指定位置元素(遍历)函数测试
void TestErase()
{
    Test_Header;
    //期待打印出的链表元素
    printf("m A a b x n y d e o\n");
    //若pos为空则执行尾删
    linklistErase(&head,NULL);
    //尝试删除第一个位置的元素
    linklistErase(&head,head);
    //找到c元素的地址
    LinkNode *pos = linklistFind(head,'c');
    //尝试删除c元素位置的元素，即删除c
    linklistErase(&head,pos);
    linklistPrint(head);
}
//删除指定位置元素(不遍历)函数测试
void TestErase2()
{
    Test_Header;
    //期待打印出的链表元素
    printf("A a b x y d e\n");
    //若pos为空则执行尾删
    linklistErase2(&head,NULL);
    //尝试删除第一个位置的元素
    linklistErase2(&head,head);
    //找到n元素的地址
    LinkNode *pos = linklistFind(head,'n');
    //尝试删除n元素位置的元素，即删除n
    linklistErase2(&head,pos);
    linklistPrint(head);
}

测试结果如图：
这里写图片描述

//逆序打印链表函数测试
void TestReversePrint()
{
    Test_Header;
    linklistReversePrint(head);
}
//删除指定元素，若存在多个该元素则只删除第一个的函数测试
void TestRemove()
{
    Test_Header;
    //期待打印的元素
    printf("a x y b d\n");
    //找到元素y的地址
    LinkNode *pos = linklistFind(head,'y');
    //在元素y之后插入b
    linklistInsertAfter(&head,pos,'b');
    //尝试删除末尾的元素
    linklistRemove(&head,'e');
    //尝试删除第一个元素
    linklistRemove(&head,'A');
    //尝试删除元素x
    linklistRemove(&head,'x');
    //尝试删除元素b原链表中有两个b
    linklistRemove(&head,'b');
    linklistPrint(head);
}

测试结果如图：
这里写图片描述

//求链表元素个数函数测试
void TestSize()
{
    Test_Header;
    size_t size = linklistSize(head);
    linklistPrint(head);
    printf("size:%lu\n",size);
}
//判断链表是否为空测试函数
void TestEmpty()
{
    Test_Header;
    //返回0说明链表为空，返回1说明链表不为空
    int ret1 = linklistEmpty(head);
    printf("%d\n",ret1);
}

测试结果如图：
这里写图片描述

//以下为测试函数调用
int main()
{
    TestPushBack();
    TestPopBack();
    TestPushFront();
    TestPopFront();
    TestFind();
    TestInsertBefore();
    TestInsertBefore1();
    TestInsertAfter();
    TestErase();
    TestErase2();
    TestReversePrint();
    TestRemove();
    TestSize();
    TestEmpty();
    return 0;
}
小心眼儿猫
关注
专栏目录
关于单链表的增删查改等操作（c语言版）
BUDAXIHUANCHICU的博客
08-09 2828
单链表的一系列操作（含菜单）
C语言实现单链表的增删改查
qq_53375020的博客
03-25 606
C语言实现带头结点单链表的相关操作
单链表c语言实现增删改查操作
09-21
VS2008运行环境 c语言实现单链表增删改查操作 并输出到控制台上
c语言 单链表的增删改查
04-25
C语言编写的单链表增删改查，实现了单链表的增加，删除，修改，查询等功能
【C语言】常见的C语言概念
最新发布
zxctsclrjjjcph的博客
09-19 3481
人和人交流使用的是自然语言，就像是汉语、英语、日语。那人和计算机是怎么交流的呢？使用计算机语言。目前已知已经有上千种计算机语言，人们们是通过计算机语言写的程序，给计算机下达指令，让计算机工作的。C语言就是众多计算机语言中的⼀种，当然C++/Java/Go/Python都是计算机语言。在VS上写代码，我们是需要创建项目的，直接新建项目就可以了。在项目中就可以添加源文件和头文件。C语言把 .c 为后缀的文件称为源文件，把 .h 为后缀的文件称为头文件。
单链表----增删查改（C语言版）
折木的博客
02-19 1211
前言 链表是数据结构中一种特别重要的结构，它和顺序表同属于线性表的一种。不同于顺序表的是，链表并没有局限于物理内存上的连续性，而是一种在逻辑上连续的线性表，因此链表可以实现很多顺序表难以实现的功能。 形象的理解，链表结构就像现实中链条一样，将一串单个物体串联在一起。 数据结构中的链表是主要这样： 链表分为多种类型，有单向链表、双向链表、带头链表、不带头链表等等…… 虽然链表类型多种多样，但实际中最常用的只有以下两种： 本篇文章我将主要向大家介绍无头单项非循环链表（单链表），这种链表结构简单，一般不会单
[数据结构]C语言链表实现
shenghua
12-26 395
[数据结构]C语言链表实现http://www.cnblogs.com/racaljk/p/7822311.html 目录   静态单链表实现   动态单链表实现   双向链表实现   循环单链表 我学数据结构的时候也是感觉很困难，当我学完后我发现了之所以困难时因为我没有系统的进行学习，而且很多教授都只是注重数据结构思想，而忽略了代码方面，为此我
c语言 单链表的增删查改（附：c++版本实现）
凡事都是靠练习
02-02 4963
单链表的增删查改，讲解基本接口的实现
C语言数据结构单链表的增删查改
04-29
C语言数据结构单链表的增删查改
数据结构——不带头结点的单链表增删查改的C语言实现
m0_46657980的博客
07-26 366
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
用c语言实现链表增删改查
11-07
自己写的，能够使用，对c语言的指针用的淋漓精致，有需要的小伙伴可以下载看下
链表操作（增删改查）C语言实现
10-05
链表操作（增删改查）C语言实现 在VC++6.0中可编译运行通过！
C语言单链表的实现
12-08
做了个简单的单链表实现，基本的功能都齐全了。而且我习惯附上详细的注释，应该对初学者蛮友好的了。
数据结构之链表实现（c语言）
m0_64334842的博客
11-09 1596
数据结构之链表介绍
C语言 单链表的增删改查
weixin_45747214的博客
05-08 739
单链表的增删改查 目录单链表的增删改查链表的创建和输出（有头结点）链表的查找链表的删除链表的修改 链表是一种最常见地采用动态存储分配方式的数据结构，相较于数组而言它更加灵活。 单链表的特点 有一个head指针变量，他存放第一个结点的地址，称之为“头指针”。 每个结点都包含一个数据域和一个指针域，数据域存放用户需要的实际数据，指针域存放下一个结点的地址。从头结点开始，每一个结点的指针域都指向下一个结点，所有结点都是单线联系。 最后一个节点不再指向其他节点，成为“表尾”结点，它的指针域为空指针“NULL”
【数据结构】单链表的增删查改（C语言实现）
在平淡的日子里寻找存在的价值
08-04 4904
单链表的增删查改操作（C语言实现）。
C语言链表——增删改查
weixin_54859557的博客
03-20 3023
链表是一种数据结构，是一种数据存放的思想
C语言 链表的增删改查
TorchCqs的博客
11-22 1657
题目：利用C或C++语言实现一个长度为N的int型单链表，包括链表的定义、建立、指定位置增减以及长度查询等操作。 #include<stdio.h> #include<stdlib.h> #define N 10 struct Link { int data; struct Link *next; }; int length = 0; // 用来存放链表长度 /** * head: 数据链表 * index: 插入的位置 * data: 插入的数据 **/ str
单链表的增删查改的c语言代码实现
04-20
可以的，以下是单链表的增删查改的c语言代码实现： 单链表的定义： ``` typedef struct Node{ int data; //存放链表的数据 struct Node *next; //指向下一个链表节点的指针 }*LinkedList, Node; ``` 链表节点的插入： ``` LinkedList LinkedListInsert(LinkedList head, int data, int index) { Node* node = (Node*)malloc(sizeof(Node)); node->data = data; node->next = NULL; Node* p = head; int count = 0; while (p->next != NULL && count < index) { p = p->next; count++; } if (count == index) { node->next = p->next; p->next = node; } return head; } ``` 链表节点的删除： ``` LinkedList LinkedListDelete(LinkedList head, int index) { Node* p = head; Node* temp; int count = 0; while (p->next != NULL && count < index) { p = p->next; count++; } if (count == index) { temp = p->next; p->next = temp->next; free(temp); } return head; } ``` 链表节点的查找： ``` int LinkedListSearch(LinkedList head, int data) { Node* p = head; int index = 0; while (p->next != NULL) { if (p->data == data) { return index; } p = p->next; index++; } return -1; } ``` 链表节点的修改： ``` LinkedList LinkedListModify(LinkedList head, int data, int index) { Node* p = head; int count = 0; while (p->next != NULL && count < index) { p = p->next; count++; } if (count == index) { p->data = data; } return head; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值