C语言实现单链表结点添加增删查改清空等操作

最新推荐文章于 2024-06-19 22:05:16 发布
最新推荐文章于 2024-06-19 22:05:16 发布
阅读量3.9k 收藏 25
点赞数 11
文章标签： 数据结构 单链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Simo0n/article/details/119983492
版权

构建一个单链表（没有头结点），链表中存储的是用户输入的整数

一、实现了以下功能：

  1. 链表初始化
  2. 链表判空
  3. 在指定结点之后添加结点
  4. 在指定结点之前添加结点（思路重要）
  5. 删除指定结点p
  6. 结点添加------首添&尾添
  7. 遍历并输出链表
  8. 查找链表的元素------按位序查找(封装起来，在List_Insert和List_DeleteByOrder这两个函数中调用)&按值查找
  9. 删除链表的元素------按值删除&按位删除
  10. 更改链表的指定元素
  11. 在链表的指定位置添加元素
  12. 在链表的指定位置添加元素（引入链表长度pList->size）
  13. 链表的清空

二、亮点：用自己定义的数据结构struct _list表示整个链表

　　　　该结构中存放了一个始终指向头结点的指针head，一个始终指向尾结点的指针tail，一个表示单链表长度的变量size

　　　　指针head和tail给链表的结点添加带来方便，不需要遍历整个链表（函数List_AddOnTail）

　　　　变量size给在链表指定位置添加结点带来方便，可以简化代码（函数List_Insert）

三、存在的问题（放在另一个随笔中）：
在函数List_DeleteByValue中：链表中存在多个相同的元素相邻时，无法全部删除（重点是相邻，相同元素不相邻时均可删除）

只能删除第偶数个位置的元素

解决方法：

  1. 空间：将原来的链表进行拷贝（或者做一个辅助数组），对原来的链表进行判断，对备份链表进行删除操作（数据量太大时不推荐）
  2. 时间：不改动删除算法，用这个算法对这个链表进行多次操作，直到删除完为止
  3. 再加一个指针：prev,使用三指针方法解决

在codeblocks上编译运行，结果如下：

 代码如下：

# include <stdio.h>
# include <stdlib.h>
# include <stdbool.h>
//定义结构体（结点）
typedef struct _node {
    int value;
    struct _node * next;
} Node;

//定义数据结构struct _list表示整个链表
//存放链表的信息：头结点（如果有的话）或首结点、尾结点、链表长度等等
typedef struct _list
{
    Node* head;//始终指向首结点
    Node* tail;//始终指向尾结点
    int size;//表示链表的长度，用在List_Insert函数中，用来判断输入的位置i是否越界，可以简化代码
} List;
//初始化链表
bool InitList(List* pList)
{
    pList->head = pList->tail = NULL;
    pList->size = 0;
    return true;
}
//判空
bool Empty(List* pList)
{
    return (pList->head==NULL);
}

