C语言模拟进栈出栈，先进先出先进后出共用内存

最新推荐文章于 2024-05-14 09:14:26 发布
最新推荐文章于 2024-05-14 09:14:26 发布
阅读量846 收藏 6
点赞数 1
分类专栏： stm32 文章标签： c语言 算法 进栈出栈 内存 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27620407/article/details/115568729
版权

本次程序可用于串口通讯缓存等，起因是UCOS的通知没有达到预想的效果。
例程包括基础数字型和实用结构体型。
本程序主体由一个结构体和三个函数组成：

一个结构体

内存和当前栈内数据长度

typedef struct Stack
{
	int Data[Data_Len];
	int P_Active;    //当前栈长 
} My_Stack_type;

三个函数

第一个函数：进栈

int Stack_Push(My_Stack_type *Stack_Active,int Data) //进栈
从内存数组的0元素开始存数，累加存。

Data Num:0 Data:
进栈成功0=0
Data Num:0 Data:
进栈成功1=10
Data Num:1 Data:0
进栈成功2=20
Data Num:2 Data:0 10
进栈成功3=30
Data Num:3 Data:0 10 20
进栈成功4=40
Data Num:4 Data:0 10 20 30
进栈成功5=50
Data Num:5 Data:0 10 20 30 40
进栈成功6=60
Data Num:6 Data:0 10 20 30 40 50
进栈成功7=70
Data Num:7 Data:0 10 20 30 40 50 60
进栈成功8=80
Data Num:8 Data:0 10 20 30 40 50 60 70
进栈成功9=90
Data Num:9 Data:0 10 20 30 40 50 60 70 80
进栈失败，数据过多
进栈失败，数据过多

第二个函数：先进后出出栈

int Stack_FILO_Pop(My_Stack_type *Stack_Active,int *Data) //先进后出出栈
从内存数组的最后进的数开始出

Data Num:10 Data:0 10 20 30 40 50 60 70 80 90
出栈成功9=90
Data Num:9 Data:0 10 20 30 40 50 60 70 80
出栈成功8=80
Data Num:8 Data:0 10 20 30 40 50 60 70
出栈成功7=70

第三个函数：先进先出出栈

int Stack_FIFO_Pop(My_Stack_type *Stack_Active,int *Data) //先进先出出栈
从最先放入的数据开始出，并将后放入的数据前移

Data Num:7 Data:0 10 20 30 40 50 60
出栈成功0
Data Num:6 Data:10 20 30 40 50 60
出栈成功10
Data Num:5 Data:20 30 40 50 60
出栈成功20
Data Num:4 Data:30 40 50 60

完整例程

#include <stdio.h>

#define Debug_En 0 
#define Data_Len 10
typedef struct Stack
{
	int Data[Data_Len];
	int P_Active;    //当前栈长 
} My_Stack_type;

My_Stack_type My_Stack;

int Stack_Push(My_Stack_type *Stack_Active,int Data)  //进栈 
{
	if(Stack_Active->P_Active<Data_Len)
	{
		Stack_Active->Data[Stack_Active->P_Active]=Data;
		#if Debug_En
			printf("进栈成功%d=%d\r\n",Stack_Active->P_Active,Stack_Active->Data[Stack_Active->P_Active]); 
			Stack_Show(Stack_Active);
		#endif
		Stack_Active->P_Active++;
		return 0; 
	}else{
		#if Debug_En
			printf("进栈失败，数据过多\r\n"); 
		#endif
		return 1;  //数据过多 
	}
}

