单向链表装载用户自定义数据的c语言实现 linklistpackagenode.h 和 linklistpackagenode.c

最新推荐文章于 2020-08-19 11:59:02 发布
最新推荐文章于 2020-08-19 11:59:02 发布
阅读量577 收藏
点赞数 1
分类专栏： 数据结构 文章标签： c语言 链表 用户自定义数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chen1540524015/article/details/74885378
版权

linklistpackagenode.h 文件

#ifndef _LINKLIST_PACKAGENODE_H_
#define _LINKLIST_PACKAGENODE_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//单向链表
//链表操作精髓在于操作关系节点，引入辅助指针pcurrent,pnext.从表头开始遍历各关系节点。

//让业务节点包含关系节点，并把关系节点放在业务的首地址
//业务的首地址就是关系节点的地址，统一转化

//让无序的数据通过指针组成链表，联系起来
//1，指针指向谁就把谁的地址赋给指针
//2，分清楚链表的操作逻辑和辅助指针变量之间的关系
//3, 链表是链式存储的，无顺序，单向的，找到3必须先找到2，
//找到2必须先找到1，找到1必先找到0，再找到头，故引入辅助指针，不可以[]操作

//实现上层调用和底层分离，不让调用用户知道数据结构
typedef void List;
typedef void UserData;

#ifndef bool
#define bool int
#define true 1
#define false 0
#endif
//链表就是有很多表格组成，刚开始创建表头格，
//业务节点创建后来的表格，通过关系节点连接起来
/**链表只创建了一个链表头，next指向null。后边添加的节点是在业务节点中产生的。**/

//小节点，等待被业务节点包含。
//由小节点之间的关系连接业务节点。
//被业务节点放在首部，小节点地址与业务节点首地址重合
//链表的算法和业务分离，STL思想

//定义小节点是有联系的 ,小节点的链表
typedef struct _tag_LinkListConnectedNode
{
    struct _tag_LinkListConnectedNode* next;
}LinkListConnectedNode;

//定义链表头， 头部链表
typedef struct _tag_LinkList{
    LinkListConnectedNode head;  //小节点
    int length; //小节点的个数就相当于业务节点的个数
}LinkList;
//定义用户链表
typedef struct _tag_LinkListUser
{
    LinkListConnectedNode head;  //小节点
    UserData* item;
}LinkListUser;
//用户定义的数据业务模型只要包含关系节点，且关系的节点的地址与表头的关系节点地址相当
//都是每个表格的首地址即可，业务节点就可以与表头串起来
//typedef struct _tag_LinkListData
//{
//  LinkListConnectedNode node;   //关系节点
//  Teacher teacher;     //业务数据
//}LinkListData;

List* LinkList_create();
bool LinkList_destory(List* list);
bool LinkList_clear(List* list);
int LinkList_getLength(List* list);
bool LinkList_insertOneNode(List* list ,UserData* listuserdata, int pos);
UserData* LinkList_getOneNode(List* list, int pos );
UserData* LinkList_deleteOneNode(List* list, int pos);
bool LinkList_deleteAllNode(List* list);
#endif

linklistpackagenode.c 文件

#include "linklistpackagenode.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//底层函数分配链表头和业务链表的内存，注意内存管理
//底层函数分配业务链表关系连接节点的内存，业务链表包含了待操作数据的节点
//对链表的操作实际是通过关系连接节点的操作完成的
//各链表的首地址就是关系连接节点的地址
//链表头的首地址就是第一个关系连接节点的地址
//链表头不存业务数据
//链表操作精髓在于操作关系节点，引入辅助指针pcurrent,pnext.从表头开始遍历各关系节点。

