c语言之单链表的基础操作（插入删除查找头插尾插）

最新推荐文章于 2024-05-01 21:35:32 发布
最新推荐文章于 2024-05-01 21:35:32 发布
阅读量329 收藏 10
点赞数 10
文章标签： c语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62642080/article/details/136218659
版权

c语言之单链表的基础操作（插入删除查找头插尾插）

有头结点

#include <stdio.h>
#include <stdlib.h> //malloc函数所需要的
struct Node
{
    // 定义一个结构体
    int data;          // 数据域
    struct Node *next; // 指针：指向node节点的指针，叫next，此处struct意为这是一个结构体，可以省略掉
};
typedef struct Node Node;      // 将结构体Node取了个名字叫做Node
typedef struct Node *Linklist; // 为这个单链表结构取了个名字叫做LinkList

// 初始化一个单链表，因为他有头结点，所以需要为头结点开辟一片空间
bool InitLinkList(Linklist &L)
{
    L = (Node *)malloc(sizeof(Node)); // 为头结点分配空间
    if (L == NULL)
    {
        // 用于检测是否分配成功
        return false;
    }
    L->next = NULL; // 头结点之后暂时还没有节点

    return true;
}

// 判断单链表是否为空
bool Empty(Linklist &L)
{
    return (L->next == NULL);
}

// 按位序插入,在表中L的第i个位置上面插入指定元素e
bool LinkInsert(Linklist &L, int i, int e)
{
    // 找到第i-1个节点，将新节点插入其后面
    Node *p = GetNum(L, e);
    return InsertNextNode(p, e);
}

// 给定节点的后插操作
bool InsertNextNode(Node *p, int e)
{
    if (p == NULL)
    {
        return false;
    }
    Node *s = (Node *)malloc(sizeof(Node));
    if (s == NULL)
    {
        return false; // 内存分配失败
    }
    s->data = e; // 将数据e保存到节点s中
    s->next = p->next;
    p->next = s; // 将节点s连接到p之后
    return true;
}

// 指定节点的前插操作
bool InsertPriorNode(Node *p, int e)
{
    if (p == NULL)
    {
        return false;
    }
    Node *s = (Node *)malloc(sizeof(Node *));
    if (s = NULL)
    {
        return false;
    }
    s->next = p->next;
    p->next = s;       // 新节点s连到p之后
    s->data = p->data; // 将p中的元素复制到s中
    p->data = e;       // p中元素覆盖为e
    return true;
}

// 按位序删除
bool ListDelete(Linklist &L, int i, int &e)
{
    Node *p = GetNum(L, e);
    if (p == NULL) // i值不合法
    {
        return false;
    }
    if (p->next == NULL) // 第i-1个节点之后已经没有节点了
    {
        return false;
    }
    Node *q = q->next; // 让q指向被删除节点
    e = q->data;       // 用e返回节点数据值
    p->next = q->next; // 将*q节点从链中断开
    free(q);           // 释放节点的存储空间
    return true;       // 删除成功
}

// 删除指定节点
bool DeleteNode(Node *p)
{
    // 如果p是最后一个节点，有bug，可能会扣分
    if (p == NULL)
    {
        return false;
    }
    Node *q = p->next;       // 令指针*q指向p的后继指针
    p->data = p->next->data; // 和后继节点交换数据域
    p->next = q->next;       // 将q节点从链中断开
    free(q);                 // 释放后继节点的存储空间
    return true;
}

// 按位查找，返回第i个元素
Node *GetNum(Linklist L, int i)
{
    if (i < 1)
    { // 传入的参数不合法
        return NULL;
    }
    Node *p;                       // 指针p指向当前扫描到的节点
    int j = 0;                     // 当前p指向的第几个节点
    p = L;                         // L指向节点，头结点是第0个节点
    while (p != NULL && j < i - 1) // 循环找到第i个节点
    {
        p = p->next;
        j++;
    }
    return p;
}

// 按值查找
Node *LocatNum(Linklist L, int e)
{
    Node *p = L->next;
    // 从第一个节点开始查找数据域为e的节点
    while (p != NULL && p->data != e)
    {
        p = p->next;
    }
    return p;
}

// 求表的长度
int Length(Linklist L)
{
    int len = 0;
    Node *p = L;
    while (p->next != NULL)
    {
        p = p->next;
        len++;
    }
    return len;
}


