C语言 单链表基本操作源码

最新推荐文章于 2024-08-27 09:26:09 发布
最新推荐文章于 2024-08-27 09:26:09 发布
阅读量631 收藏
点赞数
分类专栏： C语言 嵌入式 文章标签： 算法 单链表 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Paulliam/article/details/105276171
版权

单链表 源码C程序源文件：DataRetrans.c

/**
 * @file    ：
 * @date    :20191118
 * @author  :zhoumin
 */ 

#include "DataRetrans.h"
#include "server.h"
#include "rtc.h"
#include <stdbool.h>

#if MALLOC_SWITCH
void *pmalloc(uint32_t size) {  return  calloc(size, sizeof(uint8_t));}

malloc_fn  Retrans_malloc = (malloc_fn)pmalloc;
free_fn  Retrans_free = (free_fn)free;
#else
void* (*Retrans_malloc)(size_t sz) = pvPortMalloc;//malloc;
void (*Retrans_free)(void *ptr) = vPortFree;//free;
#endif

#define QUEUE_SIZE  20

/*初始化单链表*/
void InitList(LNode **HL)
{
	*HL = NULL;  //置单链表为空
}

/*删除单链表中所有节点，使其成为空表*/
void ClearList(LNode **HL)
{
	LNode *cp; //cp(current pointer)指向当前待处理节点
	LNode *np; //np(next pointer)指向cp的后继节点
	cp = *HL; //表头指针赋给cp
	while(cp != NULL){
		np = cp->next;
		Retrans_free(cp);//释放该节点内存
		cp =np; //使下一个节点成为当前节点
	}
	*HL = NULL;
}

/*得到单链表的长度*/
uint16_t LengthList(LNode *HL)
{
	uint16_t i=0;
	while(HL != NULL){
		i++;
		HL = HL->next;
	}
	return i;
}

/*检查单链表是否为空*/
bool EmptyList(LNode *HL)
{
	return HL==NULL;
}

/*得到单链表中第pos个节点中的元素*/ //节点序号从表头的序号1开始
ElemType GetList(LNode *HL, uint16_t pos) //pos>=1
{
	if(pos < 1){
		LOG_L("pos is Wrongful!");
		return NULL;
	}
	uint16_t i= 0;
	while(HL != NULL){
		i++;
		if(i == pos)
			break;
		HL = HL->next;
	}
	if(HL != NULL){  //不为空，说明已找到该节点
		return HL->data;
	}
	else{
		LOG_L("pos is out range!");//没找到
		return NULL;
	}
}

/*遍历一个链表*/
void TraverseList(LNode *HL)
{
	while(HL != NULL){
		//LOG_L(fmt, args...);
		HL = HL->next;
	}
}

/*从链表中查找出给定值的第一个元素，并由item带回该值*/
bool FindList(LNode *HL, ElemType *item)
{
	while(HL != NULL){
		if(*item == HL->data){ //根据具体比对项，修改此处代码
			*item = HL->data;  //根据具体比对项，修改此处代码
			return true;
		}
		else{
			HL = HL->next;
		}
	}
	return false;
}

/*更新链表中等于给定值的第一个元素*/
bool UpdateList(LNode *HL, const ElemType *item)
{
	while(HL != NULL){
		if(HL->data == *item)
			break;
		else
			HL = HL->next;
	}
	if(HL == NULL)	//没有找到给定值的元素，无法更新
		return false;
	else{
		HL->data = *item;
		return true;
	}
}

/*向单链表中按给定条件插入一个元素*/ //表头节点的序号指定为1,pos==1,表示插入到表头
bool InsertList(LNode **HL, ElemType item, int pos) //pos必须大于等于-1；pos:0 按值寻找插入位置  pos:-1插入到表尾  pos:>0 插入到pos指定序号位置
{
	if(pos < -1){
		LOG_L("pos is Wrongful!");
		return false;
	}
	//为item元素建立新节点
	LNode *newptr;
	newptr = (LNode *)Retrans_malloc(sizeof(LNode));
	newptr->data = item;
	//寻找新节点的插入位置
	LNode *cp = *HL;  //cp指向当前节点，即待查节点，初始为指向表头
	LNode *ap = NULL; //ahead pointer 指向cp的前驱节点,初始化空
	if(pos == 0){	//pos:0 按值寻找插入位置
		while(cp != NULL){
			if(item < cp->data) //根据具体比对内容，修改此处代码
				break;  //找到新元素的插入位置，退出循环
			else{
				ap = cp;
				cp = cp->next;
			}
		}
	}
	else if(pos == -1){   //pos:-1插入到表尾
		while(cp != NULL){
			ap =cp;
			cp = cp->next;
		}
	}
	else{    //pos:>0 插入到pos指定序号位置
		int i = 0;
		while(cp != NULL){
			i++;
			if(i == pos){ //pos==1,表示插入到表头
				break;
			}
			else{
				ap = cp;
				cp = cp->next;
			}
		}
		if(cp == NULL && i <pos){  //ypl-教材应该有误，教材源码： (cp == NULL && i+1 <pos)
			LOG_L("pos is not exist!");
			return false;
		}		
	}

	//完成新节点的插入操作
	if(ap == NULL){  //ap为空，表示，将要插入的节点位置就是表头--表头的前驱节点就是空
		newptr->next = *HL;
		*HL = newptr;
	}
	else{  //把新节点插入到非表头位置，即插入到ap和cp之间
		newptr->next = cp;  //cp如果为空，则表示插入到表尾
		ap->next = newptr;
	}

	return true;
}


