单向链表详解

最新推荐文章于 2024-04-14 14:54:09 发布
最新推荐文章于 2024-04-14 14:54:09 发布
阅读量1.5k 收藏 7
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZEROJOKEROOO/article/details/81384453
版权

#include<stdio.h>
#include<stdlib.h>
#define T 1
#define F 0

typedef int Elementtype;    //重命名int为Elementtype
typedef int Status;               //重命名int为Status，作为函数的返回类型

struct Node                            //建立链表的结构体
{
    Elementtype value;         //链表中节点的数据域可以为各种类型（在此以整形数来代替）
    struct Node *next;          //链表中节点的指针区域
};

Status init(struct Node **p);  //初始化头结点

Status print(struct Node *p);     //将链表输出

Status lenth(struct Node *p);    //计算链表的长度（在此程序中定义链表的第一个可用节点为0号位，和数组下标一样）

Status insert_head(struct Node *p, Elementtype value);  //头插,新来的节点接到头结点的后面

Status insert_tail(struct Node *p, Elementtype value);     //尾插,新来的节点接到链表NULL之前

Status insert_index(struct Node *p, int index, Elementtype value); //中间插，新来的节点放在下标index处

Status delete_index(struct Node *p, int index);                   //删除，将下标index处的节点删除（用free释放）

Status delete_value(struct Node *p, Elementtype value);//删除，将数据域为value的节点删除

Status update_index(struct Node *p, int index, Elementtype value);                               //修改数据，将下标index处改为value

Status update_value(struct Node *p, Elementtype old_value, Elementtype new_value); //修改数据,将老的数据old_value改为new_value

Status query_value(struct Node *p, Elementtype value);//查找value所处的下标

Status query_index(struct Node *p,int index); //查找下标index的数据（value）

Status empty(struct Node *p); //清空链表

Status destroy(struct Node **p);//销毁整个链表（释放头结点）

int main()
{
    struct Node *head = NULL;           //定义头结点
    init(&head);                                        //初始化头结点
    int i = 0;                                               //定义i用于循环
    
    for(i = 0; i < 20; i++)
    {
        insert_head(head, i+1);  //头插，i+1是为了从1开始插入数据；
        insert_tail(head, i+1);      //尾插
    }
    
    print(head);
    
    delete_index(head, 2);
    print(head);
    
    insert_index(head, 2, 99);
    print(head);
    
    delete_value(head, 1);
    print(head);
    
    update_index(head, 2, 88);
    print(head);
    
    update_value(head, 3, 66);
    print(head);
    
    query_value(head, 8);
    
    query_index(head,17);
    
    empty(head);
    print(head);
    
    destroy(&head);
    print(head);
    
    return 0;
}

Status init(struct Node **p)         //**p的原因是为了能改变头指针head的地址，head为struct Node *型，所以指向其地址的指针为 struct Node **型（当然，此函数可以将函数的返回值设为struct Node *型，将创建的头结点通过函数返回）                
{
    struct Node *newnode = (struct Node *)malloc(sizeof(struct Node));  //用malloc申请类型为struct Node *大小为struct Node（如果写成struct Node*就为地址的大小，不是结构体的大小）的堆空间
    if(NULL == newnode)
    {
        return F; //空间申请不成功，返回fault
    }
    
    newnode->next = NULL;  //头结点初始化
    newnode->value = 0; 
    *p = newnode;          //将newnode的地址赋给*p（head的地址此时也为newnode）
}

Status print(struct Node *p) 
{
    if(p == NULL)                //如头指针为空则说明无此链表
    {
        printf("无此链表\n");
        return F;
    }
    
    if(p->next == NULL)          //如果头指针的下一个节点为空则说明有链表但链表无数据
    {
        printf("链表为空\n");
        return F;
    }
    
    while(p->next != NULL)            //当p->next不为空
    {
        printf("%4d",p->next->value); //输出p->next的数据域
        p = p->next;                                  //移动到下一个节点处，达到循环的目的
    }
    printf("\n");
    
    return T;
}