//尾插法建立单链表
Linklist List_TailInsert(Linklist &L){
    //正向建立单链表
    int x;
    L=(Linklist)malloc(sizeof(Node));//建立头结点,初始化空表
    Node *s,*r=L;//r为尾指针
    scanf("%d",&x);
    while (x!=9999)//输入9999表示结束
    {
        s=(Node *)malloc(sizeof(Node));
        s->data=x;
        r->data=x;
        r=s;
        scanf("%d",&x);
    }
    r->next=NULL;//尾节点指针置空
    return L;
}

//头插法建立单链表
Linklist List_HeadInsert(Linklist &L){
    //反向建立单链表
    Node *s;
    int x;
    L=(Linklist)malloc(sizeof(Node));//建立头结点
    L->next=NULL;//初始化空表
    scanf("%d",&x);
    while (x!=9999)//输入9999表示结束
    {
        s=(Node *)malloc(sizeof(Node));
        s->data=x;
        s->next=L->next;
        L->next=s;
        scanf("%d",&x);
    }
    return L;
}

void test()
{
    Linklist L; // 创建一个单链表
    InitLinkList(L);
}

无头结点

#include <stdio.h>
#include <stdlib.h> //malloc函数所需要的
struct Node
{
    // 定义一个结构体
    int data;          // 数据域
    struct Node *next; // 指针：指向node节点的指针，叫next，此处struct意为这是一个结构体，可以省略掉
};
typedef struct Node Node;      // 将结构体Node取了个名字叫做Node
typedef struct Node *Linklist; // 为这个单链表结构取了个名字叫做LinkList

// 初始化一个单链表
bool InitLinkList(Linklist &L)
{
    L = NULL;
    // 将其置为空表，防止脏数据
    return true;
}

// 判断单链表是否为空
bool Empty(Linklist &L)
{
    return (L == NULL);
}

// 按位序插入,在表中L的第i个位置上面插入指定元素e
bool LinkInsert(Linklist &L, int i, int e)
{
    // 找到第i-1个节点，将新节点插入其后面
    // 因为不带头结点，所以插入第一个节点的操作与其他节点操作不同
    if (i == 1)
    {
        Node *s = (Node *)malloc(sizeof(Node));
        s->next = NULL;
        s->data = e;
        L = s; // 头指针指向新节点
        return true;
    }
    Node *p = GetNum(L, e);
    return InsertNextNode(p, e);
}

// 给定节点的后插操作
bool InsertNextNode(Node *p, int e)
{
    if (p == NULL)
    {
        return false;
    }
    Node *s = (Node *)malloc(sizeof(Node));
    if (s == NULL)
    {
        return false; // 内存分配失败
    }
    s->data = e; // 将数据e保存到节点s中
    s->next = p->next;
    p->next = s; // 将节点s连接到p之后
    return true;
}

// 指定节点的前插操作
bool InsertPriorNode(Node *p, int e)
{
    if (p == NULL)
    {
        return false;
    }
    Node *s = (Node *)malloc(sizeof(Node *));
    if (s = NULL)
    {
        return false;
    }
    s->next = p->next;
    p->next = s;       // 新节点s连到p之后
    s->data = p->data; // 将p中的元素复制到s中
    p->data = e;       // p中元素覆盖为e
    return true;
}

// 按位序删除
bool ListDelete(Linklist &L, int i, int &e)
{

    if (L == NULL)
    {
        return false;
    }
    if (i = 1)
    {
        e = L->data;
        Node *a = L;
        L = L->next;
        free(a);
        return true;
    }
    Node *p = GetNum(L, e); // 指针p指向当前扫描到的节点
    if (p == NULL)          // i值不合法
    {
        return false;
    }
    if (p->next == NULL) // 第i-1个节点之后已经没有节点了
    {
        return false;
    }
    Node *q = q->next; // 让q指向被删除节点
    e = q->data;       // 用e返回节点数据值
    p->next = q->next; // 将*q节点从链中断开
    free(q);           // 释放节点的存储空间
    return true;       // 删除成功
}