/*从单链表中删除符合给定条件的第一个元素*/
bool DeleteList(LNode **HL, ElemType *item, int pos) //pos必须大于等于-1；pos:0 按值寻找待删节点  pos:-1待删节点是表尾  pos:>0 插入到pos指定序号位置
{
	//单链表为空，无法删除，返回假
	if(*HL == NULL){
		LOG_L("LIST is empty!");
		return false;
	}
	//pos值小于-1，返回假
	if(pos < -1){
		LOG_L("pos's value is invalid!");
		return false;
	}
	//寻找需要被删除的元素的节点
	LNode *cp = *HL;  //cp指向当前节点，即待查节点，初始为指向表头
	LNode *ap = NULL; //ahead pointer 指向cp的前驱节点,初始化空
	if(pos == 0){    //按值查找被删除节点
		while(cp != NULL){
			if(*item == cp->data)
				break;
			else{
				ap = cp;
				cp = cp->next;
			}
		}
		if(cp == NULL){
			LOG_L("pos's value can't find!");
			return false;
		}
	}
	else if(pos == -1){    //查找表尾节点
		while(cp->next != NULL){
			ap = cp;
			cp = cp->next;
		}
	}
	else{    //查找给定序号的节点
		int i = 0;
		while(cp != NULL){
			i++;
			if(i == pos){
				break;
			}
			else{
				ap = cp;
				cp = cp->next;
			}
		}
		if(cp == NULL){
			LOG_L("pos is over lenth!");//指定序号越界超过链表实际长度
			return false;
		}
	}

	//删除cp指向的节点
	if(ap == NULL){ //删除表头节点
		#if 1
		LNode *temp = *HL;  //ypl-语法可能出错的备用方案  	  
		*HL = temp->next;
		#else
		*HL = (*HL)->next;//ypl-语法不标准，但仍旧能够编译过  	  
		#endif
	}
	else{ //删除非表头节点，也可能是表尾节点
		ap->next = cp->next;
	}
	//回收被删除节点的存储空间
	Retrans_free(cp);//ypl-实际上，要回收的数据还不止节点占用的空间，还有

	return true;
}



/*对单链表进行数据排序
 *假定待排序的单链表由表头指针HL所指向，对节点值按照从小到大进行排序链接时，首先建立一个空的单链表，
 *然后把HL中的每个节点取出来并按值依次插入到新建立的单链表中，最后由HL带回新建链表的表头指针
 */
 void SortList(LNode **HL)
{
	//建立一个反映排序结果的新单链表，并初始化为空
	LNode *SL;
	InitList(&SL);
	//从待排序的HL单链表中依次取出每个节点，并按值由小到大插入到新单链表中
	LNode *r=*HL;  //r指向待取出排序的一个节点，初始化为HL表头节点
	LNode *t;  //t指向r的后继节点
	LNode *cp; //指向已排序的新链表，初始化为表头SL
	LNode *ap; //ap指向cp的前驱节点，初始化为空
	while(r != NULL)
	{
		//为新插入的r节点在SL中顺序查找出插入位置
		t = r->next; //t指向原链表r节点的后继节点
		cp = SL;     //指向已排序的新链表，初始化为表头SL
		ap = NULL;   //ap指向cp的前驱节点，初始化为空
		while(cp != NULL)
		{
			if(r->data < cp->data)  
				break;  //找到被插入点，退出循环
			else{
				ap = cp;        //ap和cp均后移，实现有序链表中的每个节点依次顺序和原链表中r节点比较
				cp = cp->next;
			}
		}

		//实现插入操作
		if(ap == NULL){  //把r节点插入到表头
			r->next = SL;
			SL = r;
		}
		else{            //把r节点插入到ap和cp之间
			r->next = cp;
			ap->next = r;
		}

		//使r指向原链表的下一个节点
		r = t;
	}

	//返回链表排序结果
	*HL = SL;
}









