C语言单向链表代码示例（含详细注释）

最新推荐文章于 2021-09-04 17:29:19 发布
最新推荐文章于 2021-09-04 17:29:19 发布
阅读量379 收藏 2
点赞数 2
文章标签： c语言 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42905453/article/details/114441131
版权

C语言单向链表代码示例

node.c

#include "node.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "student.h"
node_t *node_creat()
{
    node_t *head = malloc(sizeof(node_t));
    if (head == NULL)
    {
        return NULL;
    }
    head->data = NULL;
    head->next = NULL;
    return head;
}
int node_inser_head(node_t *head,const void * data,int size)
{
    if (head == NULL || head->data != NULL || data == NULL || size <= 0)
    {
        return -1;
    }
    node_t *temp_head = head;
    //建立新节点
    node_t *temp_node_new = malloc(sizeof(node_t)); //申请一块新的空间用来存放该节点的两个地址:*next和*data
    if (temp_node_new == NULL)
    {
        printf("空间申请失败！\n");
        return -1;
    }
    temp_node_new->data = malloc(size); //再申请一块新的空间用来存放数据，返回地址存放在该新节点的*data中
    if (temp_node_new->data == NULL)
    {
        free(temp_node_new); //如果数据域申请失败，则释放新节点的地址空间
        return -1;
    }
    //写入数据
    memcpy(temp_node_new->data, data, size);
    //链接
    temp_node_new->next=temp_head->next;
    temp_head->next=temp_node_new;
    return 0;
}

int node_inser_end(node_t *head, const void *data, int size)
{
    if (head == NULL || head->data != NULL || data == NULL || size <= 0)
    {
        return -1;
    }
    node_t *temp_head = head;
    while (temp_head->next != NULL) //找出尾部节点
    {
        temp_head = temp_head->next;
    }
    //建立新节点
    node_t *temp_node_new = malloc(sizeof(node_t)); //申请一块新的空间用来存放该节点的两个地址:*next和*data
    if (temp_node_new == NULL)
    {
        printf("空间申请失败！\n");
        return -1;
    }
    temp_node_new->data = malloc(size); //再申请一块新的空间用来存放数据，返回地址存放在该新节点的*data中
    if (temp_node_new->data == NULL)
    {
        free(temp_node_new); //如果数据域申请失败，则释放新节点的地址空间
        return -1;
    }
    //写入数据
    memcpy(temp_node_new->data, data, size);
    //链接
    temp_head->next = temp_node_new;
    temp_node_new->next = NULL;
    return 0;
}
int node_inser_node(node_t *node,const void * data,int size)
{
    if (node == NULL || data == NULL || size <= 0)
    {
        return -1;
    }
    node_t *temp_node = node;
    //建立新节点
    node_t *temp_node_new = malloc(sizeof(node_t)); //申请一块新的空间用来存放该节点的两个地址:*next和*data
    if (temp_node_new == NULL)
    {
        printf("空间申请失败！\n");
        return -1;
    }
    temp_node_new->data = malloc(size); //再申请一块新的空间用来存放数据，返回地址存放在该新节点的*data中
    if (temp_node_new->data == NULL)
    {
        free(temp_node_new); //如果数据域申请失败，则释放新节点的地址空间
        return -1;
    }
    //写入数据
    memcpy(temp_node_new->data, data, size);
    //链接
    temp_node_new->next=temp_node->next;
    temp_node->next=temp_node_new;
    return 0;
}
void node_foreach(node_t *head, void (*Show)(void *))
{
    if (head == NULL)
    {
        return;
    }
    node_t *temp_head = head;
    while (temp_head != NULL) //遍历直到尾节点
    {
        if (temp_head->data != NULL) //判断数据域是否为空值
        {
            Show(temp_head->data);
        }
        temp_head = temp_head->next; //递进一个节点
    }
}

void node_free(node_t **head)
{
    node_t *temp_head = *head;
    node_t *temp_next = NULL;
    while (temp_head != NULL) //遍历节点
    {
        temp_next = temp_head->next; //备份
        if (temp_head->data != NULL)
        {
            free(temp_head->data); //释放数据域空间
            free(temp_head);       //释放节点地址空间
        }
        temp_head = temp_next; //获取下个节点的地址
    }
    free(*head);
    *head = NULL;
}