// 删除指定节点
bool DeleteNode(Node *p)
{
    // 如果p是最后一个节点，有bug，可能会扣分
    if (p == NULL)
    {
        return false;
    }
    Node *q = p->next;       // 令指针*q指向p的后继指针
    p->data = p->next->data; // 和后继节点交换数据域
    p->next = q->next;       // 将q节点从链中断开
    free(q);                 // 释放后继节点的存储空间
    return true;
}

// 按位查找，返回第i个元素
Node *GetNum(Linklist L, int i)
{
    Node *p;                       // 指针p指向当前扫描到的节点
    int j = 1;                     // 当前p指向的第几个节点
    p = L;                         // L指向节点，头结点是第0个节点
    while (p != NULL && j < i - 1) // 循环找到第i个节点
    {
        p = p->next;
        j++;
    }
    return p;
}

// 按值查找
Node *LocatNum(Linklist L, int e)
{
    Node *p = L->next;
    // 从第一个节点开始查找数据域为e的节点
    while (p != NULL && p->data != e)
    {
        p = p->next;
    }
    return p;
}

// 求表的长度
int Length(Linklist L)
{
    int len = 0;
    Node *p = L;
    while (p->next != NULL)
    {
        p = p->next;
        len++;
    }
    return len + 1;
}

// 头插法插入节点
bool HeadInsert(Linklist &L, int e)
{
    Node *s = (Node *)malloc(sizeof(Node));
    if (s == NULL)
    {
        return false; // 内存分配失败
    }
    s->data = e;
    s->next = L; // 将新节点s插入到链表头部
    L = s;       // 更新链表头指针
    return true;
}

// 尾插法插入节点
bool TailInsert(Linklist &L, int e)
{
    Node *s = (Node *)malloc(sizeof(Node));
    if (s == NULL)
    {
        return false; // 内存分配失败
    }
    s->data = e;
    s->next = NULL; // 尾部插入新节点时，将其next指针置空
    if (L == NULL)
    {
        L = s; // 空链表时直接将新节点作为头节点
    }
    else
    {
        Node *p = L;
        while (p->next != NULL)
        {
            p = p->next; // 找到尾节点
        }
        p->next = s; // 将新节点连接到尾节点后
    }
    return true;
}