//每次增加新业务节点时，只需业务创建业余节点，通过关系节点连接起来
//业务节点和链表头都要包含关系节点。
List* LinkList_create()
{
    //只创建一个头结点
    List* ret = NULL;
    LinkList* templinklist = NULL;
    templinklist = (LinkList*)malloc(sizeof(LinkList));
    memset(templinklist,0,sizeof(LinkList));
    templinklist->head.next = NULL;
    templinklist->length = 0;
    ret = (List*)templinklist;
    return ret;
}
//销毁链表先清空链表在释放表头内存
bool LinkList_destory(List* list)
{   
    bool ret;
    LinkList* templinklist = NULL;
    if (list == NULL)
    {
        return false;
    }
    templinklist = (LinkList*)list;
    ret = LinkList_clear((List*)templinklist);
    if (ret == false)
    {
        return false;
    }
    if (templinklist != NULL)
    {
        free(templinklist);
        templinklist = NULL;
    }

    return true;
}
//清空链表先删除所有业务节点，只保留表头，注意内存释放
bool LinkList_clear(List* list)
{
     bool ret;
     LinkList* templinklist = NULL;
     if (list == NULL)
     {
         return false;
     }
     templinklist = (LinkList*)list;
     ret = LinkList_deleteAllNode((List*)templinklist);
     if (ret == false)
     {
         return false;
     }
     if (templinklist != NULL)
     {
         templinklist->length = 0;
         templinklist->head.next = NULL;
     }
     return true;
}

int LinkList_getLength(List* list)
{
    int ret = 0;
    LinkList* templinklist = NULL;
    if (list == NULL)
    {
        return -1;
    }
    templinklist = (LinkList*)list;
    ret = templinklist->length;
    return ret;
}
//用户节点转换为链表节点，底层函数分配链表业务节点的内存
bool LinkList_insertOneNode(List* list ,UserData* userdata, int pos)
{
    LinkList* templinklist = NULL;
    LinkListConnectedNode* pcurrent = NULL; //辅助指针
    LinkListConnectedNode* linklistconnectednode = NULL;
    int i = 0;
    //业务链表
    LinkListUser* linklistuser = NULL;
    if (list == NULL || userdata == NULL || pos < 0)
    {
        return false;
    }
    templinklist = (LinkList*)list;
    //底层函数为业务链表分配内存
    linklistuser = (LinkListUser*)malloc(sizeof(LinkListUser));
    //初始化
    memset(linklistuser,0,sizeof(LinkListUser));
    if (linklistuser == NULL)
    {
        return false;
    }
    //代操作的数据转换为业务链表的节点
    linklistuser->item = userdata;
    //业务链表首地址就是关系连接的节点，利用关系连接节点操作
    linklistconnectednode = (LinkListConnectedNode*)linklistuser;
    //辅助指针指向链表的头部，带头的链表，头部之后就是0位置存业务节点；
    //头部只存小节点，不存业务节点。头部只是指向整个链表的首地址
    pcurrent = &(templinklist->head); 
    //辅助指针从头部跳到（pos-1） 处；头部、0、1、2、。。
    for ( i = 0; (i < pos && (pcurrent->next != NULL)); i++)
    {
        pcurrent = pcurrent->next;
    }
    //头，0,1,2,3,4, 要在3号插入，pcurrent 指向2，pcurrent->next 指向3
    //插入新节点后，新节点的next应该指向原来的3即上面的pcurrent->next，pcurrent->next应该指向新节点了
    //当前节点的next 指向要插入新节点的next
    linklistconnectednode->next = pcurrent->next;
    //当前节点的next指向要插入新节点的地址
    pcurrent->next = linklistconnectednode;
    templinklist->length++;
    return true;
}
//得到链表的业务节点
UserData* LinkList_getOneNode(List* list, int pos )
{
    LinkList* templinklist = NULL;
    LinkListConnectedNode* pcurrent = NULL; //辅助指针
    UserData* ret = NULL;
    int i = 0;
    //业务链表
    LinkListUser* linklistuser = NULL;
    if (list == NULL || pos < 0)
    {
        return NULL;
    }
    templinklist = (LinkList*)list;
    if (templinklist->length <= 0 || pos >= templinklist->length)
    {
        return NULL;
    }
    //辅助指针指向链表的头部，带头的链表，头部之后就是0位置存业务节点；
    //头部只存小节点，不存业务节点。头部只是指向整个链表的首地址
    pcurrent = &(templinklist->head); //辅助指针指向链表头部
    //辅助指针从头部跳到（pos-1） 处；头部、0、1、2、。。
    for (i = 0; (i < pos && (pcurrent->next != NULL)); i++) //跳pos次，到pos-1处，刚开始指向头部，跳1次指向0
    {
        pcurrent = pcurrent->next;
    }
    //得到业务链表节点
    linklistuser = (LinkListUser*)(pcurrent->next);
    ret  = (UserData*)(linklistuser->item);
    return ret;
}
//删除链表的业务节点，由于业务节点时底层分配的，还需要底层释放
UserData* LinkList_deleteOneNode(List* list, int pos)
{
    LinkList* templinklist = NULL;
    LinkListConnectedNode* pcurrent = NULL; //辅助指针
    LinkListConnectedNode* pdelete = NULL; //缓存要删除的节点
    UserData* ret = NULL;
    int i = 0;
    LinkListUser* linklistuser = NULL;
    if (list == NULL || pos < 0)
    {
        return NULL;
    }
    templinklist = (LinkList*)list;
    if (templinklist->length <= 0 || pos >= templinklist->length)
    {
        return NULL;
    }
    //辅助指针指向链表的头部，带头的链表，头部之后就是0位置存业务节点；
    //头部只存小节点，不存业务节点。头部只是指向整个链表的首地址
    pcurrent = &(templinklist->head); //辅助指针指向链表头部
    //辅助指针从头部跳到（pos-1） 处；头部、0、1、2、。。
    for (i = 0; (i < pos && (pcurrent->next != NULL)); i++) //跳pos次，到pos-1处，刚开始指向头部，跳1次指向0
    {
        pcurrent = pcurrent->next;
    }
    //得到要删除的节点
    pdelete = pcurrent->next;
    pcurrent->next = pdelete->next;
    templinklist->length--;
    //删除的业务节点
    linklistuser =(LinkListUser*)pdelete;
    ret = (UserData*)linklistuser->item;
    //释放业务节点内存
    if (linklistuser != NULL)
    {
        free(linklistuser);
        linklistuser = NULL;
    }
    return ret;
}

