双向链表处理不定长数据的问题

最新推荐文章于 2022-10-23 16:23:19 发布
置顶 最新推荐文章于 2022-10-23 16:23:19 发布
阅读量208 收藏 1
点赞数 1
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/psr1999/article/details/120034141
版权

嵌入式系统 双向链表 内存管理 数据结构 节点操作
关键词由CSDN通过智能技术生成

双向链表处理不定长数据的问题

应用方面

在所有的嵌入式设备中，内存有限成了硬件的一个鸡肋，所以， 减少内存的使用 在嵌入式程序中尤为重要。而双向链表就是一种好的选择。

双向链表逻辑处理示意图

逻辑示意图

数据结构设置

typedef struct doubly_linked_list_s doubly_linked_list_t;

struct doubly_linked_list_s
{
	int list_id;
	int total_children;
	doubly_linked_list_t *children;
	doubly_linked_list_t *prev;
	doubly_linked_list_t *next;
};

初始化双向链表

typedef struct doubly_linked_list_s  doubly_linked_list;
doubly_linked_list *g_Parent = NULL;

doubly_linked_list *init_doubly_linked_list(void)
{
	if(NULL != g_Parent)
	{
		return g_Parent;
	}

	g_Parent = (doubly_linked_list*)malloc(sizeof(doubly_linked_list));
	if(NULL == g_Parent)
	{
		return NULL;
	}

	g_Parent->list_id = 0;
	g_Parent->total_children = 0;
	g_Parent->children = NULL;
	g_Parent->prev = g_Parent;
	g_Parent->next = g_Parent;

	return g_Parent;
}

双向链表节点内存的申请和释放

doubly_linked_list *doubly_linked_palloc(int id)
{
	doubly_linked_list* doubly_node = NULL;

	doubly_node = (doubly_linked_list*)malloc(sizeof(doubly_linked_list));
	if(NULL == doubly_node)
	{
		return NULL;
	}

	doubly_node->list_id = id;
	doubly_node->children = NULL;
	doubly_node->total_children = 0;
	doubly_node->next = doubly_node;
	doubly_node->prev = doubly_node;

	return doubly_node;
}


int doubly_linked_pfree(doubly_linked_list *p)
{
	doubly_linked_list *temp = NULL, *cur = NULL;;

	if(NULL == p)
	{
		return 0;
	}

	if(NULL != p->children)
	{	
		temp = p->children;	
	
		while(temp)
		{
			cur = temp;
			free(cur);
			cur = NULL;			
			temp = temp->next; 
		}	
	}

	p->children = NULL;
	p->next = NULL;
	p->prev = NULL;

	free(p);
	p = NULL;

	return 0;
}

初始化双向链表数据

doubly_linked_list *init_doubly_linked_list_data(doubly_linked_list* parent)
{
	int i = 0;
	int cnt = 0;
	doubly_linked_list *cur = NULL;
	doubly_linked_list *new = NULL;

	if(NULL == parent)
	{
		return NULL;
	}

	for(i = 0; i < TOTAL_ITEMS; i++)
	{
		new = doubly_linked_palloc(i);

		if(NULL == new)
		{
			break;
		}

		if(0 == i)
		{
			parent->children = new;
			cur = g_Parent->children;

		}
		else
		{
			new->prev = cur->prev;
			new->prev->next = new;
			new->next = cur;
			cur->prev = new;	
		}

		cnt++;
	}

	parent->total_children = cnt;

	return parent;
}

移除节点，但不释放内存

doubly_linked_list*  remove_from_doubly_linked_list(doubly_linked_list* parent, 
	doubly_linked_list* cur, int direction)
{
	if(NULL == parent || NULL == cur)
	{
		return NULL;
	}

	if(1 == direction)
	{
		(cur)->next->prev = (cur)->prev;
		(cur)->prev->next = (cur)->next;	
		parent->children = (cur)->next;	
	}
	else
	{
		cur->prev->next = cur->next;
		cur->next->prev = cur->prev;
	}
	
	(cur)->prev = NULL;
	(cur)->next = NULL;

	return cur;
}

数据在头部/末尾添加