//在指定结点之后添加结点
bool InsertNextNode(Node* p, int elem)
{
    bool sign = true;
    if(p == NULL)
    {
        sign = false;
    }
    Node* s = (Node*)malloc(sizeof(Node));
    if(s == NULL)//内存分配失败
    {
        sign = true;
    }
    s->value = elem;
    s->next = p->next;
    p->next = s;

    return sign;
}
//在指定节点之前添加结点
/*
偷天换日的操作！
    指定结点的前驱结点是未知的，从头结点遍历的话时间复杂度高O(n)
    虽然结点不能交换位置，但是结点中的数据可以交换位置[O(1)]
*/
bool InsertPriorNode(Node* p, int elem)
{
    bool sign = true;
    if(p == NULL)
    {
        sign = false;
    }
    Node* s = (Node*)malloc(sizeof(Node));
    if(s == NULL)
    {
        sign = false;
    }
    //连接
    s->next = p->next;
    p->next = s;
    //下面两个语句是精髓
    s->value = p->value;//将结点p中的元素复制到s中
    p->value = elem;//p中元素替换为elem

    return sign;
}
//删除指定结点p(局限：当该结点是尾结点时，无法完成操作)
bool DeleteNode(Node* p)
{
    bool sign = true;
    if(p == NULL)
    {
        sign = false;
    }
    Node* q = p->next;//q指向p的后继结点
    p->value = p->next->value;//p结点和它的后继结点交换数据
    p->next = q->next;//将q结点删除
    free(q);

    return sign;
}
//结点添加（尾添加）
Node* List_AddOnTail(List* pList, int number)//传入指针的指针
{
    //分配结点空间，并写入p->value
    Node* p = (Node*)malloc(sizeof(Node));
    p->value = number;
    p->next = NULL;
    //head始终指向首结点，tail始终指向尾结点
    //如果链表是空的，最新分配的结点（p）既是head，也是tail
    if(pList->head == NULL)
    {
        pList->head = p;
        pList->tail = p;
    }
    //如果链表不是空的，只需要处理tail
    else
    {
        pList->tail->next = p;//此时链表的尾结点要指向新分配的结点
        pList->tail = p;//新分配的结点成为链表的tail
    }
    pList->size ++;
    pList->tail->next = NULL;//tail里面的指针必须是NULL

/*  //在链表的尾结点之后添加结点，需要循环，
    Node* last = pList->head;
    if(last)
    {
        while(last->next)
        {
            last = last->next;
        }
        //接上去
        last->next = p;
    }
    else
    {
        pList->head = p;
    }
*/
    return pList->head;
}
//结点添加(头添)
Node* List_AddOnHead(List* pList, int n)
{
    Node* p = (Node*)malloc(sizeof(Node));
    p->value = n;
    p->next = NULL;
    if(pList->head == NULL)
    {
        pList->head = p;
        pList->tail = p;
    }
    else
    {
        p->next = pList->head;
        pList->head = p;
    }
    pList->size ++;
    return pList->head;
}
//遍历输出链表
void List_Print(List* pList)
{
    Node* p;
    for(p=pList->head; p; p=p->next)
    {
        printf("%-5d", p->value);
    }
    printf("\n");
}
//查（按位）
Node* List_GetElem(List* pList, int i)
{
    Node* q;
    if(i<1 || i>pList->size)
        q = NULL;
    else
    {
        Node* p = pList->head;
        int j = 1;
        while(j<i)
        {
            p = p->next;
            j++;
        }
        q = p;
    }

    return q;
}
//查（按值）
bool List_Search(List* pList, int number)
{
    bool isFound = false;
    Node* p;
    for(p=pList->head; p; p=p->next)
    {
        if(p->value == number)
        {
            isFound = true;
            break;
        }
    }
    return isFound;
}
//按值删除元素（仅删除第一个）
void List_DeleteByValue(List* pList, int number)
{
    Node* prev;
    Node* p;
    Node* q;
    for(p=pList->head,q=NULL; p; q=p,p=p->next)
    {
        if(number == p->value)
        {
            if(q)
            {
                q->next = p->next;
            }
            else
            {
                pList->head = p->next;
            }
        free(p);
        break;
        }
    }
}
//更改指定元素
void List_Change(List* pList, int a, int b)
{
    Node* p;
    for(p=pList->head; p; p=p->next)
    {
        if(p->value == a)
        {
            p->value = b;
        }
    }
}
//在指定位置添加元素，引入链表长度（pList->size）
bool List_Insert(List* pList, int i, int elem)
{
    bool sign = true;
    if(i<1 || i>pList->size+1)
        sign = false;
    else if(i == 1)
    {
        Node* s = (Node*)malloc(sizeof(Node));
        s->value = elem;
        s->next = pList->head;
        pList->head = s;
    }
    //找到第i-1个结点
    else
    {
        Node* p = List_GetElem(pList, i-1);//封装 找到第i-1个结点,注意这里传入的参数是List*类型
        sign = InsertNextNode(p,elem);//封装 在第i-1个结点之后插入新结点
    }
    return sign;
}
//按位序删除元素
bool List_DeleteByOrder(List* pList, int i, int* elem)
{
    bool sign = true;
    if(i<1 || i>pList->size+1)
        sign = false;
    else if(i == 1)
    {
        Node* p = pList->head;
        pList->head = p->next;
        free(p);
    }
    //找到第i-1个结点
    else
    {
        Node* p = List_GetElem(pList, i-1);//简单的封装  注意这里传入的参数是List*类型
        if(p==NULL || p->next==NULL)//i值越界或者第i-1个结点没有后继结点
        {
            sign = false;
        }
        Node* q = p->next;
        *elem = q->value;
        p->next = q->next;
        free(q);
    }
    return sign;
}
//清除链表
bool List_Clear(List* pList)
{
    Node* p;
    Node* q;
    bool sign = true;
    if(pList->head == NULL)
        sign = false;
    p = pList->head->next;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    pList->head->next = NULL;//注意！！！不能少
    return sign;
}