bool LinkList_deleteAllNode(List* list)
{
    LinkList* templinklist = NULL;
    if (list == NULL)
    {
        return false;
    }
    templinklist = (LinkList*)list;
    while(templinklist->length > 0)
    {
        LinkList_deleteOneNode(list,0);
    }
    return true;
}

/***********************以下为测试代码************************/

/*

//方法1：在业务节点中定义链表的一格的关系节点
//typedef struct _tag_Teacher{
//  LinkListConnectedNode node;
//  int age;
//  char name[64];
//}Teacher;

//方法2：把业务直接定义到链表一格的关系节点之下
//用户定义的数据业务模型只要包含关系节点，
//且关系的节点的地址与表头的关系节点地址相当
//都是每个表格的首地址即可，业务节点就可以与表头串起来
typedef struct _tag_Teacher{
    int age;
    char name[64];
}Teacher;


void main()
{

    int k = 0;
    List* list = NULL;
    Teacher t1,t2,t3,t4,t5;
    t1.age = 21;t2.age = 22;t3.age = 23;t4.age = 24;t5.age = 25;
    list = LinkList_create();
    if (list == NULL)
    {
        printf("list创建失败");
    }

    //头插法，插入元素
    //业务节点强制转换为ListNode* ,ListNode* 强制转换为小节点LinkListConnectedNode*;
    LinkList_insertOneNode(list,(UserData*)&t1,0);
    LinkList_insertOneNode(list,(UserData*)&t2,0);
    LinkList_insertOneNode(list,(UserData*)&t3,0);
    LinkList_insertOneNode(list,(UserData*)&t4,0);
    LinkList_insertOneNode(list,(UserData*)&t5,0);
    printf("链表长度是：%d \n", LinkList_getLength(list));
    //遍历链表
    for (k = 0; k < LinkList_getLength(list); k ++)
    {
        Teacher* teachertemp = (Teacher* )LinkList_getOneNode(list,k); 
        printf("老师%d的年龄是%d \n",k+1,teachertemp->age);
    }
    LinkList_deleteAllNode(list);
    printf("链表长度是：%d \n", LinkList_getLength(list));
    LinkList_destory(list);
    system("pause");
}
*/