doubly_linked_list*  insert_from_doubly_linked_list_tail(doubly_linked_list* parent, 
	doubly_linked_list* cur)
{
	if(NULL == parent || NULL == cur)
	{
		return NULL;
	}

	(cur)->prev = (parent)->prev;
	(cur)->prev->next = (cur);
	(cur)->next = (parent);
	(parent)->prev = (cur);
	
	return cur;
}


doubly_linked_list*  insert_from_doubly_linked_list_head(doubly_linked_list* parent, 
	doubly_linked_list* cur)
{
	if(NULL == parent || NULL == cur)
	{
		return NULL;
	}

	cur->next = parent;
	cur->prev = parent->prev;
	cur->prev->next = cur;
	parent->prev = cur;
	
	return cur;
}

向下/上移动操作的双向链表逻辑

int move_doubly_linked_list_down(doubly_linked_list* parent)
{
	doubly_linked_list* cur = NULL;	

	cur = remove_from_doubly_linked_list(parent, parent->children, DOWN_DIRE);

	if(NULL == cur)
	{
		return -1;
	}

	cur->list_id = parent->children->prev->list_id+1;

	insert_from_doubly_linked_list_tail(parent->children, cur);

	print_doubly_linked_list_data(parent);

	return 0;
}


int move_doubly_linked_list_up(doubly_linked_list* parent)
{
	doubly_linked_list* cur = NULL;	

	cur = remove_from_doubly_linked_list(parent, parent->children->prev, UP_DIRE);

	if(NULL == cur)
	{
		return -1;
	}

	cur->list_id = parent->children->list_id-1;

	insert_from_doubly_linked_list_head(parent->children, cur);
	parent->children = cur;

	print_doubly_linked_list_data(parent);

	return 0;
}

完整代码

#include <stdio.h>
#include <malloc.h>
#include <string.h>

#define UP_DIRE       0      // Move up flag
#define DOWN_DIRE     1      // Move down flag

#define TOTAL_ITEMS   10     // Maximum number of rows displayed. 

typedef struct doubly_linked_list_s doubly_linked_list_t;

struct doubly_linked_list_s
{
	int list_id;
	int total_children;
	doubly_linked_list_t *children;
	doubly_linked_list_t *prev;
	doubly_linked_list_t *next;
};

typedef struct doubly_linked_list_s  doubly_linked_list;
doubly_linked_list *g_Parent = NULL;

doubly_linked_list *init_doubly_linked_list(void)
{
	if(NULL != g_Parent)
	{
		return g_Parent;
	}

	g_Parent = (doubly_linked_list*)malloc(sizeof(doubly_linked_list));
	if(NULL == g_Parent)
	{
		return NULL;
	}

	g_Parent->list_id = 0;
	g_Parent->total_children = 0;
	g_Parent->children = NULL;
	g_Parent->prev = g_Parent;
	g_Parent->next = g_Parent;

	return g_Parent;
}


doubly_linked_list *doubly_linked_palloc(int id)
{
	doubly_linked_list* doubly_node = NULL;

	doubly_node = (doubly_linked_list*)malloc(sizeof(doubly_linked_list));
	if(NULL == doubly_node)
	{
		return NULL;
	}

	doubly_node->list_id = id;
	doubly_node->children = NULL;
	doubly_node->total_children = 0;
	doubly_node->next = doubly_node;
	doubly_node->prev = doubly_node;

	return doubly_node;
}


int doubly_linked_pfree(doubly_linked_list *p)
{
	doubly_linked_list *temp = NULL, *cur = NULL;;

	if(NULL == p)
	{
		return 0;
	}

	if(NULL != p->children)
	{	
		temp = p->children;	
	
		while(temp)
		{
			cur = temp;
			free(cur);
			cur = NULL;			
			temp = temp->next; 
		}	
	}

	p->children = NULL;
	p->next = NULL;
	p->prev = NULL;

	free(p);
	p = NULL;

	return 0;
}