QueueHandle_t xQueue;     
//osSemaphoreId xComRxSem;
struct Repeat_Qmsg *reMsgHead  = NULL;
LNode *reMSGHead;



/**
 * 数据单元内存释放
 */ 
void FreeQMsg(QMsg *pmsg)
{
    if(pmsg != NULL)
    {
        if(pmsg->message.data != NULL) 
        {
            Retrans_free(pmsg->message.data);
            pmsg->message.data = NULL;
        }
        Retrans_free(pmsg);
        pmsg = NULL;
    }
}

int PutToRepeatQmsg(QMsg *data)
{
    struct Repeat_Qmsg *p = (struct Repeat_Qmsg *)Retrans_malloc(sizeof(struct Repeat_Qmsg));
    if(p == NULL)
    {   
        LOG_E("malloc error.\r\n");
        return CL_FAIL;
    }
    p->data = data;
    
    if(reMsgHead == NULL)
    {
        p->next = NULL;
        reMsgHead = p;
    }
    else
    {
        p->next = reMsgHead;
        reMsgHead = p;
    }
    
    return CL_OK;
}

void RepeatQmsgLoop(void)
{
    struct Repeat_Qmsg *p = reMsgHead;
    struct Repeat_Qmsg *last = NULL ,*temp;
    QMsg *data = NULL;
	
    while (p != NULL)
    {
        if(GetTimeStamp() >= p->data->timestamp+3000)
        {
            data = p->data;
            //将节点数据添加到发送队列
            if(xQueueSendToBack(xQueue,(void*)&data,0) != pdTRUE)
            {
                LOG_E("send to queue error.\r\n");
                FreeQMsg(data);//添加队列失败，释放数据单元内存
            }
            /* 删除节点p  */
            temp = p; //记录节点
            if(p == reMsgHead)//p指向头节点
            {
                reMsgHead = p->next;
            }
            else
            {
                last->next = p->next;
            }
			last = p;
			p = p->next;
            Retrans_free(temp);//释放该节点内存
            temp = NULL;
        }
        else
        {
			last = p;
            p = p->next;
        }
    }
}



int DataRetrans_SendMsg(Message_Unit message,timeout_callback callback)
{
    BaseType_t ret ;
    if(message.data == NULL)
        return CL_FAIL;
    
    QMsg *pmsg = (QMsg *)Retrans_malloc(sizeof(QMsg));
    if(pmsg == NULL)
    {
        LOG_E("malloc queue msg failed.\r\n");
        return CL_FAIL;
    }
    pmsg->message = message;
    pmsg->flag = 1;
    pmsg->callback = callback;
    pmsg->timers = 1;

	ret = xQueueSendToBack(xQueue,&pmsg,0);
	//ret = xQueueSendToFront(xQueue,&pmsg,0);

    if(ret != pdTRUE)
    {
        LOG_E("send msg to queue error.\r\n");
        Retrans_free(pmsg);
        return CL_FAIL;
    }
    return CL_OK;
}


void BswSrv_485SendTask(void *argc)
{
    uint32_t values = 0;
    QMsg *pmsg = NULL;
    BaseType_t ret;

    //UNUSED(argc);
	
    while (1)
    {
		vTaskDelay(300);
		Feed_WDT();
		ret = xQueueReceive(xQueue,(void*)&pmsg, 5/*portMAX_DELAY*/);

        if(ret == pdTRUE && pmsg != NULL)
        {
            //发送消息
			//LOG_I("-->msg:%s \r\n",pmsg->message.data);
			//PrintfData(">>msg:",pmsg->message.data,pmsg->message.len);
			//BswDrv_UsartSend(CHG_UART_INDEX, pmsg->message.data,pmsg->message.len);


                pmsg->timers++;
                pmsg->timestamp = GetTimeStamp();

            
            //等待消息ACK 最多等待200ms
            values = ulTaskNotifyTake(pdTRUE,200);
			

            if(values == 1)//收到ack
            {
                FreeQMsg(pmsg);
            }
            else if(pmsg->flag == 1)//超时
            {
                if(pmsg->timers >= 3)
                {
                    FreeQMsg(pmsg);
                    if(pmsg->callback) pmsg->callback();
                    //LOG_I("send data timeout.\r\n");
                }
                else
                {
                    //添加到重发队列
                    PutToRepeatQmsg(pmsg);
					LOG_E("PutToRepeatQmsg. \r\n");
                }
            }
            else
            {
                FreeQMsg(pmsg);
                //LOG_I("wait ack timeout.\r\n");
            }
        }

        //轮询重发队列
        RepeatQmsgLoop();
    }
}