可能会调用其它头文件会源文件，如果遇到，请翻看我的其它博客，对其头文件或源文件的实现方式。
good luck !

夏天不热 冬天不冷
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言，单链表实现（不含文件读入信息，单纯手动）
嗷嗷待哺的簸箕板
07-13 573
C语言，单链表实现（不含文件读入信息，单纯手动录入信息） 主要以学生ID，姓名和三课成绩进行操作 结构体定义 struct Node { char name[20]; // 学生姓名 char no[20]; // 学生学号 float score[3]; // score数组分别存储语文、数学、英语成绩 float total; // 总分 struct Node *next; // 下一个结点的地址 }; 创建链表先上代码图 typedef st
Android 文件读写
jven的博客
07-25 208
读取 /** * 文件读取 * @param is 文件的输入流 * @return 返回文件数组 */ private byte[] read(InputStream is) { //缓冲区inputStream BufferedInputStream bis = null; //用于存储数据 ByteArrayOutputStream baos = null; try { //每次读1024 byte[] b = new byte[1024];
单链表（LinkedList）
Cdreamfly的博客
04-16 1314
与数组相似，链表也是一种线性数据结构。这里有一个例子：   正如你所看到的，链表中的每个元素实际上是一个单独的对象，而所有对象都通过每个元素中的引用字段链接在一起。   链表有两种类型：单链表和双链表。上面给出的例子是一个单链表，这里有一个双链表的例子：   单链表中的每个结点不仅包含值，还包含链接到下一个结点的引用字段。通过这种方式，单链表将所有结点按顺序组织起来。 下面是一个单链表的例子： ...
每日面试题2(ArrayList和LinkedList)
程序员小章的博客
08-19 559
ArrayList和linkedList的区别 一般大家都知道ArrayList和LinkedList的大致区别： 1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 一．时间复杂度 首先一点关键的是，ArrayList的内部实现是基于基础
线性表的链式存储结构（C语言实现）
qq_32262155的博客
10-29 2546
由于线性表的顺序存储结构在进行插入与删除是要移动大量的元素，会耗费大量的时间，线性表的链式存储结构就完美的解决了这个问题。 首先是单链表的创建，有头插法和尾插法。 头插法： /* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */ void CreateListHead(LinkList *L, int n) { LinkList p; int i;
数据结构-链表的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 链表的部分实现代码（单向链表、双向链表、循环链表、约瑟夫环等），详细介绍参考数据结构--链表的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
c语言实现单向链表.
01-05
在IT领域，C语言是一种基础且强大的编程语言，尤其适合实现底层数据结构和算法。本文将深入探讨如何使用C语言来实现单向链表，并扩展到实现双向链表的“增删改查显”功能。 首先，让我们了解链表的基本概念。链表是...
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
链表-使用C语言实现循环链表.zip
最新发布
03-13
本资源“链表-使用C语言实现循环链表.zip”将详细介绍如何用C语言来创建和操作循环链表。 首先，我们要理解循环链表的基本概念。循环链表是一种链表，其最后一个节点的指针不是NULL，而是指向链表的第一个节点，...
逆置数组实现和链表实现（C语言实现） 数组和链表.pdf
04-18
“逆置数组实现和链表实现（C语言实现）” 本资源主要讲解了数组和链表的逆置操作的C语言实现，包括数组逆置和链表逆置两部分。下面是对该资源的详细知识点解释： 一、数组逆置 数组逆置是将数组中的元素按照逆序...
数据结构之LinkedList的简单实现
qq_27857857的博客
12-17 2172
简单实现了java里的LinkedList，如add、set、get等方法。
C语言实现LinkedList链表数据结构
愤怒的苹果ext的博客
11-15 4734
链表基本的就是一个数据域一个指针域，数据域存储你的数据，指针域就指向你下一个节点的内存地址。示意图(画的很粗糙,请见谅) 链表的特点： 增删快 (修改元素时，只需要改变指针域指向就可以了) 查询慢 (元素之前内存地址不连续，只能挨个挨个遍历查找) 我们现在就来实现一个非循环单链表 首先写出链表的结构体： typedef struct Node{ //非循环单链表结构体 int data;
oracle 数据装载方式汇总
jianxing11的专栏
10-17 1140
1、数据源文件，是sql格式： 工具：plsql developer ，命令窗口：sql&gt;@D:\daoru.sql 或者tools--&gt;导入表 2、数据源文件，是csv、excel格式： 工具：plsql developer，tools--&gt;文本导入器（csv）、tools--&gt;ODBC导入器（excel） 3、数据源文件，是csv格式，且数据量比较大： 工具...
数据结构之链表(Linked-List)及操作
David的博客
07-07 4039
一、 数据结构之链表(Linked-List) 线性表是最常用的存储结构，线性表的每个单元称为元素，元素拥有一个数据及一个地址线性表有两种物理存储方式：顺序存储方式和链式存储方式数组是具有代表性的顺序存储方式的线性表，单链表是具有代表性的链式存储方式的线性表。 1.数组 数组的内存是连续分配的，可以通过数组的索引直接获取对应的数据，其索引就是线性表中所说的元素的“地址”，但索引不是地...
用c/c++自己动手实现一个链表LinkList
一只懒虫的博客
10-08 3594
链表的特点 便于插入删除，这些操作只要改变指针的指向 遍历查找O(n) 排序复杂度也极大 所以适合插入删除频繁的程序。 实现思想 自建基本的节点数据结构 明确基本操作：初始化、插入、删除、按位置查找、按值查找等等 实现代码 注：vs2008 // LinkList.cpp : Defines the entry point for the console application. //...
链表的链性表的c语言实现方式 linklist.h 和 linklist.c
chen1540524015的博客
07-10 4874
linklist.h 文件#ifndef _LINKLIST_H_ #define _LINKLIST_H_ #include <stdio.h> #include <stdlib.h> #include <string.h> //链表就是一个一个的表通过关系节点连接的 //单向链表 //链表操作精髓在于操作关系节点，引入辅助指针pcurrent,pnext.从表头开始遍历各关系节点。//让业务节点
LeetCode刷题笔记（Java）---第161-180题
gongsenlin341的博客
05-09 568
文章目录162. 寻找峰值164. 最大间距165. 比较版本号 162. 寻找峰值 峰值元素是指其值大于左右相邻值的元素。 给定一个输入数组 nums，其中 nums[i] ≠ nums[i+1]，找到峰值元素并返回其索引。 数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。 你可以假设 nums[-1] = nums[n] = -∞。 解答 //二分查找 public int findPeakElement(int[] nums) { int lef
Java实习生面试复习(四)：LinkedList
Linn的博客
03-19 1554
我是一名很普通的大三学生。我会坚持写博客，输出知识的同时巩固自己的基础，记录自己的成长和锻炼自己，奥利给！！ LinkedList 适用于集合元素先入先出和先入后出的场景，在队列中被频繁使用。下面我们就来简单了解一下它，并看看它跟常用的ArrayList的区别。 LinkedList结构分析 LinkedList 底层数据结构是一个双向链表，整体结构...
链表笔试面试题（二）
xiongluo0628的博客
08-16 296
本博客内容： 一、以链表的每2个为单位，对调二者的位置，如果原链表是1-2-3-4-null，对调之后就是2-1-4-3-null 二、判断链表的总结点是偶数还是奇数？ 三、将循环链表分成二等分，如果节点总数为奇数，就定第一个小的循环链表，比第2个多一个节点 四、寻找与模除（modular）有关的节点。编写函数，以便根据整数常量k，在包含n个元素的单链表中，寻找序号最大，且给序号又能为k所...
Linux List.h深度解析：双向链表与数据结构实现
此外，List.h文件还可能包含了队列和堆栈等其他数据结构的实现，它们都是基于链表的变种，但可能涉及不同类型的指针管理和操作策略。理解这些基础数据结构及其在Linux内核中的应用，有助于深入理解操作系统内部的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值