int main(void)
{
//创建并初始化，输入元素
    List list;
    InitList(&list);
    int number;
    printf("请输入整数（输入-1结束）：\n");
    do
    {
        scanf("%d", &number);
        if(number != -1)
        {
            list.head = List_AddOnTail(&list, number);//注意这里要传入head的地址
            //list.head = List_AddOnHead(&list, number);
        }
    }while(number != -1);
//遍历并输出链表
    printf("链表中的元素为：");
    List_Print(&list);
//查(按值)
    printf("\n请输入您要查找的元素：");
    scanf("%d", &number);
    if(List_Search(&list, number) == true)
    {
        printf("找到了！\n");
    }
    else
    {
        printf("没找到！\n");
    }
//查（按位）
    printf("请输入您要查找的位序：");
    int i, elem;
    scanf("%d", &i);
    if(List_GetElem(&list, i) != NULL)
    {
        printf("找到了！该元素是%d\n", List_GetElem(&list, i)->value);//这个地方的写法有问题吗？
    }
    else
    {
        printf("位序越界！\n");
    }
//删除，按元素值
    printf("\n请输入您要删除的元素：");
    scanf("%d", &number);
    if(List_Search(&list, number) == true)
    {
        List_DeleteByValue(&list, number);
        printf("删除成功！当前链表中的元素为：");
        List_Print(&list);
    }
    else
    {
        printf("删除失败！您要删除的元素不存在！\n");
    }

//更改链表元素
    int a, b;
    printf("\n请输入旧元素：");
    scanf("%d", &a);
    if(List_Search(&list, a))
    {
        printf("请输入新元素：");
        scanf("%d", &b);
        List_Change(&list, a, b);
        printf("更改成功！当前链表元素为：");
        List_Print(&list);
    }
    else
    {
        printf("未找到！\n");
    }
//插入元素
    printf("\n请输入您要插入的位置和数字：");
    scanf("%d%d", &i, &elem);
    if(List_Insert(&list, i, elem))
    {
        printf("插入成功！当前链表元素为：");
        List_Print(&list);
    }
    else
    {
        printf("插入失败！\n");
    }
//按位序删除元素
    printf("\n请输入您要删除的结点的位序：");
    scanf("%d", &i);
    if(List_DeleteByOrder(&list, i, &elem))
    {
        printf("删除成功！删除的元素为:%d\n当前链表元素为：", elem);
        List_Print(&list);
    }
    else
    {
        printf("删除失败！\n");
    }

//链表清除
    if(List_Clear(&list))
    {
        printf("\n链表已清空！\n");
    }
    else
    {
        printf("\n清空失败，链表为空\n");
    }

    return 0;
}

