C语言——两个栈实现一个队与两个队实现一个栈

最新推荐文章于 2023-07-01 11:29:47 发布
最新推荐文章于 2023-07-01 11:29:47 发布
阅读量204 收藏 1
点赞数
文章标签： c语言 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wly2333777/article/details/128871988
版权

C语言——两个栈实现一个队与两个队实现一个栈

两个栈实现一个队

定义栈的头文件

#ifndef _STACK_H
#define _STACK_H

enum res
{
	FULL=-2,
	EMPTY,
	StackNULL,
	OK
};
//定义数据元素
typedef int data_type;
//定义栈
typedef struct stack
{
	data_type * p_data;//数据存储首地址
	int size;//最大个数
	int top;//栈顶下标
}Stack;
//创建栈，输入size，返回结构体首地址
Stack * createStack(int size);


//入栈
int pushStack(Stack * pStack,data_type item);

//展示
int showStack(Stack * pStack);

//出栈
int popStack(Stack * pStack,data_type * pItem);

//销毁
int destroyStack(Stack ** ppStack);

//菜单
void menu();


int outStackQueue(Stack * pStack1,Stack * pStack2);


#endif

定义栈函数

栈函数中实现了栈的添加、删除、销毁、查看

#include <stdio.h>
#include "../include/stack.h"
#include <stdlib.h>
#include <string.h>


//创建栈
Stack * createStack(int size)
{
		//动态分配栈大小
		//结构体分配空间
		Stack * pStack=NULL;
		pStack=(Stack *)malloc(sizeof(Stack));
		//判断空间是否分配成功
		if(pStack == NULL)
		{
			perror("malloc error");
			return NULL;
		}
		//重置空间，首地址，值，大小
		memset(pStack,0,sizeof(Stack));
		// 设置栈顶
		pStack->top=-1;
		//分配数据空间
		//开辟数据的空间,结构体中的p_data为其首地址
		pStack->p_data=(data_type *)malloc(size*sizeof(data_type));
		if(pStack->p_data == NULL)
		{
			perror("malloc error");
			return NULL;
		}
		pStack->size=size;
		return pStack;
}
//插入
int pushStack(Stack * pStack,data_type item)
{
	if(pStack == NULL)
	{
		return StackNULL;
	}
	
	if(pStack->top==pStack->size-1)
	{
		return FULL;
	}

	//栈顶下标
	pStack->top++;
	//栈顶添加元素
	pStack->p_data[pStack->top]=item;
	return OK;
}
//展示
int showStack(Stack * pStack)
{
	if(pStack == NULL)
	{
		return StackNULL;
	}
	int i=0;
	for(i=0;i<=pStack->top;i++)
	{
		printf("%5d",pStack->p_data[i]);
	}
	printf("\n");
}
//出栈
//Pitem:删除后保存的数据
int popStack(Stack * pStack,data_type * Pitem)
{
	if(pStack == NULL)
	{
		return StackNULL;
	}
	if(pStack->top==-1)
	{
		return EMPTY;
	}
	*Pitem=pStack->p_data[pStack->top];
	pStack->top--;
	return OK;
}
//销毁空间
int destroyStack(Stack ** ppStack)
{
	if(*ppStack == NULL)
	{
		return StackNULL;
	}
	free((*ppStack)->p_data);
	free(*ppStack);
	*ppStack=NULL;
	return OK;
}

实现两个栈模拟一个队

#include <stdio.h>
#include "../include/stack.h"



int main()
{	
	Stack * pStack1=NULL;
	Stack * pStack2=NULL;
	int size=0;
	int op=0;
	data_type item;
	printf("请输入您要创建的队的大小\n");
	scanf("%d",&size);
	//创建栈
	pStack1=createStack(size);
	pStack2=createStack(size);
	while(1)
	{
		printf("请输入选项：------1:入队/2：出队\n");
		scanf("%d",&op);
		if(op == -1)break;
		switch(op)
		{
			case 1:
				//入队
				printf("请输入你要插入的元素\n");
				scanf("%d",&item);
				pushStack(pStack1,item);
				break;
			
			case 2:
				//出队
				outStackQueue(pStack1,pStack2);
				
				break;
		}
		showStack(pStack1);
		showStack(pStack2);
	}
	return 0;

}
//出队