doubly_linked_list *init_doubly_linked_list_data(doubly_linked_list* parent)
{
	int i = 0;
	int cnt = 0;
	doubly_linked_list *cur = NULL;
	doubly_linked_list *new = NULL;

	if(NULL == parent)
	{
		return NULL;
	}

	for(i = 0; i < TOTAL_ITEMS; i++)
	{
		new = doubly_linked_palloc(i);

		if(NULL == new)
		{
			break;
		}

		if(0 == i)
		{
			parent->children = new;
			cur = g_Parent->children;

		}
		else
		{
			new->prev = cur->prev;
			new->prev->next = new;
			new->next = cur;
			cur->prev = new;	
		}

		cnt++;
	}

	parent->total_children = cnt;

	return parent;
}

int print_doubly_linked_list_data(doubly_linked_list* parent)
{
	int i = 0;
	doubly_linked_list *cur = NULL;

	if(NULL == parent)
	{
		return -1;
	}

	cur = g_Parent->children;

	for(i = 0; i < parent->total_children && cur; i++)
	{
		printf("id = %d\n", cur->list_id);
		cur = cur->next;
	}

	printf("\n====================================\n");

	return 0;
}


doubly_linked_list*  remove_from_doubly_linked_list(doubly_linked_list* parent, 
	doubly_linked_list* cur, int direction)
{
	if(NULL == parent || NULL == cur)
	{
		return NULL;
	}

	if(1 == direction)
	{
		(cur)->next->prev = (cur)->prev;
		(cur)->prev->next = (cur)->next;	
		parent->children = (cur)->next;	
	}
	else
	{
		cur->prev->next = cur->next;
		cur->next->prev = cur->prev;
	}
	
	(cur)->prev = NULL;
	(cur)->next = NULL;

	return cur;
}

doubly_linked_list*  insert_from_doubly_linked_list_tail(doubly_linked_list* parent, 
	doubly_linked_list* cur)
{
	if(NULL == parent || NULL == cur)
	{
		return NULL;
	}

	(cur)->prev = (parent)->prev;
	(cur)->prev->next = (cur);
	(cur)->next = (parent);
	(parent)->prev = (cur);

	return cur;
}


doubly_linked_list*  insert_from_doubly_linked_list_head(doubly_linked_list* parent, 
	doubly_linked_list* cur)
{
	if(NULL == parent || NULL == cur)
	{
		return NULL;
	}

	cur->next = parent;
	cur->prev = parent->prev;
	cur->prev->next = cur;
	parent->prev = cur;


	return cur;
}

int move_doubly_linked_list_down(doubly_linked_list* parent)
{
	doubly_linked_list* cur = NULL;	

	cur = remove_from_doubly_linked_list(parent, parent->children, DOWN_DIRE);

	if(NULL == cur)
	{
		return -1;
	}

	cur->list_id = parent->children->prev->list_id+1;

	insert_from_doubly_linked_list_tail(parent->children, cur);

	print_doubly_linked_list_data(parent);

	return 0;
}


int move_doubly_linked_list_up(doubly_linked_list* parent)
{
	doubly_linked_list* cur = NULL;	

	cur = remove_from_doubly_linked_list(parent, parent->children->prev, UP_DIRE);

	if(NULL == cur)
	{
		return -1;
	}

	cur->list_id = parent->children->list_id-1;

	insert_from_doubly_linked_list_head(parent->children, cur);
	parent->children = cur;

	print_doubly_linked_list_data(parent);

	return 0;
}


int main(int argc, char const *argv[])
{
	
	init_doubly_linked_list();
	init_doubly_linked_list_data(g_Parent);
	print_doubly_linked_list_data(g_Parent);

	move_doubly_linked_list_down(g_Parent);
	move_doubly_linked_list_down(g_Parent);

	move_doubly_linked_list_up(g_Parent);
	move_doubly_linked_list_up(g_Parent);
	return 0;
}

总结

使用双向链表的特性之一，就是可以快速定位到末尾指针，这样可以在向下操作时，快速定位。

定长显示，只需要把第一个或者最后一个进行剔出，不需要释放内存，直接对该节点进行赋值即可，并修改双向链表的处理。