void test()
{
    Linklist L; // 创建一个单链表
    InitLinkList(L);
}
世染尘光166
关注
  • 10
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构——基于C语言实现单链表的应用.rar
08-11
//初始化表 //头插法添加结点 // 尾插法添加结点 //查找的函数（按序号查找） //根据长度输出单链表的数据 // 插入一个新的结点 //单链表的删除操作
c语言单链表_C语言实现单链表的头插、尾插、删除、插入、查询操作
weixin_39965490的博客
11-23 138
效果图编译工具：代码：#pragma clang diagnostic push#pragma ide diagnostic ignored "cert-err34-c"/********************************************* * 单链表的实现 ********************************************/#include #incl...
【C语言】单链表建立、插入删除操作
qq_43782985的博客
06-13 5066
C语言-单链表
C语言之单链表操作之插入
Arvin_success的博客
09-10 3100
2、插入（后插） 假设在一个单链表中存在2个连续结点p、q（其中p为q的直接前驱），若我们需要在p、q之间插入一个新结点s，那么我们必须先为s分配空间并赋值，然后使p的链域存储s的地址，s的链域存储q的地址即可。(p->link=s;s->link=q)，这样就完成了插入操作。 下例是应用插入算法的一个例子： #include #include #include #define
C语言实现单链表的头插、尾插、删除、插入、查询操作
08-26 957
效果图 编译工具： 代码： #pragma clang diagnostic push #pragma ide diagnostic ignored "cert-err34-c" /********************************************* * 单链表的实现 **************************************...
用C语言创建单链表并实现插入、删除等简单操作
HXZ_CREATE的博客
06-08 5342
单链表比起顺序表来说存储更灵活，在需要进行频繁的插入或删除操作的情况下，使用单链表来操作更加简单。但是在需要查找元素，计算链表长度时又会显得比较麻烦。选择顺序表还是单链表是要依情况而定。 创建单链表（头插法）： 头插法：始终让每个新结点放在链表中第一个位置，这样导致的结果是：当我们对链表进行遍历时，先遍历的是最后加入链表的结点。（下面给出的代码先不给新结点的数据域赋值，尾插法也是） void CreateListHead( LinkList *L , int length ) { int i ;
C语言单链表——头/尾插法，逆置，合并，排序，删除等操作
m0_74556076的博客
10-08 580
【源码】C语言单链表——头/尾插法，逆置，合并，排序，删除等操作。
C语言实现单链表的基本操作
weixin_46625488的博客
07-31 8762
王道c语言版数据结构--实现单链表的基本操作
单链表的创建，插入，删除以及查找
热门推荐
Lookdrama的博客
10-22 3万+
链表是一种物理存储单元上非连续、非顺序的存储结构，由一系列结点组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。提示：这里对文章进行总结：例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
C语言数据结构 单链表的建立、遍历、查找、插入和删除操作
追求。
04-26 1万+
链表（Linked List）是一种物理存储单元上非连续、非顺序的数据结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（node，链表中每一个元素称为结点）组成，每一次为一个结构体 动态分配的内存空间，可称之为一个结点，每个结点之间可以是不连续的，但结点内是连续的。结点个数是不受限定的，可以随时删改，这是与数组相比的优点。.........
C语言 数据结构之单链表基本操作
10-05
6. 头插、头删、尾插、尾删 7. 按照顺序插入(自带排序) 8. 按照位置插入数据 9. 按照数据修改数据 10. 按照节点位置查找数据 11. 判断某个值是否在当前链表中（按数据查找数据） 12. 面试中常见：单链表翻转 13. ...
单链表的基本操作.cpp
04-09
实现单链表的基本操作：头插法建立单链表、尾插法建立单链表、查找指定位置上的元素值、查找指定元素的位置、插入若干元素、删除若干元素、合并两个单链表、求两个合集的差、求单链表长度、逆置单链表、访问单链表各...
电话号码管理项目功能包括简易菜单、单链表、包括增删改查等基本操作 链表插入采用尾插法
03-05
该项目通常会涉及一些常见的功能，例如添加、查找、修改和删除联系人，显示所有联系人的信息以及释放内存等。 在此项目中，需要使用链表数据结构来存储联系人的信息。每个联系人都是链表的一个节点，包含姓名、电话...
数据结构单链表（C语言）
03-27
通过c语言实现单链表的建立、初始化、尾插法插入结点、头插法插入结点、数据的查找、删除、在指定位置插入结点、在指定位置删除结点、打印输出数据、统计单链表的长度等功能。
C语言（操作符）2
2301_78843337的博客
05-01 1321
操作符详解2.0
【C语言视角】数据结构之~二叉树
循环渐进学习编程，成长
05-01 1188
设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。第一层是根结点，只有一个，所以2(1-1）=20=1。终端结点数其实就是叶子结点数，而一棵二叉树，除了叶子结点外，剩下的就是度为1或2的结点数了，我们设n1为度是1的结点数。终端结点数其实就是叶子结点数，而一棵二叉树，除了叶子结点外，剩下的就是度为1或2的结点数了，我们设n1为度是1的结点数。
redis核心数据结构——跳表项目设计与实现（跳表结构插入数据、删除数据、展示数据）
qq_63149342的博客
05-01 519
另外就是每次创建新节点时需要随机分配层数，加上一开始用两个变量分别记录最大层数和当前层数，分配后该层数不能超过最大层数，且如果大于当前层数，需要将当前层数进行更新。向跳表中插入一对数据，如果跳表中已存在该键值对，则不做任何操作，返回 1，如果不存在该键值对，则将该键值对插入到跳表中，返回 0。此成员函数需要从跳表中删除键为 key 的节点。在跳表中查询键值为 key 的键值对，如果跳表中已存在该键值对，则返回 true，否则返回 false。参数说明： K key：要删除的元素的键，其中 K 是键的类型。
【数据结构】链表专题2
最新发布
m0_74091744的博客
05-01 1300
前言本篇博客继续探讨有关链表的专题，这片博客的题，提前打个预防针，有点意思哦，哈哈哈，话不多说，进入正文若有问题 评论区见📝。
用c语言尾插法创建单链表并实现删除，插入，查找
03-21
这段代码使用了尾插法创建单链表，实现了插入、删除、查找操作。其中，createList 函数用于创建一个空链表，insert 函数用于在链表尾部插入一个节点，delete 函数用于删除链表中第一个值为 data 的节点，search 函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值