int outStackQueue(Stack * pStack1,Stack * pStack2)
{	
	
	data_type q_item,p_item;
	if((pStack1->top)==0) 
	{
		popStack(pStack1,&q_item);
		return OK;
	}
	while(1)
	{
		//出1
		popStack(pStack1,&q_item);
		//入2
		pushStack(pStack2,q_item);
		if((pStack1->top)==-1) break;
	}
	//出2
	popStack(pStack2,&p_item);
	printf("出队======%d\n",p_item);
	//入1
	
	while(1)
	{
		if((pStack2->top)==-1) break;
		//出2
		popStack(pStack2,&p_item);
		//入1
		pushStack(pStack1,p_item);
		
	}
	
	return OK;
}

两个队实现一个栈

定义队的头文件

#ifndef _QUEUE_H
#define _QUEUE_H

enum res
{
	EMPTY=-4,
	FULL,
	POSERR,
	QUEUENULL,
	OK
};
//定义数据元素
typedef int data_type;
//定义顺序队列
typedef struct queue
{
	data_type * p_data;//数据存储首地址
	int size;//最大个数
	int front;//队头
	int rear;//队尾始终指向下一个入队元素
}Queue;
//创建顺序队列，输入size，返回结构体首地址
Queue * createQueue(int size);


//插入
int inQueue(Queue * pQueue,data_type item);

//展示
int showQueue(Queue * pQueue);

//删除
int outQueue(Queue * pQueue,data_type * Pitem);

//销毁
int destroyQueue(Queue ** ppQueue);



//菜单
void menu();

//模拟出栈
int outQueueStack(Queue * pQueue1,Queue * pQueue2);


#endif

定义队函数

#include <stdio.h>
#include "../include/queue.h"
#include <stdlib.h>
#include <string.h>


//创建顺序表
Queue * createQueue(int size)
{
		//动态分配顺序表大小
		//结构体分配空间
		Queue * pQueue=NULL;
		pQueue=(Queue *)malloc(sizeof(Queue));
		//判断空间是否分配成功
		if(pQueue == NULL)
		{
			perror("malloc error");
			return NULL;
		}
		//重置空间，首地址，值，大小
		memset(pQueue,0,sizeof(Queue));
		//对头与对尾
		//分配数据空间
		//开辟数据的空间,结构体中的p_data为其首地址
		pQueue->p_data=(data_type *)malloc(size*sizeof(data_type));
		if(pQueue->p_data == NULL)
		{
			perror("malloc error");
			return NULL;
		}
		pQueue->size=size;
		pQueue->front=pQueue->size-1;
		pQueue->rear=pQueue->size-1;
		return pQueue;
}
//插入，在队尾插入
int inQueue(Queue * pQueue,data_type item)
{
	if(pQueue == NULL)
	{
		return POSERR;
	}
	if((pQueue->rear+1)%pQueue->size==pQueue->front)
	{
		printf("队满\n");
		return FULL;
	}
	//插入
	//队尾指向下一个入队元素
	pQueue->rear=(pQueue->rear+1)%(pQueue->size);
	pQueue->p_data[pQueue->rear]=item;
	return OK;
}
//展示
int showQueue(Queue * pQueue)
{
	if(pQueue == NULL)
	{
		return POSERR;
	}
	if((pQueue->front)==(pQueue->rear))
	{
		printf("队空\n");
	 	return QUEUENULL;
	}
	int i=0;
	for(i=0;i<(pQueue->rear+1)%(pQueue->size);i++)
	{
		printf("%5d",pQueue->p_data[(pQueue->front+1)%(pQueue->size)+i]);
	}
	printf("\n");
}
//出队：队头删除，每删除一个元素，队头加1；
//Pitem:删除后保存的数据
int outQueue(Queue * pQueue,data_type * Pitem)
{
	if(pQueue == NULL)
	{
		return POSERR;
	}
	if((pQueue->front)==(pQueue->rear))
	{
		printf("队空\n");
	 	return QUEUENULL;
	}
	pQueue->front=(pQueue->front+1)%pQueue->size;
	*Pitem=pQueue->p_data[pQueue->front];

	return OK;
}
//销毁空间
int destroyQueue(Queue ** ppQueue)
{
	if(*ppQueue == NULL)
	{
		return POSERR;
	}
	free((*ppQueue)->p_data);
	free(*ppQueue);
	*ppQueue=NULL;
	return OK;
}