Status insert_head(struct Node *p, Elementtype value)              //头插，（需要知道头结点的地址，以及所插入的数据内容）
{
    struct Node * new = (struct Node *)malloc(sizeof(struct Node)); //用malloc申请一个节点所需的空间
    if(NULL == new)                                                                                         //申请的空间为NULL则说明申请不成功
    {
        return F;
    }
    
    new->next = NULL;                                               //初始化新节点的指针域
    new->value = value;                                             //将所要的数据给新节点的数据域
    
    new->next = p->next;                                            //头插时先将新节点的指针域指向头结点的下一个节点
    p->next = new;                                                  //再将头结点的指针域指向新节点（这样不会出错，如果操作步骤返了会将头结点的下一个指针域覆盖，从而使链表断开）
    
    return T;
}

Status insert_tail(struct Node *p, Elementtype value)                //尾插，（需要知道头结点的地址，以及所插入的数据内容）
{
    struct Node *new = (struct Node *)malloc(sizeof(struct Node));   //用malloc申请一个节点所需的空间
    if(NULL == new)                                                  //申请的空间为NULL则说明申请不成功
    {
        return F;
    }
    
    new->next = NULL;                                                 //初始化新节点的指针域
    new->value = value;                                               //将所要的数据给新节点的数据域
    
    while(NULL != p->next)                                            //遍历找到链表的结尾
    {
        p = p->next;                                                  
    }
    
    p->next = new;                                                    //将新节点放在尾部
    
}

Status insert_index(struct Node *p, int index, Elementtype value)     //中间插，（需要知道头结点的地址，所插入的位置，以及数据内容）  
{
    int i = 0;                                                        //用于循环
    
    struct Node *new = (struct Node *)malloc(sizeof(struct Node));    //用malloc申请一个节点所需的空间
    new->next = NULL;
    new->value = value;
    
    if(index < 0 || index > lenth(p) - 1)                             //判断所设定的index在不在可操作范围内
    {
        printf("index error/n");                                      
        return F;
    }
    
    for(i = 0; i < index; i++)                                        //找到要插入的位置
    {
        p = p->next;
    }
    
    new->next = p->next;                                              //将新节点插入到index的位置上
    p->next = new;
    
    return T;
}

Status lenth(struct Node *p)                                          //判断链表的长度
{
    int len = 0;                                                                   //定义一个长度
    while(NULL != p->next)                                            //遍历，记录长度
    {
        len++;
        p = p->next;
    }
    return len;                                                       //将所得的长度返回
}

Status delete_index(struct Node *p, int index)                        //按位置删除
{
    int len = 0;                                                           
    int i = 0;
    struct Node * temp = NULL;
    
    len = lenth(p);
    if(index < 0 || index > len-1)
    {
        printf("index error\n");
        return F;
    }
    
    for(i = 0; i < index; i++)                                         //找到要删除的位置
    {
        p = p->next;
    }
    
    temp = p->next;                                                    //将删除处的前后两个节点连接
    p->next = temp->next;                                              
    free(temp);                                                            //将删除的节点释放
    temp = NULL;                                                       //将temp指向空，防止野指针

    return T;
}

Status delete_value(struct Node *p, Elementtype value)                 //按值删除
{
    int flag = 0;                                                      //定义flag判断是否找到值
    struct Node * temp = NULL;
    while(NULL != p->next)                                             //遍历找值
    {
        if(p->next->value == value)
        {
            temp = p->next;
            p->next = temp->next;
            free(temp);
            temp = NULL;
            flag = 1;                                                  //将值删除后，flag = 1；
        }
        else
        {
            p = p->next;
        }
    }
    
    if(flag == 0)                                                      //如果flag等于0说明没找到值
    {
        printf("未找到value\n");
    }
    
    return T;
}

Status update_index(struct Node *p, int index, Elementtype value)      //按位置修改
{
    int i = 0;
    
    if(index < 0 || index > lenth(p)-1)
    {
        printf("index error\n");
        return F;
    }
    
    for(i = 0; i < index; i++)                                         //找到要修改的位置
    {
        p = p->next;
    }
    
    p->next->value = value;                                            //新值给旧值
    
    return T;
    
}

Status update_value(struct Node *p, Elementtype old_value, Elementtype new_value)  //按值删除
{
    while(NULL != p->next)                                                         //遍历找值
    {
        if(p->next->value == old_value)
        {
            p->next->value = new_value;                                            //修改
        }
        
        p = p->next;                                                               
    }
    return T;
}

Status query_value(struct Node *p, Elementtype value)                              //通过值查位置
{
    int data = 0;                                                                  //记录位置
    
    while(NULL != p->next)                                                         //遍历
    {
        if(p->next->value == value)
        {
            printf("%d addr is %d\n",value,data);
        }
        p = p->next;
        data++;
    }
    printf("\n");
    return T;
}