node_t *node_find(node_t *head, const void *data, int mode, int (*cmp)(const void *, const void *, int))
{
    if (head == NULL || head->data != NULL || data == NULL || mode <= 0)
    {
        return NULL;
    }
    node_t *temp_head = head; //备份
    while (temp_head != NULL) //遍历节点
    {
        if (temp_head->data != NULL)
        {
            if (cmp(temp_head->data, data, mode) == 0) //如果找到了
            {
                return temp_head; //返回目标节点
            }
        }

        temp_head = temp_head->next;
    }
    return NULL; //没找到返回NULL节点
}

int node_updata(node_t *node, const void *data, int mode, int (*updata)(void *, const void *, const int))
{
    if (node == NULL || data == NULL || node->data == NULL || mode <= 0)
    {
        return -1;
    }
    node_t *temp_node = node;
    if (updata(temp_node->data, data, mode) == 0)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

int node_delete(node_t *head, node_t *node)
{
    if (node == NULL || head->data != NULL || head->next == NULL)
    {
        return -1;
    }
    node_t *temp_head = head;
    while (temp_head != node) //从头节点开始找node
    {
        if (temp_head->next == node) //如果该节点的下一个节点是目标节点
        {
            temp_head->next = node->next; //链接
            free(node->data);             //释放数据域
            free(node);                   //释放指针域
            return 0;
        }
        temp_head = temp_head->next; //递进
    }

    return 1;
}

node.h

#ifndef NODE_H
#define NODE_H

typedef struct Node
{
    void *data;
    struct  Node *next;    
}node_t;


/*************
 * 函数名：node_creat
 * 功能：创建一个头节点
 * 参数：无
 * 返回值：头节点地址
 * **********/
node_t *node_creat();
/*************
 * 函数名：node_inser_end
 * 功能：尾插一组结构体数据(即在链表尾部插入)
 * 参数：
 *      head:头节点地址
 *      data:需要插入的数据
 *      size:数据大小
 * 返回值：成功返回0，失败返回非0
 * **********/
int node_inser_end(node_t *head,const void * data,int size);
/*************
 * 函数名：node_inser_head
 * 功能：头插一组结构体数据(即在head后的一个节点处插入)
 * 参数：
 *      head:头节点地址
 *      data:需要插入的数据
 *      size:数据大小
 * 返回值：成功返回0，失败返回非0
 * **********/
int node_inser_head(node_t *head,const void * data,int size);
/*************
 * 函数名：node_inser_node
 * 功能：任意节点插入一组结构体数据
 * 参数：
 *      node:节点地址
 *      data:需要插入的数据
 *      size:数据大小
 * 返回值：成功返回0，失败返回非0
 * **********/
int node_inser_node(node_t *node,const void * data,int size);
/*************
 * 函数名：node_foreach
 * 功能：遍历链表
 * 参数：
 *      head:头节点地址
 *      void(*Show)(void *):链表显示回调函数
 * 返回值：无
 * **********/
void node_foreach(node_t *head,void(*Show)(void *));
/*************
 * 函数名：node_free
 * 功能：清空该链表并释放所有的内存空间
 * 参数：
 *      head:头节点的地址&head
 * 返回值：无
 * **********/
void node_free(node_t **head);
/*************
 * 函数名：node_free
 * 功能：找到目标节点的地址
 * 参数：
 *      head:头节点的地址&head
 *      data:索引值
 *      mode:索引模式
 *      cmp:索引回调函数
 * 返回值：目标节点的地址
 * **********/
node_t *node_find(node_t *head,const void *data,int mode,int (*cmp)(const void *,const void *,int));
/*************
 * 函数名：node_updata
 * 功能：改变链表中某一个节点的某个数据元素
 * 参数：
 *      node:目标节点地址
 *      data:修改的数据源
 *      mode:更新模式
 *      updata:数据更新的回调函数
 * 返回值：成功返回0,失败返回非0
 * **********/
int node_updata(node_t *node,const void *data,int mode,int (*updata)(void *,const void *,const int));
/*************
 * 函数名：node_delete
 * 功能：删除目标节点
 * 参数：
 *      head:头节点地址
 *      node:目标节点地址
 * 返回值：成功返回0,失败返回非0
 * **********/
int node_delete( node_t *head,node_t *node);

#endif

student.c

#include "student.h"
#include <stdio.h>
#include <string.h>
void student_Print(void *data)
{
    student_t *v = data;
    printf("姓名：%s\t年龄：%d\t身高：%d\t\n", v->name, v->age, v->high);
}

int student_Cmp(const void *data_1, const void *data_2, const int mode)
{
    const student_t *v = data_1;
    const int *num2 = data_2;
    switch (mode)
    {
    case 1: //比较姓名
        return strcmp(v->name, data_2);
    case 2: //比较年龄
        return (*v).age - (*num2);
    case 3: //比较身高
        return (*v).high - (*num2);
    case 4: //比较全部
        return memcmp(v, data_2, sizeof(student_t));
    default:
        return -1;
    }
}

int student_Updata(void *data_1, const void *data_2, const int mode)
{
    student_t *v = data_1;
    const int *num2 = data_2;
    switch (mode)
    {
    case 1: //修改姓名
        strcpy(v->name,data_2);
        return 0;
    case 2: //修改年龄
        v->age = *num2;
        return 0;
    case 3: //修改身高
        v->high = *num2;
        return 0;
    case 4: //修改全部
        memcpy(v, data_2, sizeof(student_t));
        return 0;
    default:
        return -1;
    }
}

student.h

#ifndef STUDENT_H
#define STUDENT_H

typedef struct Student
{
    char name[20];
    int age;
    int high;
} student_t;
/*******************
 * 函数名：student_Print
 * 功能：学生链表打印
 * 参数：链表数据域
 * 返回值：无
 * **************/
void student_Print(void *data);
/*******************
 * 函数名：student_Cmp
 * 功能：学生信息比较
 * 参数：
 *      data_1:待比较的数据域
 *      data_2:目标数据
 *      mode:索引模式
 * 返回值：一样返回0,不一样返回非0
 * **************/
int student_Cmp(const void *data_1, const void *data_2, const int mode);
/*******************
 * 函数名：student_Updata
 * 功能：学生信息更新
 * 参数：
 *      data_1:待更新的数据域
 *      data_2:目标数据
 *      mode:更新模式
 * 返回值：成功返回0,失败返回非0
 * **************/
int student_Updata(void *data_1,const void *data_2,const int mode);

#endif

main.c

#include <stdio.h>
#include "node.h"
#include "student.h"
#include <string.h>
int main()
{
    node_t *head = node_creat(); //创建头节点
    student_t stu[6];
    strcpy(stu[0].name, "张三丰");
    stu[0].age = 100;
    stu[0].high = 200;
    strcpy(stu[1].name, "张四丰");
    stu[1].age = 101;
    stu[1].high = 201;
    strcpy(stu[2].name, "张五丰");
    stu[2].age = 102;
    stu[2].high = 202;
    strcpy(stu[3].name, "张六丰");
    stu[3].age = 103;
    stu[3].high = 203;
    strcpy(stu[4].name, "张七丰");
    stu[4].age = 104;
    stu[4].high = 204;
    node_inser_end(head, &stu[0], sizeof(student_t));  //尾插
    node_inser_head(head, &stu[1], sizeof(student_t)); //头插
    node_inser_end(head, &stu[2], sizeof(student_t));  //尾插
    node_inser_head(head, &stu[3], sizeof(student_t)); //头插
    node_inser_end(head, &stu[4], sizeof(student_t));  //尾插//理论顺序为6->4->3->5->7
    printf("---------------------------------\n");
    node_foreach(head, student_Print);
    printf("---------------------------------\n");
    char findname[] = "张五丰";
    const int findage = 104;
    const int findhigh = 204;
    node_t *findnode = node_find(head, findname, 1, student_Cmp);
    if (findnode != NULL)
    {
        student_t *v = findnode->data;
        printf("找到了！\n");
        printf("姓名：%s\t年龄：%d\t身高：%d\t\n", v->name, v->age, v->high);
        char newname[] = "张八丰";
        const int newage = 110;
        const int newhigh = 210;
        const student_t w = {"张八丰", 110, 210};
        int temp;
        temp = node_updata(findnode, newname, 1, student_Updata);
        if (temp == 0)
        {
            printf("修改成功！\n");
        }
        else
        {
            printf("修改失败! \n");
        }
    }
    else
    {
        printf("没找到\n");
    }
    printf("---------------------------------\n");
    node_foreach(head, student_Print);
    printf("---------------------------------\n");
    if (node_delete(head, findnode) == 0)
    {
        printf("删除成功!\n");
    }
    else
    {
        printf("删除失败!\n");
    }
    printf("---------------------------------\n");
    node_foreach(head, student_Print);
    printf("---------------------------------\n");
    strcpy(findname, "张三丰");
    findnode = node_find(head, findname, 1, student_Cmp); //在张三丰节点后面插入张九丰
    strcpy(stu[5].name, "张九丰");
    stu[5].age = 800;
    stu[5].high = 300;
    if (node_inser_node(findnode, &stu[5], sizeof(student_t)) == 0)
    {
        printf("插入成功!\n");
    }
    else
    {
        printf("插入失败!\n");
    }
    printf("---------------------------------\n");
    node_foreach(head, student_Print);
    printf("---------------------------------\n");
    node_free(&head); //释放链表空间
    if (head == NULL)
    {
        printf("释放成功!\n");
    }
    else
    {
        printf("释放失败!\n");
    }
    return 0;
}

运行结果

在这里插入图片描述

Xicode
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言单链表代码
weixin_42104550的博客
08-26 2887
下面的内容对初学者来说很抽象，建议多画图理解，或者去看熟悉我的C语言内存结构以及指针研究的文章再来理解链表。 顺序表的缺点可以用链表来解决，链表也分为单链表和双链表。这一文只展示单链表的代码。为什么单链表的访问效率极高，而且不会因为表的长度而影响的。因为链表在每一个数据前面都有一个地址头，也就是说链表的每个数据其实是有头有尾的，头是一个指向尾的地址，尾部才是真正的用户存储的数据。 每个数据是这样存储的，next是地址指针 data才是数据。每个数据都是独立的一个节点，只是这些块节点有next指针把它们串
C语言实现单向链表及其各种排序（含快排，选择，插入，冒泡）
zpcdcsdn的专栏
11-01 2131
 #include #include #define LEN sizeof(struct Student) struct Student                //结构体声明 {  long num;  int score;  struct Student* next; }; int n; struct Student* creat() {  struct S
c语言_单向链表代码
weixin_38293453的博客
02-15 246
一、LinkTable.h文件 //LinkTable结构体实现 typedef struct Link{ int elem; struct Link *next; }node; #define initTableSize 5 node * initLinkTable(); int selectElem(node *p, int elem); node *amendElem(node ...
C语言的单向链表代码
阿达King哥的博客
11-11 208
写着玩 #include <stdio.h> typedef struct Node { int num; struct Node *next; } Node; Node *head=NULL; int count = 0; void addNode() { int num; Node *p = (Node*)malloc(sizeof(Node)); prin...
C语言单向链表构建+实例
qq_45253310的博客
09-04 327
C语言单项向链表构建+实例构建思路具体代码（以输入学生数学成绩为例） 构建思路 链表的构建是C语言的一项特色，也是必须要掌握的一项技能。构建的思路如下： 构建各个模块，分别如下： 1.构建链表头。 2.构建结点。 3.插入结点。 4.删除结点。 5.修改结点。 6.打印结点。 具体代码（以输入学生数学成绩为例） 创建链表 //创建链表头 struct Node*creat_node() { struct Node*Head_node=(struct Node*)malloc(sizeof(struct N
链表的一个C代码实例
堂吉诃德的专栏
10-15 545
范例代码是一个ADT（抽象数据类型）双向环形链表的基本操作部分的实例（未包含线程安全机制），全部遵从ANSI C标准，由User:JohnBull贡献，代码遵从GPL版权许可。 接口声明 #ifndef LLIST_H #define LLIST_H typedef void node_proc_fun_t(void*); typedef int node_comp_fun_t(c
C语言自学链表，单向链表，双向链表，适合新手学习。
06-18
本资源提供的是针对初学者设计的链表学习材料，包括单向链表和双向链表的实现。下面将详细讲解这两种链表的数据结构及其操作。 1. **单向链表**： 单向链表是一种线性数据结构，每个节点包含两部分：数据域和指针...
C语言实现单向链表加注释
最新发布
06-11
以下是C语言实现单向链表并加上注释的代码示例： ```c #include #include // 定义单向链表结构体 struct Node { int data; // 数据域 struct Node* next; // 指针域 }; int main() { // 初始化链表头节点 ...
C语言实现链表通讯录
06-26
- 单向链表：每个节点包含数据部分和指向下一个节点的指针。在这个项目中，链表的节点可能包含联系人的姓名、电话、邮箱等信息。 - 链表操作：插入、删除、遍历等基本操作需要手动更新节点间的指针。 3. **结构体...
C语言学生信息管理系统（单向链表，密码登录，学生端，教师端，功能齐全，登录界面彩色字体，注释超详细，一看就懂！）
04-20
底层链表（单向链表）list.h,list.c; 菜单文件menu.h,menu.c; 功能模块student.h,student.c; main.c;in.c; Linux C，Ubuntu；make工具多文件编译，文件操作，用文件保存学生信息表（掉电保护，防丢失) ; 注释超全，...
C语言之单向链表详解及实例代码
12-31
1，单向链简洁。 单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指列表中的下一个结点；列表是由结点构成，由head指针指向第一个成为表头的结点而终止于最后一个指向nuLL的指针； 2，例子要求： 根据示例代码中的例子，完成单向链表(single linked list)中的以字符串为数据的链表的插入、删除以及查找，并支持单向链表的反转； 3，代码实现。 #include <stdio> #include <math.h>
c语言单链表程序
07-05
C语言单链表程序
数据结构c语言版-单链表的操作程序代码
05-19
c语言数据结构的， 学数据结构一定会用到的 。
c语言实现单向循环链表
09-01
c语言实现单向循环链表
python实现链表操作
sunny
07-28 252
定义一个链表： class Node(object): """单链表的结点""" def __init__(self, item): # item存放数据元素 self.item = item # next是下一个节点的标识 self.next = None class SingleLinkList(object): """单链表""" def __init__(self): self._h
C语言实现 单向链表
qq_37941471的博客
06-09 1157
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素                    (数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据
单链表的c语言,单链表（C语言）(示例代码)
weixin_39974557的博客
05-19 139
单链表：单向无循环，最后置于空//SeqList.h#pragmaonce#include#include#include#defineMAX_SIZE100typedefintDataType;typedefstructSeqlist{DataType*_array;size_t_size;size_t_capacity;}Seqlist;voidInitSeqlist(S...
C语言单向链表的实现
qq_17441227的博客
12-14 878
1.C语言单向链表的实现 #include #include //定义链表节点类型，包含数据和指向下一个节点的指针 typedef struct Node { int data; struct Node *next; }Node,*PNode; PNode createList(int len);//创建n个节点的链表 void printList(PNode
单向链表 代码实现
黑桃K
09-02 251
#include<stdio.h> typedef int LDataType; //单链表节点 typedef struct listNode{ LDataType _data; struct listNode* _next; }listNode; //头指针 typedef struct list{ listNode* _head; }list; //初始化链表 void listInit(list* lst){ if (lst == NULL) return; lst-&g
C语言单向链表详解：表示与实现
本文将详细介绍单向链表的概念、特点以及在C语言中的具体实现。 1. **概念与特点** - 单向链表是链表的一种，每个节点包含两个域：一个用于存储数据（称为`data`），另一个用于存储指向下一个节点的指针（称为`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值