实现两个队模拟一个栈

#include <stdio.h>
#include "../include/queue.h"



int main()
{	
	Queue * pQueue1=NULL;
	Queue * pQueue2=NULL;
	int size=0;
	int op=0;
	data_type item;
	printf("请输入您要创建的栈的大小\n");
	scanf("%d",&size);
	//创建队
	pQueue1=createQueue(size);
	pQueue2=createQueue(size);
	while(1)
	{
		printf("请输入选项：------1:入栈/2：出栈\n");
		scanf("%d",&op);
		if(op == -1)break;
		switch(op)
		{
			case 1:
				//入栈
				printf("请输入你要插入的元素\n");
				scanf("%d",&item);
				inQueue(pQueue1,item);
				break;
			case 2:
				//出栈
				outQueueStack(pQueue1,pQueue2);
				
				break;
		}

	}
	return 0;

}
//出栈

int outQueueStack(Queue * pQueue1,Queue * pQueue2)
{	
	
	data_type q_item,p_item;
	while(1)
	{
		//出1
		outQueue(pQueue1,&q_item);
		//入2
		inQueue(pQueue2,q_item);
		//1空结束
		if(((pQueue1->front)==(pQueue1->rear))) break;
	}
	//出2
	outQueue(pQueue2,&p_item);
	printf("出栈======%d\n",p_item);
	
	while(1)
	{
		//2空结束
		if((pQueue2->front)==(pQueue2->rear)) break;
		//出2
		outQueue(pQueue2,&p_item);
		//入1
		inQueue(pQueue1,p_item);
		
	}
	
	return OK;
}

！！！为了防止队列的指针溢出，本篇采用循环队列解决队列指针溢出，
因为删除队列是更改队头指针，队列中的数据并未删除，所以显示队列会显示队列中的所有元素，而不会只显示有效元素
！！！！求个只显示有效元素的方法