无聊写博客来玩玩
关注
专栏目录
【基本数据结构 二】线性数据结构：链表
MaoLin Tian's Blog
03-24 216
上一篇Blog理解了数组的定义、数组的存储、数组的使用和Array类等数组的基本知识，我们理解到数组是一种线性的固定长度连续内存空间的相同数据类型存储结构，而且随机访问的时间复杂度为O(1)，插入和删除的平均时间复杂度都是O(n)，其实我们经常拿数组和链表进行比较，那么这二者之间到底有什么差别呢？需要学习链表之后才能知道。 链表的定义 单链表 双向链表 循环链表 链表与数组 链表的存储 链表的使用 链表代码实现技巧 链表实现技巧 经典链表代码 单链表反转 链表中环的检测 两个有序链表的合并 删除链表中倒数第
如何用数组来模拟实现链表
浮晓悠羡
10-18 5369
习惯了定义一个Node类型作为链表的节点，如此一来，无论是插入、删除，还是查找，代码实现都非常便捷。但如果用数组来实现链表，又该如何去考虑呢？
c++ 不定长消息的处理
True Truth
08-22 428
在c++中，使用结构体来对地址上的数据进行标示，一般情况下，这给我们编程带来很大的变量，可以通过一个简单的机构处理千千万的数据。 但是最近我遇到一个难题，在传输结构中，数据不定长。这样的数据就超出了一个结构体的处理范围了。 大致是，我有个程序A，会输出随机的多个结果，将这些结果通过管道传递给另外一个程序B。 在B中我们知道结果的结构但是目前还不知道结果的个数。 这个时候我们可以在B中我们定义一个结...
c语言不定长参数处理,3.7 C语言不定长参数
weixin_39867327的博客
05-18 261
```c#include #include #include #include char *my(char *format, ...){va_list list;//1. 先获取格式化后字符串的长度va_start(list, format);int size = vsnprintf(NULL, 0, format, list);va_end(list);if(size <= 0) {ret...
C语言实使用不定长数组现双向循环链表库
王廷云的博客
03-28 580
不定长数组: 包含0个元素的数组，虽然不会分配空间，但会分配一个地址，只需把数据挂在这个地址上就可以了(当然,需要分配空间)。需要注意的是，这只是个地址不是指针变量，所以不能直接接收分配到的空间的地址。 文件分为两个文件：DoubleList.h 和 DoubleList.c 把两个文件放到同一目录，然后根据头文件的链表和节点的定义来声明数据就可以直接调用库文件中的函数。 Doubl...
不定长的指针数组 里面存字符串_redis数据结构与对象到底长什么样？
weixin_39915081的博客
11-26 128
写在前面前方高能！前方高能！前方高能！文章较长，可能需要花费您两个小时的时间，请做好心理准备，但是一旦你准备看下去，我相信您一定会有收获，不枉此行，let’s go!!!一、简单动态字符串说明：Redis没有直接使用C语言传统的字符串表示(以空字符结尾的字符数组， 以下简称C字符串) ， 而是自己构建了一种名为简单动态字符串(simple dynamic string， SDS) 的抽象...
【数据结构】不定长顺序表
weixin_56499830的博客
04-01 574
不定长顺序表，顾名思义，就是顺序表的长度不定，可以存放任意多个数据。与定长顺序表相比，它可以在顺序表长度不够用时自己进行扩容。那么在设计不定长的顺序表时，存放数据的数组就不能是固定长度的了，这时我们可以考虑用动态数组来代替，进行扩容时就可以动态申请内存，将数据存放到动态数组中。同时加入一个变量 list_size 来存放总的格子数（总容量）。结构如图： 结构体声明如下： typedef int ELEM_TYPE; #define MAX_SIZE 10 typedef struct Dsql
链表的基本概念以及java实现单链表-循环链表-双向链表
mcrwayfun，欢迎你
07-19 1839
前言 线性结构是非常简单且常用的数据结构，而线性表则是一种非常典型的线性结构。 线性表定义 线性表的数据结构 链表 单链表 单链表的定义 单链表的插入和删除 单链表的遍历，清空，判空，获取指定结点 循环链表 循环链表的定义 循环链表的插入和删除 循环链表的遍历，清空 双向链表 双向链表的定义 双向链表的插入和删除 本节代码传送门，欢迎star：https://github...
基础数据结构（简单的数据结构，主要有链表、栈、队列以及常见的排序算法）.pdf
11-18
链表分为单向链表、双向链表和循环链表等不同类型，每种类型有不同的操作特性。 栈是一种“后进先出”（LIFO）的数据结构，常被比喻为一叠盘子。栈的主要操作有压栈（添加元素至栈顶）和弹栈（移除栈顶元素）。栈在...
不定长内存池算法
04-08
- 不定长内存池需要处理内存碎片问题。如果分配的内存块大小不一，可能导致大量小碎片，影响内存利用率。因此，内存池可能会采用分桶策略，每个桶对应一种内存块大小，减少碎片。 - 为了有效地回收内存，内存池...
c语言创建不定长链表,不定长链表队列C语言实现
weixin_29038303的博客
05-23 319
#ifndef _CONST_H_#define _CONST_H_#include #include typedef enum{False = 0,True,}Bool;typedef int ElemType;#define QUEUE_MAX_SIZE 10#define STACK_INIT_SIZE 10#define STACK_INCREMENT_SIZE 2#define Null...
数据结构——链表
qq_43589840的博客
09-20 346
链表（Linked list） 1 相关概念 链表是一种常用的数据结构，它通过指针将一些列数据结点，连接成一个数据链。 优点： 动态数据结构：相对于数组，具有更好的动态性（非顺序存储）； 内存利用率高：建立链表时无需预先知道数据总量大小，可随机的分配空间；链表大小可在程序运行时增加或减少； 易于插入和删除 缺点： 内存使用：数组只需要数据域空间，链表每个节点都包含指针域，其需要额外的内存空间； 遍历困难：链表随机访问的性能没有数组好，需要 O(n) 的时间复杂度； 链表数组性能对比： 常见的链表种
【顺序表】不定长顺序表
最新发布
lxylxylxy的博客
10-23 163
不定长顺序表与定长顺序表的区别点
c语言创建不定长链表,不定长链表队列C语言实现(示例代码)
weixin_35717251的博客
05-23 492
#ifndef _CONST_H_#define _CONST_H_#include #include typedef enum{False = 0,True,}Bool;typedef int ElemType;#define QUEUE_MAX_SIZE 10#define STACK_INIT_SIZE 10#define STACK_INCREMENT_SIZE 2#define Null...
不定长链表队列C语言实现
weixin_30929011的博客
01-04 213
#ifndef _CONST_H_#define _CONST_H_ #include <stdio.h>#include <stdlib.h> typedef enum { False = 0, True,}Bool; typedef int ElemType; #define QUEUE_MAX_SIZE 10 #define STACK_INIT_...
串口接收不定长数据的几种方式
热门推荐
main_h_的博客
09-11 2万+
在阅读本文前，你需要先做到串口成功接收一个数据（相信这一点是很简单的） 这几天简单总结了一下用串口怎么接收一帧数据的办法，个人使用的有三种，下面逐一介绍： 第一种：使用中断的方式； 这种在数据接收不频繁状态下使用。简单易实现。既然是使用中断，所以自然需要硬件的支持，比如stm32就可以这么做，具体操作见我之前的博客stm32串口中断接收一帧数据 8位单片机估计是没有的，嵌入式32位的处
处理串口接收不定长数据的另一种解决方法
静静流淌的柯溪的博客
12-05 7579
开发平台：Keil 5 库函数版本：V3.5 芯片：STM32F103CBT6 之前我在我的另一篇博客中介绍过使用串口空闲中断+DMA的方式来处理不定长数据，没有看过的同学可以点击这里查看。今天要介绍另一种接收不定长数据的方法。 使用的是接收中断和和空闲中断结合的方式。大概思路是：我们在串口配置的时候先只开串口接收完成中断，然后在接收中断中再开启空闲中断，当空闲中断发生时，表明本次数据接收完成，再...
数据结构讲解：循环链表与双向链表操作
总结来说，循环链表和双向链表在数据结构中占有重要地位，它们在处理特定类型的数据问题时提供了更多的灵活性和效率。理解并熟练掌握这些概念及其操作，对于编写高效算法和优化数据结构至关重要。在实际编程中，根据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值