Status query_index(struct Node *p,int index)                                      //通过位置查找值
{
    int i = 0;
    
    if(index < 0 || index > lenth(p) - 1)
    {
        printf("index error\n");
        return F;
    }
    
    for(i = 0; i < index; i++)                                                    //找位置
    {
        p = p->next;
    }
    
    printf("addr%d value is %d\n",index,p->next->value);
    
    return T;
    
}

Status empty(struct Node *p)                                                      //清空
{
    struct Node * temp = NULL;
    while(p->next != NULL)                                                        //遍历删除
    {
        temp = p->next;
        p->next = temp->next;
        free(temp);
        temp = NULL;
    }
    
    return T;
}

Status destroy(struct Node **p)                                                   //销毁
{
    struct Node * temp = NULL;                                                    
    while((*p)->next != NULL)                                                     //遍历删除   
    {
        temp = (*p)->next;
        (*p)->next = temp->next;
        free(temp);
        temp = NULL;
    }
    free(*p);                                                                      //释放头结点
    *p = NULL;
    return T;
}

ZEROJOKEROOO
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
初学链表———单向链表创建
qq_44001832的博客
11-09 1920
初学链表之单向链表创建 链表是由一个个节点构成的，而每一个节点都可以看成两个部分组成，分别是数据域和指针域，链表是由不是连续的地址空间组成的非线性存储结构，字面意思，他们不是一个连串的地址空间，那么我们想让他们能被顺序访问，就得用指针来分别访问他们的地址空间，这就是指针域的功能 创建结构体类型 在这里v插入代码片v ...
C语言之单向链表详解及实例代码
12-31
1，单向链简洁。...根据示例代码中的例子，完成单向链表(single linked list)中的以字符串为数据的链表的插入、删除以及查找，并支持单向链表的反转； 3，代码实现。 #include #include <math.h>
数据结构之单链表非常详细介绍(适合小白）
m0_74438843的博客
08-22 4923
数据结构深度学习之单链表非常详解解读~~~一万多字详解
链表详解（易懂）
热门推荐
SlimShadyKe的博客
04-24 6万+
链表是一系列的存储数据元素的单元通过指针串接起来形成的，因此每个单元至少有两个域，一个域用于数据元素的存储，另一个或两个域是指向其他单元的指针。这里具有一个数据域和多个指针域的存储单元通常称为节点（node）。 链表的第一个节点和最后一个节点，分别称为链表的头节点和尾节点。尾节点的特征是其 next 引用为空（null）。链表中每个节点的 next 引用都相当于一个指针，指向另一个节点，借助这些...
数据结构-链表-单向链表-01.链表介绍
最新发布
weixin_43501701的博客
04-14 739
1. **头节点的指针需要进行插入和删除操作：** 在单向链表中，插入和删除节点时通常需要更新头节点指针，特别是在头部插入或删除节点时。例如，使用单向链表实现的栈和队列具有动态大小和高效的插入和删除操作。3. **不进行插入和删除操作：** 如果链表的头节点在整个链表的生命周期内都不会发生改变，而且不会执行插入和删除操作，那么可以在栈或静态存储区中分配内存空间给头节点指针。2. **插入和删除操作高效：** 在单向链表中，插入和删除节点的操作效率很高，因为只需要修改相邻节点的指针，而不需要移动其他节点。
链表超细详解
weixin_73604097的博客
02-08 816
本次详细讲解了链表的使用，希望对大家有所帮助
单向链表简介
qq_51086925的博客
06-22 3540
一、单想链表的特征 单向链表是利用动态内存分布、使用结构体并配合指针来实现的一种数据结构。相比于数组，单向链表进行数据插入和删除的操作更为简单，但是，调取链表中的元素，只能一个个去访问寻找，不能直接通过位置，一步得到。 二、实现单向链表的基础 struct student { int score; char num[100]; struct student *next;/*通过这个可以指向结构体的指针，可以将多个结构体像是锁链一样连起来 例如：p1->p2->...
python实现单向链表详解
09-20
【Python实现单向链表详解】 链表是一种重要的数据结构，它不同于数组，不需预先定义大小，可以动态地增删元素。链表中的每个元素称为“节点”，每个节点包含数据域（存储数据）和指针域（指向下一个节点）。在...
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
单向动态链表
m0_74133525的博客
01-16 89
用c语言实现单向动态链表，动态内存分配，头文件
四种创建单链表的方法
兔子王
09-23 1万+
学习了这么久的数据结构，终于把链表吃透啦，下面是我整理的四种创建单链表的的方法，以及一些非常容易犯的错误，让我们一起来看看吧~
详细介绍如何写一个单向链表
A_lid的博客
07-31 523
有头单向链表，创建，插入，删除，查询，转置，清空，销毁。
自己动手写一个简单的单向链表结构
凉拌糖醋鱼
07-11 397
自己动手写一个简单的单向链表结构 链表结构，是一个相对比较复杂的结构，不过也不难理解。尤其是我们在学习了Java中的数据类型之后，了解了除了基本的数据类型，其他的数据类型都是引用数据类型，也就是说，引用了它们的地址值。 关于链表结构，它的特点是插入删除特别的方便，但是查询就会比较麻烦，因为单向链表只在头结点保存了对下一个结点的引用，如果你要查询链表中某个元素的数据，那么就得从头结点开始遍历整个链表，可以说是相当慢了。但是插入元素结点是很方便的，只需要将要查如位置的前一个元素结点的指针域指向要插入元素结点，再
C语言单向链表的实现
无界编程
10-30 5万+
一个简单结点的结构体表示为：    struct note    {       int  data；              /*数据成员可以是多个不同类型的数据*/       struct  note  *next；      /*指针变量成员只能是-个*/    }；  一个简单的单向链表的图示 1．链表是结构、指针相结合的-种应用,它是由头、中间、尾多个链环组成的单方向可伸缩的链表,链
单向循环链表 初始化 合并
blacop的博客
02-24 927
#include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR -1 #define TRUE 1 #define FALSE -1 #define NULL 0 #define OVERFLOW -2 #define ElemType int #define Status int typedef int ElemType type
单链表的基本操作(初始化，插入，删除等）
Mr_zhou..的博客
09-01 8399
单链表：单链表是线性表链式存储的一种形式，其中的结点一般含有两个域，一个是存放数据信息的数据域(Data)，另一个是指向该结点的后继结点存放地址的指针域(Next)，一个单链表必须有一个首指针指向单链表中的第一个结点。 单链表的结构如下所示： typedef int DataType; typedef struct Node {     DataType data;  //存放数据信息的数...
单向链表的基本概念
weixin_42048463的博客
05-17 166
1. 在结构体的定义中声明结构体指针变量: [注]在上面的定义中, 编译器不知道temp类型的变量占用多少内存空间(在定义pt时, temp类型还未完成定义), 所以无法为其分配存储空间. 在下面的定义中, 指针变量在内存中所占用的空间是确定的, 即便编译器并不知道temp类型为何物, 也可以为其分配存储空间. 2. 单向链表中的结点: 3. 单向链表实现思想简介: 4. 建立一个单向链表: ...
单链表的讲解：单链表的原理，添加、删除元素
wyqwilliam的博客
09-16 3万+
单链表及其节点 链表是一系列的存储数据元素的单元通过指针串接起来形成的，因此每个单元至少有两个域， 一个域用于数据元素的存储，另一个域是指向其他单元的指针。 这里具有一个数据域和多个指针域的存储单元通常称为 结点（node） 一种最简单的结点结构如图所示，它是构成单链表的基本结点结构。在结点中数据域用来存储数据元素， 指针域用于指向下一个具有相同结构的结点。 因为只有一个指针结点，称为单链表 ...
单向链表的建立
zhquanquan的博客
01-23 1025
（1）链表节点的数据结构定义 struct Node { int num; struct Node *next; } struct 关键字能定义各种类型的变量集合,称为结构(structure),并把它们视为一个单元。在链表节点的定义中，除一个整型的成员外，成员p是指向与节点类型完全相同的指针。在链表节点的数据结构中，非常特殊的一点就是结构体内的指针域的数据类型使用了未定义成功的数
C语言链表详解.ppt
11-15
C语言链表详解涵盖的知识点包括：链表的概念、单向链表的结构与操作、自定义结点、指针在链表中的作用、以及如何使用链表进行数据管理。掌握这些概念对于编写高效、灵活的C语言程序至关重要，特别是那些需要频繁添加...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值