/**
 * 485总线任务初始化 
 */ 
void BswSrv_485TaskInit(void)
{
    xQueue = xQueueCreate(QUEUE_SIZE, sizeof(QMsg *));
    //xComRxSem = osSemaphoreCreate(NULL,10);
    reMsgHead = NULL;
}

 

单链表 源码C程序头文件：DataRetrans.h

#ifndef __DATA_RESTRANS_H_
#define __DATA_RESTRANS_H_

#include "includes.h"


//typedef enum {FALSE   = 0, TRUE   = !FALSE  }   Bool;


typedef void (*timeout_callback) (void);


/**
 * 消息单元
 */ /*重发数据区*/
typedef struct
{
    uint16_t len;	//数据长度
    void *   data;	//数据缓存区
    uint16_t msgId;	//流水号
	uint8_t  cmd;	//指令
}Message_Unit;

/**
 * 队列数据单元
 */ 
typedef struct
{
	/*重发数据区*/
    Message_Unit message;
	/*重发控制器*/
    uint8_t  flag;                  //未收到应答的重发标志 1：正在重发 0：结束重发
    uint8_t  timers;                //当前发送次数
    uint32_t timestamp;             //上次发送时间戳
    timeout_callback callback;		//超时回调函数	
}QMsg;

typedef QMsg* ElemType;

struct _LNode{
	ElemType data;
	struct _LNode *next;
};
typedef struct _LNode LNode;





/**
 * 重传消息链表
 */ 
struct Repeat_Qmsg
{
    QMsg *data;
    struct Repeat_Qmsg *next;
};

#define MALLOC_SWITCH  1 //0

#if MALLOC_SWITCH
typedef void *(*malloc_fn)(size_t sz);
typedef void (*free_fn)(void *ptr);

extern malloc_fn  Retrans_malloc;//malloc;
extern free_fn  Retrans_free;//free;
#else
extern void *(*Retrans_malloc)(size_t sz);//malloc;
extern void (*Retrans_free)(void *ptr);//free;
#endif



int DataRetrans_SendMsg(Message_Unit message,timeout_callback callback);

void BswSrv_485TaskInit(void);

#endif

 