cowboy.J
关注
C语言实现单链表的增删查改
03-25
单链表是数据结构中的基础概念，特别是在C语言...总结起来，C语言实现单链表的增、删、查、改涉及到了结构体、指针、内存管理等核心概念。通过熟练掌握这些操作，可以为后续学习更复杂的数据结构和算法打下坚实的基础。
单向循环链表创建、遍历、插入、删除、查找（按位置，按元素值）、清空、销毁
刘明的博客
06-11 1万+
SinglyLinkedCirculayList.h #include "stdafx.h" #include "iostream" using namespace std; typedef struct LNode { int data; struct LNode *next; }LNode, *LinkedList; //创建链表 bool createLinkedList(Linked
如何在单链表中的任意一个位置插入一个结点
超烦豆先森
10-21 3269
java 实现单链表在任意位置插入一个结点
C学习笔记|单链表的删除操作
最新发布
weixin_50765750的博客
06-19 130
C学习笔记|单链表的删除操作
数据结构学习系列之单向链表的清空与销毁
qq_41878292的博客
09-04 1296
【代码】数据结构学习系列之单向链表的清空与销毁。
数据结构——单链表 创建 清空 插入 删除 查询 输出 完整源码
m0_61628700的博客
02-26 7458
完整代码在最后 一.单链表基本操作 1.初始化 1）创建结构体，储存节点的数据+指针域； 2）创建指向结构体的指针； 3）用结构体定义单链表； 4）初始化链表头节点：为头节点开辟内存； 5）判断内存是否开辟成功； 6）头节点的指针域置空，使链表长度为0。 typedef struct Node//1 { ElemType data; struct Node *next; }Node; typedef struct Node *LinkList;//2 Status Init...
单链表的插入操作（全）
热门推荐
Boyt1317的博客
05-04 2万+
单链表的插入（全） 三种方式进行插入操作
C语言数据结构单链表的增删查改
04-29
C语言数据结构单链表的增删查改
经典c语言实现二叉树，包括增删查改等操作
02-12
经典c语言实现二叉树，包括增删查改等操作
二叉树，数据结构，经典c语言实现，包括增删查改等操作
02-12
数据结构二叉树，数据结构，经典c语言实现，包括增删查改等操作
C语言实现单链表-增删改查.pdf
02-16
本文介绍了单链表的基本概念以及在C语言中如何实现单链表的增删改查等基本操作。通过这些操作，可以有效地管理和操作链表数据。链表作为一种重要的数据结构，在实际开发中有着广泛的应用场景，理解并掌握其基本操作...
单链表相关操作（插入，删除，查找）
weixin_69884785的博客
08-15 1463
单链表的相关操作：插入（带头节点，不带头节点，前插，后插），删除操作（带头节点，不带头节点，用前驱节点删除，用后驱节点删除），查找操作（按值查找，按位查找）
【数据结构】链表
East-sunrise的博客
09-15 751
链表？简简单单 一看就会 一学就起飞
C++单链表创建、增加、删除、查找。
sy_1999的博客
10-03 880
【代码】C++单链表创建、增加、删除、查找。
C语言单向链表看这一个就够了（包含链表的建立、输出、删除、插入、释放附代码和运行结果）
m0_57148596的博客
03-22 2556
今天凌晨接触结构体时，接触了结构体指针，当时感觉并没有什么鸟用，于是我百度了下，发现其是构建链表的一种非常常用的工具。这里其实有个很容易让编程小白容易误解的地方，即搞混结构体指针和结构体中的指针。结构体指针，指的是结构体的变量，而结构体中的指针是在构建结构体时定义的一个成员，这就是它们的最大区别。于是为了更加了解结构体指针的应用场景，我查看单项链表的相关视频直到凌晨4点，终于小有所成，只是头发也跟着少了几根。结尾附运行结果。最后我们尝试对上面5个步骤放进int main（）进行运行吧。//主函数。
单链表中的基本操作(详细代码图解+注释+算法步骤)
Xiao_Ya__的博客
05-23 7685
单链表中的基本操作(详细代码图解+注释+算法步骤)
关于链表的清空（防止内存泄漏）
xxxxxxyao的博客
11-11 4027
  构建链表之后为什么要将链表清空？   链表是用指针把一个个存储的空间连接起来了，用完之后不清空，很容易发生内存泄漏（内存泄漏：向系统申请分配内存进行使用(new)，可是使用完了以后却不delete，而自己出于某些原因不能再访问到那块内存（也许把它的地址给弄丢了），这时候系统也不能再次将它分配给需要的程序。） JVM内存回收    jvm内存结构分为五大区域：程序计数器、虚拟机栈、本地方法...
C语言链表之在指定结点前面或后面插入新的结点
weixin_51976284的博客
04-14 4361
1.我们知道链表无非就是增删改查这几个操作。而在指定结点前方或后方插入结点就是增加的一种体现。 （1）在指定结点后方插入新结点 例子：1->2->3->4->5 当要在3和4之间插入新结点的时候（即在3的后方插入新结点） 步骤：1.先找到3（point->data == data） 2.将3->next（即4的地址）赋给new->next,将新结点new与结点4建立了联系 即：new->next = 3->next; 3.完成上面两步骤后，再执行3-&g
数据结构———单链表基本操作（C++实现）
weixin_51358062的博客
04-19 2104
数据结构———单链表实验（C++实现）** ** 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值