int Stack_FILO_Pop(My_Stack_type *Stack_Active,int *Data)   //先进后出出栈 
{
	if(Stack_Active->P_Active)
	{
		Stack_Active->P_Active--;
		*Data=Stack_Active->Data[Stack_Active->P_Active];
		#if Debug_En
			printf("出栈成功%d=%d\r\n",Stack_Active->P_Active,*Data); 
			Stack_Show(Stack_Active);
		#endif
		return 0; 
	}else{
		printf("出栈失败，数据为空\r\n"); 
		return 1;  //数据过多 
	}
}
int Stack_FIFO_Pop(My_Stack_type *Stack_Active,int *Data)   //先进先出出栈 
{
	int i=0;
	if(Stack_Active->P_Active)
	{
		*Data=Stack_Active->Data[0];
		#if Debug_En
			printf("出栈成功%d\r\n",*Data);
		#endif
		for(i=0;i<Stack_Active->P_Active;i++)
		{
			Stack_Active->Data[i]=Stack_Active->Data[i+1];
		}
		Stack_Active->P_Active--;
		#if Debug_En
			Stack_Show(Stack_Active);
		#endif
		return 0; 
	}else{
		#if Debug_En
			printf("出栈失败，数据为空\r\n"); 
		#endif
		return 1;  //数据过多 
	}
}
int Stack_Show(My_Stack_type *Stack_Active)//打印内存 
{
	int i=0;
	printf("Data Num:%d Data:",Stack_Active->P_Active);
	for(i=0;i<Stack_Active->P_Active;i++)
	{
		printf("%d ",Stack_Active->Data[i]);
	}
	printf("\r\n");
}


int main(int argc, char *argv[])
{
	int i=0;
	int Data;
	Stack_Show(&My_Stack);
	for(i=0;i<12;i++)
	{
		Stack_Push(&My_Stack,i*10);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<3;i++)
	{
		Stack_FILO_Pop(&My_Stack,&Data);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<3;i++)
	{
		Stack_FIFO_Pop(&My_Stack,&Data);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<12;i++)
	{
		Stack_Push(&My_Stack,i*10);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<3;i++)
	{
		Stack_FILO_Pop(&My_Stack,&Data);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<20;i++)
	{
		Stack_FIFO_Pop(&My_Stack,&Data);
	}
	Stack_Show(&My_Stack);
	return 0;
}

实际运行截图

Data Num:0 Data:
进栈成功0=0
Data Num:0 Data:
进栈成功1=10
Data Num:1 Data:0
进栈成功2=20
Data Num:2 Data:0 10
进栈成功3=30
Data Num:3 Data:0 10 20
进栈成功4=40
Data Num:4 Data:0 10 20 30
进栈成功5=50
Data Num:5 Data:0 10 20 30 40
进栈成功6=60
Data Num:6 Data:0 10 20 30 40 50
进栈成功7=70
Data Num:7 Data:0 10 20 30 40 50 60
进栈成功8=80
Data Num:8 Data:0 10 20 30 40 50 60 70
进栈成功9=90
Data Num:9 Data:0 10 20 30 40 50 60 70 80
进栈失败，数据过多
进栈失败，数据过多
Data Num:10 Data:0 10 20 30 40 50 60 70 80 90
出栈成功9=90
Data Num:9 Data:0 10 20 30 40 50 60 70 80
出栈成功8=80
Data Num:8 Data:0 10 20 30 40 50 60 70
出栈成功7=70
Data Num:7 Data:0 10 20 30 40 50 60
Data Num:7 Data:0 10 20 30 40 50 60
出栈成功0
Data Num:6 Data:10 20 30 40 50 60
出栈成功10
Data Num:5 Data:20 30 40 50 60
出栈成功20
Data Num:4 Data:30 40 50 60
Data Num:4 Data:30 40 50 60
进栈成功4=0
Data Num:4 Data:30 40 50 60
进栈成功5=10
Data Num:5 Data:30 40 50 60 0
进栈成功6=20
Data Num:6 Data:30 40 50 60 0 10
进栈成功7=30
Data Num:7 Data:30 40 50 60 0 10 20
进栈成功8=40
Data Num:8 Data:30 40 50 60 0 10 20 30
进栈成功9=50
Data Num:9 Data:30 40 50 60 0 10 20 30 40
进栈失败，数据过多
进栈失败，数据过多
进栈失败，数据过多
进栈失败，数据过多
进栈失败，数据过多
进栈失败，数据过多
Data Num:10 Data:30 40 50 60 0 10 20 30 40 50
出栈成功9=50
Data Num:9 Data:30 40 50 60 0 10 20 30 40
出栈成功8=40
Data Num:8 Data:30 40 50 60 0 10 20 30
出栈成功7=30
Data Num:7 Data:30 40 50 60 0 10 20
Data Num:7 Data:30 40 50 60 0 10 20
出栈成功30
Data Num:6 Data:40 50 60 0 10 20
出栈成功40
Data Num:5 Data:50 60 0 10 20
出栈成功50
Data Num:4 Data:60 0 10 20
出栈成功60
Data Num:3 Data:0 10 20
出栈成功0
Data Num:2 Data:10 20
出栈成功10
Data Num:1 Data:20
出栈成功20
Data Num:0 Data:
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
出栈失败，数据为空
Data Num:0 Data:

实用结构体型：

#include <stdio.h>

#define Debug_En 1 
#define Data_num 100
#define Data_Len 50
typedef struct
{
	int RealData[Data_num];
	int Sta;
}Stack_Data;

typedef struct Stack
{
	Stack_Data Data[Data_Len];
	int P_Active;    //当前栈长  
} My_Stack_type;

My_Stack_type My_Stack;

int Stack_Push(My_Stack_type *Stack_Active,Stack_Data *Data)  ///进栈 
{
	if(Stack_Active->P_Active<Data_Len)
	{
		Stack_Active->Data[Stack_Active->P_Active]=*Data;
		#if Debug_En
			printf("进栈成功%d=%d %d \r\n",Stack_Active->P_Active,
		Stack_Active->Data[Stack_Active->P_Active].Sta,
		Stack_Active->Data[Stack_Active->P_Active].RealData[0]); 
		#endif	
		Stack_Active->P_Active++;
		#if Debug_En
			Stack_Show(Stack_Active);
		#endif
		return 0; 
	}else{
		#if Debug_En
			printf("进栈失败，数据过多\r\n"); 
		#endif
		return 1;   
	}
}

int Stack_FILO_Pop(My_Stack_type *Stack_Active,Stack_Data *Data)   //先进后出出栈 
{
	if(Stack_Active->P_Active)
	{
		Stack_Active->P_Active--;
		*Data=Stack_Active->Data[Stack_Active->P_Active];
		#if Debug_En
			printf("出栈成功%d=%d %d\r\n",Stack_Active->P_Active,Data->Sta,Data->RealData[0]); 
			Stack_Show(Stack_Active);
		#endif
		return 0; 
	}else{
		printf("出栈失败，数据为空\r\n"); 
		return 1;   
	}
}
int Stack_FIFO_Pop(My_Stack_type *Stack_Active,Stack_Data *Data)   //先进先出出栈 
{
	int i=0;
	if(Stack_Active->P_Active)
	{
		*Data=Stack_Active->Data[0];
		#if Debug_En
			printf("出栈成功%d=%d %d\r\n",Stack_Active->P_Active,Data->Sta,Data->RealData[0]);
		#endif
		for(i=0;i<Stack_Active->P_Active;i++)
		{
			Stack_Active->Data[i]=Stack_Active->Data[i+1];
		}
		Stack_Active->P_Active--;
		#if Debug_En
			Stack_Show(Stack_Active);
		#endif
		return 0; 
	}else{
		#if Debug_En
			printf("出栈失败，数据为空\r\n"); 
		#endif
		return 1;   
	}
}
int Stack_Show(My_Stack_type *Stack_Active)//打印内存 
{
	int i=0;
	printf("Data Num:%d Data:",Stack_Active->P_Active);
	for(i=0;i<Stack_Active->P_Active;i++)
	{
		printf("%d %d|",Stack_Active->Data[i].Sta,Stack_Active->Data[i].RealData[0]);
	}
	printf("\r\n");
}