Paulliam
关注
专栏目录
2.3单链表的基本操作代码（数据结构C语言版）
weixin_51575278的博客
07-16 6540
1.单链表的存储结构 typedef struct Node//结点类型定义 { ElemType data; struct Node *next; }Node,*LinkList;//LinkList为结构体指针类型 2.初始化单链表 InitList(LinkList *L) { *L=(LinkList)malloc(sizeof(Node));//建立头结点 (*L)->next=NULL;//建立空的单链表 } /*L是指向单链表的头结点的指针，用来接收主程序中.
C语言链表源代码示范
06-01
适用于初学者学习C语言链表操作的源代码，内含链表的增添，查找，删除等基本操作，并附有详细的代码注释
链表-单链表的基本操作及C语言代码实现
最新发布
Dola的博客
08-27 396
遍历的概念想必大家都不会陌生，即就是从链表的头开始，逐步向后进行每一个元素的访问，这就是遍历，对于遍历操作，我们可以衍生出很多常用的数据操作，比如说查询元素，修改元素，获取元素个数，打印整个链表数据等等。删除元素要建立一个前驱结点和一个当前结点，当找到了我们需要删除的数据时，直接使用前驱结点跳过要删除的结点指向要删除结点的后一个结点，再将原有的结点通过free函数释放掉。以上的操作均用到了遍历的思维，针对于遍历还有非常多的用法供自主设计，请参考后文配套的习题进行练习。
链表学习2
weixin_51884452的博客
03-19 82
单链表的基本操作及C语言代码实现。
单链表基本操作代码
weixin_34301132的博客
10-28 91
#include <stdio.h>#include <stdlib.h> #include <stdio.h> #include <stdlib.h> typedef struct List { struct List *next; int data; }List; List *creatList(int...
c语言单链表的基本操作(代码)
Mr·潘
11-12 4472
c语言实现单链表的基本操作：建立、打印、删除、插入、逆序。仅供学习之用还需不断完善,有待读者自己研究 #include #include typedef struct stu { int data; //数据 struct stu *next; //指向下一节点的指针 }node; node *creat(int n)//创建链表 { node *head,*p1,*p2;
数据结构-单链表基本操作-C语言代码
热门推荐
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
【数据结构 C语言版】第三篇 单链表习题_数据结构c语言 单链表题
2401_84182271的博客
04-30 984
方法一代码题解（方法二）（1）翻转方向（2）代码实现细节图解方法二代码。
精选_基于C语言单链表实现的超市商品信息管理系统_源码打包
03-09
在本项目中，"精选_基于C语言单链表实现的超市商品信息管理系统_源码打包" 提供了一个使用C语言编程实现的超市商品信息管理系统的源代码。这个系统利用了数据结构中的单链表来存储和管理商品信息，使得在实际应用中...
精选_毕业设计_基于C语言的单链表客房管理系统_完整源码
03-05
接下来，我们需要实现链表的基本操作。包括： 1. 初始化链表：创建空链表，头节点通常设置为NULL。 2. 插入节点：根据需要插入新房间信息，可能在链表的头部或尾部。 3. 删除节点：根据房间号查找并删除指定房间...
基于c语言单链表的学生管理系统.zip
08-07
【资源内容】：包含完整源码+工程文件+说明（若有），项目具体内容可查看下方的资源详情。 【附带帮助】： 若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步。 【本人专注计算机领域】： ...
纯C语言实现的通用链表（类）源代码
01-15
纯C语言实现的通用链表（类）源代码 纯C语言代码实现的通用链表（类）源代码，可在bc++、tc，tc++等这些老古董编译器以及gcc、vc6.0、vc2005中通过编译，觉得不错的下载研究研究，不能抓到截图。 　　一些说明： 　　为了可扩展使用，下面的结点结构中用TYPE指定数据类型，使用时请按照需要在list_def.h中把TYPE定义为合适的类型，并且提供三个原型函数，第一个用来为TYPE类型的数据赋值，第二个判断两个TYPE类型的数据是否相等，第三个用来打印(显示)TYPE类型的数据。 　　在 list_def.h文件中，已经使用把TYPE定义为int类型 (#define TYPE int);也按int类型提供了上述三个函数,如需要其它类型只需做出适当的修改。特别说明，也可把"TYPE定义为自己定义的结构体等其它自定义类型。本链表为单向链表，非常有效。可以用作队列，堆栈等一些非常有用的数据结构。
C语言链表源代码
08-11
从MTK 分离出来的C语言链表代码，使用独立内存管理
链表基本操作源码
12-28
c 语言 链表基本操作，创建 查找 删除 插入 双向链表源码
单链表的基本操作代码实现(C语言版)
m0_67647682的博客
08-04 3万+
单链表基本操作取值、按值查找返回元素所在地址、按值查找返回元素所对应序号、结点插入和删除以及头插法和尾插法建立单链表等的实现与解析，链表学习记录。
单链表的基本操作（完整代码）
weixin_44195690的博客
08-05 1万+
函数说明????： LinkList List_HeadInsert(LinkList& L)：用头插法建立单链表 LinkList List_TailInsert(LinkList& L)：用尾插法建立单链表 LNode * GetElem(LinkList L, int i):按照序号查找结点值 LNode * LocateElem(LinkList L,int i) ：按值查找表结点 bool InsetElem(LinkList& L, int i, int e) :插入
C语言实现链表(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-14 1733
#include "stdio.h" #include "stdlib.h" #include "malloc.h" //5 个常量定义 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -1 //类型定义 typedef int Status; typedef int ElemType; //测试程序长度定义 #define LONGTH 5 //链表的类型 typedef struct LNode {
单链表基本操作代码实现【数据结构笔记】
m0_51336041的博客
05-22 690
带头结点
链表的基本操作源代码
weixin_30768661的博客
05-16 246
//链表的基本操含有对链表的建立，插入，删除，查询，输出等基本操作 /在此特别提醒链表的基础尤为重要，在这里重写此代码能够更加深刻的理解了链表的空间的申请， /头节点的建立以及头指针的重要和尾节点存在的必要性 /这个源代码以链表的创建为核心，为了怕麻烦就没有进行优化，但是创建和输出是这个代码的核心。 /希望这个能帮助到初学者，在这有不懂得地方可以看我的随笔，链表的整表的创建，那里有更加详细...
C语言单链表超市商品管理系统源码下载
总结，本资源"精选_基于C语言单链表实现的超市商品信息管理系统_源码打包"，涉及了C语言编程、单链表数据结构、文件操作等多个知识点。通过这个项目，可以学习到如何利用C语言进行实际项目的开发，包括基本的程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值