n . x
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用两个队列实现栈——C语言实现
sinat_32092165的博客
03-30 2058
如何用两个队列实现栈？ 思路分析：建立队列q1，在第队列中入队元素1，2，3，4。 我们知道，队列是先进先出的，如果出队的话，得到的元素是1，而不是4。而按照栈的要求，出栈的元素应该是4. 那么怎样得到队列的最后一个元素4呢？这个时候，就要借助第二个队列了。建立空队列q2，我们可以将队列的中元素一个个出队，然后将出来的元素入队到队列q2中。这样，分别将1，2，3从队列q1中出队，然后入队队列...
用两个栈实现队列
weixin_45674536的博客
09-07 116
用两个栈实现队列
C语言 | 如何用两个栈模拟队列
weixin_44212838的博客
04-03 1974
用两个栈，一个专门入数据，一个专门出数据 来模拟实现一个队列。
C语言实现用两个栈实现一个队列的功能
最新发布
BYTEDANCE的博客
07-01 643
双栈实现队列功能
用两个栈实现队列（C语言版）
m0_51641706的博客
10-10 4407
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 ) https://leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof/ 由于C语言的栈要自己实现。前面写好栈的一些接口，代码在最后。 思路：双栈。 先说两个栈的作用：一个栈用于插入，一个栈用于删除。 1.创建
用两个栈实现队列(C语言模块化实现)
CppYyds的博客
02-01 844
1.贴题目： 2.贴代码： /* 两个栈实现队列, S1,S2，S1只管进，S2只管出*/ /* 入队操作: push元素进入S1 */ /* 出队操作: S2非空时, 从S2弹出元素, S2为空, S1数据导入S2再弹出 */ #define MAXSIZE 10000 /* 栈的基本操作 */ typedef struct { int *data; int top; } Stack; bool emptyStack(Stack *S) { return S-&g
C语言数据结构用栈实现表达式求值
10-26
栈主要有两个基本操作：压栈（Push）和弹栈（Pop）。压栈是将元素添加到栈顶，而弹栈则是从栈顶移除元素。在表达式求值中，我们通常会遇到括号、运算符和数字，这些都可以作为栈中的元素。运算符的优先级决定了它们...
C语言基础——堆和栈的区别
08-19
堆和栈是计算机领域中的两个重要概念，特别是在C语言编程中，它们是不可或缺的。但是，对于很多初学者来说，堆栈是一个很模糊的概念。因此，本文将详细介绍堆和栈的区别，并解释它们在C语言程序中的应用。 首先，...
C语言——借助指针实现数组元素的逆序.zip
07-13
逆序数组的基本思想是通过两个指针，一个从数组的开头开始，另一个从结尾开始，然后交换它们所指向的元素，直到两个指针相遇。以下是一个简单的逆序数组的示例代码： ```c void reverseArray(int arr[], int size) ...
输入一个浮点数，判断小数有几位——C语言代码
05-22
C语言提供了`scanf`函数来读取用户输入，可以这样获取一个浮点数： ```c #include int main() { float num; printf("请输入一个浮点数："); scanf("%f", &num); // 进行后续处理... } ``` 要计算小数部分的...
C语言 用两个栈实现一个队列CPP源代码
04-22
自己写的代码，有详细的注释，供大家参考。
C语言用两个栈实现一个队列的功能
10-22
用量个栈实现一个队列，使其可以有进队和出队的操作。
两个栈实现一个队列
11-23
使用面向对象技术，应用两个栈实现一个队列，并且应用了模板技术，所实现的队列是队列模板！
任意两个正整数的加减乘除——C语言代码
05-22
本项目名为“任意两个正整数的加减乘除”，是针对C语言初学者的一个简单练习，旨在帮助学习者掌握基本的运算符和控制流程。 首先，我们要理解C语言中的算术运算符。加法（+）、减法（-）、乘法（*）和除法（/）是...
【c语言】两个栈实现一个队列
xing1584114471的博客
10-26 417
声明文件 #ifndef __QUEUE_H #define __QUEUE_H #include <stdio.h> #include <assert.h> #include <malloc.h> #define ElemType int #define SIZE 10 #define TRUE 1 #define FALSE 0 //定义栈 typ...
通过两个栈实现一个队列(C语言）
小心眼儿猫的博客
04-16 3099
思路：如下图，我们可以定义两个栈，其中一个input用于实现队列的入队列的操作（就是input栈的入栈），另外一个output用于实现出队列和取队首元素的操作（就是output栈的出栈和取栈顶元素）。 当我们要出队列或者去队首元素时时，因为出队列和取队首元素要从output栈出，所以要先将input中的元素移到output中（而且谁最后入栈，就先把谁移到output中，这样一来，后入栈（后入队
数据结构——两个栈模拟实现一个队列（C语言）
weixin_42468092的博客
10-06 1919
两个栈模拟实现一个队列 实现思路：入栈时存储元素进入栈1，出栈时，将栈1中所有元素取出并放入栈2中，这样栈1中的元素就进行了逆置，即实现了与输入顺序相同。 比如：入栈元素顺序：1，2，3，4，5 那么此时栈1中元素自上而下顺序为：5，4，3，2，1 栈2元素为空。 出栈时，将栈1中元素依次取出放入栈2 此时栈2中元素自上而下顺序为：1，2，3，4，5（即保证了与输入顺序相同） 栈1元素为空 #include<stdio.h> #include<stdlib.h> #define .
用两个栈实现一个队列【C语言】
zypf_lover的博客
03-17 1956
问题描述： 考虑用两个栈实现队列这样的特殊结构 问题分析 提示：这里填写问题的分析： 例如：Handler 发送消息有两种方式，分别是 Handler.obtainMessage()和 Handler.sendMessage()，其中 obtainMessage 方式当数据量过大时，由于 MessageQuene 大小也有限，所以当 message 处理不及时时，会造成先传的数据被覆盖，进而导致数据丢失。 解决方案： 提示：这里填写该问题的具体解决方案： 例如：新建一个 Message 对象，并将读取到
C语言编程：200个经典项目实战——余弦曲线绘制与迭加直线
第一个程序是关于绘制余弦曲线，它演示了如何在没有数组的情况下，利用C语言的数学库函数`acos`来模拟屏幕的对称特性，实现每行显示两个余弦曲线上的点。程序通过循环计算出每个角度对应的y坐标，并利用`printf`函数...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值