int main(int argc, char *argv[])
{
	int i=0;
	int Data;
	Stack_Data Stack_Data_DIs;

	for(i=0;i<12;i++)
	{
		Stack_Data_DIs.Sta=i*10;
		Stack_Data_DIs.RealData[0]=10+i;
		Stack_Push(&My_Stack,&Stack_Data_DIs);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<3;i++)
	{
		Stack_FILO_Pop(&My_Stack,&Stack_Data_DIs);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<3;i++)
	{
		Stack_FIFO_Pop(&My_Stack,&Stack_Data_DIs);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<12;i++)
	{
		Stack_Data_DIs.Sta=i*10;
		Stack_Data_DIs.RealData[0]=10+i;
		Stack_Push(&My_Stack,&Stack_Data_DIs);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<3;i++)
	{
		Stack_FILO_Pop(&My_Stack,&Stack_Data_DIs);
	}
	Stack_Show(&My_Stack);
	for(i=0;i<20;i++)
	{
		Stack_FIFO_Pop(&My_Stack,&Stack_Data_DIs);
	}
	Stack_Show(&My_Stack);
	return 0;
}
物极必反1024
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现的 通用FIFO 先进先出队列
05-14
一共有三个接口 //P_FIFO_T FIFO_Creat(int nNodeMax, int nNodeSize); //void FIFO_Push(P_FIFO_T hFifo, void *pvBuff); //char * FIFO_Pop(P_FIFO_T hFifo); 在下不才，如有不对，请大家评论啊。
操作系统页面置换算法之先进先出(FIFO)页面置换算法（C语言实现）
CuriosityCAX的博客
12-08 6578
先进先出（FIFO）页面置换算法 【注】本代码数据及思路方法参考自《计算机操作系统（第四版）》汤小丹等 编著的教材。 #include <iostream> int accessPage[20] = { 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1 }; int flagFIFO[3] = { -1, -1, -1 }; // 用来在FIFO算法中标记三个物理块装入页面的时间 int physicalBlock[3] = { -1,-1,-1 };
C语言——栈和队列
最新发布
super_coders的博客
05-14 415
ps->a我们有两种初始化方法，一种是直接malloc一个空间，可以是四个或者八个对象的空间，也可以像我一样，先不开，等会入栈的时候再开。栈是一种特殊的线性表，限定仅在表尾进行插入和删除的线性表。在进行入栈以前，先把top指向为栈顶的下一个数据，如果指向栈顶数据的话，初始化就不能为0。队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。栈的实现一般使用数组或者链表，因为cpu高速缓存的原因，使用数组也非常ok。希望这篇博客对你有所帮助！头文件：Queue.h。
c语言怎样实现串行通信存储,C语言实现串行通信接口程序
weixin_39794130的博客
05-17 469
C语言实现串行通信接口程序摘 要 本文说明了异步串行通信(RS-232)的工作方式，探讨了查询和中断两种软件接口利弊，并给出两种方式的C语言源程序。的I/O通道之一，以最简单方式组成的串行双工线路只需两条信号线和一条公共地线，因此串行通信既有线路简单的优点同时也有它的缺点，即通信速率无法同并行通信相比，实际上EIA RS-232C在标准条件下的最大通信速率仅为20Kb/S。尽管如此，大多数外设都提...
【C语言】向一个按照顺序排好的数组中插入一个数，然后再次按原顺序排好
weixin_46545179的博客
10-14 1870
向一个按照顺序排好的数组中插入一个数，然后再次按原顺序排好
C语言数据的存储
yuanhang690的博客
01-18 557
C语言数据的存储，int型，char型，以及浮点型float/double，整形提升。有符号char和无符号char的取值范围。
C 数据结构 —— 先入先出
qq_28499879的博客
04-09 1257
创建相关节点： #include <stdio.h> #include <linux/mutex.h> struct fifo_node { int some_data; struct fifo_node *next; }; struct fifo_queue { struct mutex lock; struct fifo_node *head; struct fifo_node *tail; }; static fifo_queue
集合的应用——利用LinkedList模拟进栈出栈操作.zip
11-19
栈是一种后进先出（LIFO）的数据结构，其核心操作包括push（入栈）和pop（出栈）。在`StringStack1.java`中，我们可能会看到一个使用LinkedList作为底层数据结构的栈实现。LinkedList的addFirst()方法用于模拟push...
TIA博途SCL学习-堆栈的入栈和出栈（后入先出）程序示例.docx
01-04
堆栈是一种遵循“后入先出”（Last In, First Out，简称LIFO）原则的数据结构。这意味着最后进入堆栈的数据会最先被取出。在SCL编程中，我们可以利用数组来模拟堆栈的功能。 1. 入栈操作： 在SCL中，我们可以创建...
基于TIA博途的堆栈算法（先进后出）SCL语言程序（V15版本）.docx
11-19
在堆栈中，数据的存取只允许在栈顶进行，即新进栈的数据将位于旧数据之上，而当需要出栈时，最先进栈的数据会最先被移除。这种特性使得堆栈在许多计算任务中，如函数调用、表达式求解和内存管理等场景中具有重要作用...
程序设计 进栈出栈.vcxproj.filters
06-26
程序设计 进栈出栈.vcxproj.filters
汇编言语——进栈出栈指令PPT学习教案.pptx
10-05
* 例6.1展示了PUSH指令和POP指令对堆栈的影响， AX＝4F8AH，BX＝307CH，SP＝1000H，分别逐条执行下列指令，用内存图的形式画出堆栈的变化情况，并分析程序段执行完后AX和BX寄存器的值。 本PPT学习教案详细讲解了...
C语言存储数字,C语言数据的存储和取出详细讲解
weixin_33628926的博客
05-17 908
数据的存储和取出整形的储存我们知道一个整形的存储是以补码的形式储存取出是原码的形式。比如：int a = 5;的二进制是101那它的原码应该是：00000000 00000000 00000000 00000101正数的原反补相同那它存进去和取出来都是：00000000 00000000 00000000 00000101那float a = 5.5;也是四个字节它和整形存储的方式一样吗？浮点型的...
c语言实现先进先出的链表,先进先出（FIFO）页面置换算法 C语言实现
weixin_39988331的博客
05-21 1118
广东工业大学 操作系统实验实验内容假设每个页面中可存放10条指令，分配给作业的内存块数为4。用C语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。如果4个内存块均已装入该作业，则需进行页...
c语言实现队列的先进先出操作
仗劍走天涯
01-07 6351
队列的特点是先进先出，有一个队列头和一个队列尾。如下图示：整个队列含有一个队列头指针front和一个队列尾指针rear，并且队列中每个节点中包含一个数据域和一个指向下一个节点的指针域。 定义一个节点： typedef struct _node{ int data; struct _node *next; }node; 定义队列结构体： typedef struct { nod...
先进先出置换算法实现请求分页存储管理(C语言)
qq_38902844的博客
05-23 2359
要求 作业共有320条指令，假设每个页面存放10条指令，它的地址空间为32页，初始状态所有页都未调入内存。 分配给作业的内存块数为4。 如果访问的指令在内存，则显示其物理地址，转入下一条指令，否则发生缺页，此时记录缺页次数，将相应页调入内存； 如果4个内存块均已占用，需进行页面置换，最后显示其物理地址，并转入下一条指令。 在所有320条指令执行完毕后，计算并显示作业运行过程中发生的缺页率。 作业中指令的访问次序按下述原则生成： 1、在[0，319]之间随机选取一条起始指令，序号为m ； 2、顺序执行下一条
c语言先进先出数组实现,数据结构——C语言实现队列
weixin_31100517的博客
05-21 1135
C语言实现队列1.队列的结构及相关概念队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out)的特性。入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头 2.队列的实现：队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数 组头上出数据，效率会比较低。下面...
用C语言实现先进后出的数据结构---栈
m0_46611602的博客
06-30 1379
数据结构----栈 一、基本概念 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 ---百度百科 二、用C语言实现栈 1.定义栈
先进先出 c语言 函数,定义一个数组，先进先出。怎样做效率高1点
weixin_28931449的博客
05-20 1123
定义一个数组，先进先出。怎样做效率高一点本帖最后由 xia8710279 于 2014-07-05 20:55:46 编辑自己想的方法unsignedcharA_buff[MAX_NUM];//定义一个数组，长度为MAX_NUMunsignedcharHeadNum=MAX_NUM;//堆栈的头的编号unsignedcharEndNum=MAX_NUM;...
c语言进栈出栈完整代码
12-08
以下是C语言实现栈的完整代码，包括初始化栈、扩容、入栈、出栈、获取栈顶元素、获取栈中有效元素个数、检测栈是否为空和销毁栈等操作： ```c #include #include #include #define STACK_SIZE 4 // 初始容量 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值