使用队列实现栈——基于C语言

最新推荐文章于 2023-06-08 14:35:56 发布
最新推荐文章于 2023-06-08 14:35:56 发布
阅读量404 收藏 2
点赞数
分类专栏： C 数据结构 文章标签： 链表 队列 栈 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38705421/article/details/107973180
版权

今天使用之前实现的队列实现栈。

下面是Main.c文件;

#include "QueueToStack.h"
#include <stdio.h>

int main()
{
	QueueToStack *stack = QueueToStackCreate();
	
	if(stack != NULL)
	{
		int i, len = -1, data = -1;
		
		for(i = 0; i < 100; i++)
		{
			QueueToStackPush(stack, i);
		}
		
		len = QueueToStackLength(stack);
		printf("len = %d\n\n", len);
		
		for(i = 0; i < len / 2; i++)
		{
			QueueToStackPop(stack, NULL);
		}
		
		len = QueueToStackLength(stack);
		printf("len = %d\n\n", len);
		
		printf("打印队列中元素：\n");
		for(i = 0; i < len; i++)
		{
			int data;
			QueueToStackPop(stack, &data);
			printf("stack[%02d] = %-2d\n", i, data);
		}
		
		printf("\n删除状态：%d\n\n", QueueToStackPop(stack, NULL));
		printf("获取数据元素状态：%d\n\n", QueueToStackTop(stack, &data));
	
		stack = QueueToStackDestroy(stack);
		len = QueueToStackLength(stack);
		printf("len = %d\n\n", len);
	}
	
	return 0;
}

下面是QueueToStack.h文件：

#ifndef __QueueToStack_H__
#define __QueueToStack_H__

#include <stdio.h>
#include <stdlib.h>
#include "DynamicQueue.h"
#include "Macro.h"

STRUCT(QueueToStack)
{
	DynamicQueue *queue1;
	DynamicQueue *queue2;
	int len;
};

QueueToStack* QueueToStackCreate(void);
QueueToStack* QueueToStackDestroy(QueueToStack *stack);
int QueueToStackLength(QueueToStack *stack);
Bool QueueToStackPush(QueueToStack *stack, DataType data);
Bool QueueToStackPop(QueueToStack *stack, DataType *data);
Bool QueueToStackTop(QueueToStack *stack, DataType *data);

#endif

下面是QueueToStack.c文件：

#include "QueueToStack.h"

QueueToStack* QueueToStackCreate(void)		//O(1)
{
	QueueToStack *ret = MALLOC(QueueToStack, 1);
	
	if(ret)
	{
		ret->queue1 = DynamicQueueCreate();
		ret->queue2 = DynamicQueueCreate();
		
		if((ret->queue1 != NULL) && (ret->queue2 != NULL))
		{
			ret->len = 0;
		}
		else
		{
			DynamicQueueDestroy(ret->queue1);
			DynamicQueueDestroy(ret->queue2);
			
			FREE(ret);
		}
	}
	
	return ret;
}

QueueToStack* QueueToStackDestroy(QueueToStack *stack)		//O(n)
{
	if(stack != NULL)
	{
		DynamicQueueDestroy(stack->queue1);
		DynamicQueueDestroy(stack->queue2);
			
		FREE(stack);		
	}
	
	return NULL;
}

int QueueToStackLength(QueueToStack *stack)		//O(1)
{
	return (stack != NULL) ? stack->len : -1;	
}

Bool QueueToStackPush(QueueToStack *stack, DataType data)		//O(n)
{
	Bool ret = (stack != NULL);
	
	if(ret)
	{
		ret = DynamicQueueEnqueue(stack->queue1, data);
		if(ret) stack->len++;
	}
	
	return ret;
}

Bool QueueToStackPop(QueueToStack *stack, DataType *data)		//O(n^2)
{
	Bool ret = (stack != NULL);
	
	if(ret)
	{
		while(DynamicQueueLength(stack->queue1) > 1)
		{
			DataType data;
			ret = ret && DynamicQueueDequeue(stack->queue1, &data);
			ret = ret && DynamicQueueEnqueue(stack->queue2, data);
		}
		
		ret = ret && DynamicQueueDequeue(stack->queue1, data);
		
		while(DynamicQueueLength(stack->queue2) > 0)
		{
			DataType data;
			ret = ret && DynamicQueueDequeue(stack->queue2, &data);
			ret = ret && DynamicQueueEnqueue(stack->queue1, data);			
		}
		
		if(ret) stack->len--;
	}
	
	return ret;
}

Bool QueueToStackTop(QueueToStack *stack, DataType *data)		//O(n^2)
{
	Bool ret = ((stack != NULL) && (data != NULL));
	
	if(ret)
	{
		while(DynamicQueueLength(stack->queue1) > 1)
		{
			DataType data;
			ret = ret && DynamicQueueDequeue(stack->queue1, &data);
			ret = ret && DynamicQueueEnqueue(stack->queue2, data);
		}
		
		ret = ret && DynamicQueueDequeue(stack->queue1, data);
		ret = ret && DynamicQueueEnqueue(stack->queue2, *data);
		
		while(DynamicQueueLength(stack->queue2) > 0)
		{
			DataType data;
			ret = ret && DynamicQueueDequeue(stack->queue2, &data);
			ret = ret && DynamicQueueEnqueue(stack->queue1, data);			
		}
	}
	
	return ret;	
}

下面是DynamicQueue.h文件：

#ifndef __DYNAMICQUEUE_H_
#define __DYNAMICQUEUE_H_

#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"

STRUCT(DynamicQueue)
{
	LinkList *list;
	int len;
};

DynamicQueue* DynamicQueueCreate(void);
DynamicQueue* DynamicQueueDestroy(DynamicQueue *queue);
int DynamicQueueLength(DynamicQueue *queue);
Bool DynamicQueueEnqueue(DynamicQueue *queue, DataType data);
Bool DynamicQueueDequeue(DynamicQueue *queue, DataType *data);
Bool DynamicQueueFront(DynamicQueue *queue, DataType *data);

#endif

下面是DynamicQueue.c文件：

#include "DynamicQueue.h"

DynamicQueue* DynamicQueueCreate(void)								//O(1)
{
	DynamicQueue *ret = MALLOC(DynamicQueue, 1);

	if(ret != NULL)
	{
		ret->list = LinkListCreate(); 	//O(1)
		
		if(ret->list != NULL)
		{
			ret->len = 0;
		}
		else
		{
			free(ret);
			ret = NULL;
		}
	}
	
	return ret;
}

DynamicQueue* DynamicQueueDestroy(DynamicQueue *queue)				//O(n)
{
	if(queue != NULL)
	{
		LinkListDestroy(queue->list);	//O(n)
		free(queue);
	}
	
	return NULL;
}

int DynamicQueueLength(DynamicQueue *queue)							//O(1)
{
	return (queue != NULL) ? queue->len : -1;
}

Bool DynamicQueueEnqueue(DynamicQueue *queue, DataType data)		//O(n)
{
	Bool ret = (queue != NULL);
	
	if(ret)
	{
		ret = LinkListInsert(queue->list, queue->len, data);//O(n)
		if(ret) queue->len++;
	}
	
	return ret;
}

Bool DynamicQueueDequeue(DynamicQueue *queue, DataType *data)		//O(1)
{
	Bool ret = (queue != NULL);
	
	if(ret)
	{
		ret = LinkListDelete(queue->list, 0, data);	//O(1)
		if(ret) queue->len--;
	}
}

Bool DynamicQueueFront(DynamicQueue *queue, DataType *data)			//(1)
{
	Bool ret = (queue != NULL) && (data != NULL);
	
	if(ret)
	{
		ret = LinkListGet(queue->list, 0, data);
	}
	
	return ret;
}

下面是LinkList.h文件：

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

#include "Macro.h"

STRUCT(LLNode)
{
	DataType data;
	LLNode *next;
};

STRUCT(LinkList)
{
	int len;
	LLNode *next;
	LLNode *m_current;
};

LinkList* LinkListCreate(void);
LinkList* LinkListDestroy(LinkList *list);
int LinkListLength(LinkList *list);
Bool LinkListInsert(LinkList *list, int i, DataType data);
Bool LinkListDelete(LinkList *list, int i, DataType *data);
int LinkListFind(LinkList *list, DataType data); 
Bool LinkListSet(LinkList *list, int i, DataType data);
Bool LinkListGet(LinkList *list, int i, DataType *data);
LLNode* LinkListMove(LinkList *list, int i);
Bool LinkListEnd(LinkList *list);
void LinkListNext(LinkList *list);
DataType LinkListCurrent(LinkList *list);

#endif

下面是LinkList.c文件：

#include "LinkList.h"

LinkList* LinkListCreate(void)		//O(1)
{
	LinkList *list = MALLOC(LinkList, 1);
	
	if(list != NULL)
	{
		list->len = 0;
		list->next = NULL;
		list->m_current = NULL;
	}
	
	return list;
}

LinkList* LinkListDestroy(LinkList *list)	//O(n)
{
	if(list != NULL)
	{
		while(list->next != NULL)
		{
			LinkListDelete(list, 0, NULL);
		}
		
		FREE(list);
	}
	
	return NULL;
}

int LinkListLength(LinkList *list)	//O(1)
{
	return (list != NULL) ? list->len : -1;
}

Bool LinkListInsert(LinkList *list, int i, DataType data)		//O(n)
{
	Bool ret = (list != NULL) && (i >= 0) && (i <= LinkListLength(list));
	
	if(ret)
	{
		LLNode *node = MALLOC(LLNode, 1);
		
		if(node != NULL)
		{			
			if(0 == i)
			{
				node->data = data;
				node->next = list->next;
				
				list->next = node;
			}
			else
			{
				LLNode *pre = LinkListMove(list, i - 1);
				
				node->data = data;
				node->next = pre->next;
				
				pre->next = node;
			}
			
			list->len++;
		}
		else
		{
			ret = false;
		}
	}
	
	return ret;
}

Bool LinkListDelete(LinkList *list, int i, DataType* data)	//O(n)
{
	Bool ret = (i >= 0) && (i < LinkListLength(list));
	
	if(ret)
	{
		LLNode *node = list->next;
		
		if(0 == i)
		{
			if(data) *data = node->data;
			list->next = node->next;
		}
		else
		{
			LLNode *pre = LinkListMove(list, i - 1);
			
			node = pre->next;
			
			if(data) *data = node->data;
			
			pre->next = node->next;	
		}
		
		free(node);
		list->len--;
	}
	
	return ret;
}

Bool LinkListSet(LinkList *list, int i, DataType data)	//O(n)
{
	return ((i >= 0) && (i < LinkListLength(list))) ? (LinkListMove(list, i)->data = data, true) : false;
}

Bool LinkListGet(LinkList *list, int i, DataType* data)	//O(n)
{
	return ((data != NULL) && (i >= 0) && (i < LinkListLength(list))) ? (*data = LinkListMove(list, i)->data, true) : false;
}

//下面四个配合使用用于遍历链表，时间复杂度为O(n)
LLNode* LinkListMove(LinkList *list, int i)
{
	LLNode *ret = NULL;
	
	list->m_current = NULL;
	
	if((list != NULL) && (i >= 0) && (i < LinkListLength(list)))
	{		
		LLNode *node = list->next;
		
		if(node != NULL)
		{
			int j;
			
			for(j = 0; j < i; j++)
			{
				node = node->next;	
			}
			
			ret = node;
			list->m_current = node;				
		}	
	}
	
	return ret;
}

Bool LinkListEnd(LinkList *list)
{
	return (list != NULL) ? (list->m_current == NULL) : false;
}

void LinkListNext(LinkList *list)
{
	if((list != NULL) && (list->m_current != NULL))
	{
		list->m_current = list->m_current->next; 
	}	
}

DataType LinkListCurrent(LinkList *list)
{
	return ((list != NULL) && (list->m_current != NULL)) ? list->m_current->data : (DataType)0;
}

int LinkListFind(LinkList *list, DataType data)	//O(n)
{
	int ret = -1;		
	
	if(list)
	{
		int i = 0;
		
		for(LinkListMove(list, 0); !LinkListEnd(list); LinkListNext(list), i++)
		{
			if(LinkListCurrent(list) == data)
			{
				ret = i;
				break;
			}
		}		
	}
	
	return ret;
}

下面是Macro.h文件：

#ifndef __MACRO_H__
#define __MACRO_H__

typedef int DataType;

#define deBug() printf("File = %s\nLine = %d\n", __FILE__, __LINE__)

#include <stdio.h>
#include <stdlib.h>

#ifndef __cplusplus
	typedef int Bool;
	#define true 1
	#define false 0
#else
	typedef bool Bool;
#endif 

#define MALLOC(type, size) 	(type*)malloc(sizeof(type) * size)
#define FREE(p)				(free(p), p = NULL)

#define STRUCT(type)	typedef struct __struct##type type;\
						struct __struct##type

#endif

下面是运行结果：
在这里插入图片描述
在这里插入图片描述

海天up
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用栈实现队列(C语言实现)
。烊了
06-19 3429
在上一篇优化后队列的实现(C语言实现) 中，虽然我们对队列的时间复杂度进行了优化，但是却让代码的可读性变差了，代码显得略微臃肿（当然，这些话你看看就好，主要是为了奉承这篇博文的）。 这里主要实现的是：利用栈来实现队列 基本思路： 1，创建两个栈 2，两个栈合并起来组装成一个队列，分别取名为instack,outstack，用于进队列，出队列 3，比如有1,2,3,4,5 需要进入队列，先将这一串数压入instack栈中，假设压入顺序为1,2,3,4,5（1为栈底），再将instack中的数据移入outst
软工大作业——基于C语言的订餐系统（面向过程实现）.zip
最新发布
06-15
C语言是一种广泛使用的编程语言，它具有高效、灵活、可移植性强等特点，被广泛应用于操作系统、嵌入式系统、数据库、编译器等领域的开发。C语言的基本语法包括变量、数据类型、运算符、控制结构（如if语句、循环语句...
用队列模拟栈（C语言实现）
qq_54831038的博客
02-09 842
1.用队列模拟栈 注意此处的格式要求要详细阅读 /** * Your MyStack struct will be instantiated and called as such: * MyStack* obj = myStackCreate(); * myStackPush(obj, x); * int param_2 = myStackPop(obj); * int param_3 = myStackTop(obj); * bool param_4 = myStackEm
225. 用队列实现栈(C实现)
呋喃吖的博客
11-04 264
题目 题目链接：225. 用队列实现栈 思路 用两个队列来模拟实现栈的操作！ 入栈操作：即给任意一个空的队列入队即完成入栈操作； 出栈操作：先把有数据的队列q1的值出队到另一个队列q2,当q1剩余一个数据时候，那么就出队最后一个数据，表示出栈！ 由于C语言没有提供队列的数据结构，所以需要自己实现一个队列； 该队列：队尾入队，队头出队，保持先进先出即可！ c代码实现 typedef int QDataType; typedef struct QueueNode { QDataType data;
C语言-- 用队列实现栈的功能以及用栈实现队列
qq_53830608的博客
08-09 405
1）定义两个队列：Temp、data。临时队列temp: 先进的数据放在这。然后从data内移到temp。
【数据结构】用队列实现栈
Extreme_wei的博客
03-23 2729
本篇总结利用队列如何实现栈的相关操作，不难观察，栈和队列是可以相互转化的，需要好好总结它们的特性，构造出一个恰当的结构来实现即可，所以本篇难点不在代码思维，而是对结构的理解。
分治法求最大字段和问题——C语言代码
05-22
同时，为了提高效率，可以利用数据结构（如栈或队列）来辅助计算。 7. **测试与调试**：编写完代码后，需要对各种边界条件和随机输入进行测试，确保程序的正确性。 在提供的压缩包中，"分治法求最大字段和问题.cpp...
数据结构：基于C语言的迷宫问题
08-03
总的来说，基于C语言的迷宫问题是一个很好的实践数据结构和算法的机会，它涵盖了基本的数组操作、栈和队列的使用，以及搜索算法的实现。通过解决这个问题，你可以深入理解这些基础知识，并提升你的编程技能。
C语言——仓库管理系统.zip
08-17
《C语言——仓库管理系统》是一个基于C语言编写的软件项目，专为初学者设计，特别是针对大一学生在学习C语言阶段的课程设计或大作业。这个系统旨在模拟实际仓库的库存管理流程，帮助学生实践C语言编程技能，并理解...
中国科学院大学22-23秋季学期 《程序设计基础与实验（C语言）》课程大作业——基于Min-Max搜索策略的五子棋对战程序
06-15
C语言是一种广泛使用的编程语言，它具有高效、灵活、可移植性强等特点，被广泛应用于操作系统、嵌入式系统、数据库、编译器等领域的开发。C语言的基本语法包括变量、数据类型、运算符、控制结构（如if语句、循环语句...
【数据结构与算法】用队列实现栈
Welcome home | Jian Liao 's blog
03-21 1833
😼前面我们相继实现了栈和队列，是不是愁没有练手的地方呢？别担心，本章带大家用队列来实现一个栈！😽我们都知道，栈和队列可以看作为兄弟，一个后进先出(LIFO)，一个先进先出(FIFO)，他们虽有不同的性质，但总的来说还是不分家的，因为，我们既可以用队列实现栈，也可以用栈实现队列，而本章就先来带大家来了解如何使用队列来实现栈。💝学会了用队列实现栈，那么下一篇文章就是教大家如何用栈实现队列了。栈和队列还真是有趣呢！❤️‍🔥后续将会持续输出有关数据结构的文章，你们的支持就是我写作的最大动力！
225.用队列实现栈
la_brave_man的博客
03-20 151
方法一：使用一个队列实现栈 方法二：使用两个队列实现栈
用栈实现队列 / 用队列实现栈
qq_74260823的博客
06-08 1166
如果入队列栈（栈1），出队列栈（栈2）都为空，队列自然也为空。
用队列实现栈
qq_45875349的博客
10-26 175
入栈操作时，首先将元素入队到 queue2queue2​，然后将 queue1queue1​ 的全部元素依次出队并入队到 queue2queue2​，此时 queue2queue2​ 的前端的元素即为新入栈的元素，再将 queue1queue1​ 和 queue2queue2​ 互换，则 queue1queue1​ 的元素即为栈内的元素，queue1queue1​ 的前端和后端分别对应栈顶和栈底。为了满足栈的特性，即最后入栈的元素最先出栈，在使用队列实现栈时，应满足队列前端的元素是最后入栈的元素。
C语言 | 队列实现栈
张登雨的博客
03-27 125
力扣225题 /* 构造队列结构 */ #define LEN 20 typedef struct queue { int* data; int head; int rear; int size; } Queue; /* 初始化队列 */ Queue* initQueue(int k) { Queue* obj = (Queue*)malloc(sizeof(Queue)); obj->data = (int*)malloc(sizeof(int) *
C语言-用队列实现栈
梦中破的博客
11-14 1205
栈：是先进后出的数据结构 队列：是先进先出的数据结构 用一个队列实现栈 主要目的是：保证队首的元素和栈顶相同 当队列为空时，直接入队；当队列不为空时，将该元素入队之后，将该元素之前的所有元素依次出队再入队。这样栈顶元素对应队首，栈底元素对应队尾，弹出时，按顺序弹出。 ...
c语言俩个栈实现一个队列
u010916862的博客
04-19 3963
思路，现在设有俩个栈s1，s2。完成一个队列。     入队时，数据进入栈s1。出队时检查s2栈是否为空，为空则将s1出栈，出栈数据依次入栈s2。完成一个s1全部出栈后，s2出栈既是此时的出队操作。如果s2不为空，那s2直接出栈。如果s2，s1都为空，此时队列为空，无法执行出队操作。代码如下。/** *@filename seqstack.c *@author haohaibo *...
【C语言】栈和队列的相互实现
m0_62537611的博客
07-01 798
用队列实现栈代码实现完整代码用栈实现队列 代码实现完整代码力扣链接：用队列实现栈这个题目，使用队列模拟实现栈，我们是使用C语言来实现，由于C语言没有相应的库所以我们要先手写一个队列出来，在此之前我们还要对队列和栈的性质有所了解 ，可以参考我之前写的文章——（队列的模拟实现）和（栈的模拟实现） 创建两个队列 初始化 入栈 出栈 获取栈顶元素 判空 销毁栈 完整代码 用栈实现队列 力扣链接：用栈实现队列这个题目是用栈实现队列，我们依然使用C语言
【c语言】两个队列实现一个栈
Catdeo的博客
06-19 1619
两个队列实现一个栈 核心思想：模拟出栈的后进先出操作 创建queue1和queue2，入栈时选择一个非空队列执行入队列操作（若两个队列都为空，则随机选择一个队列），出栈时需要先从非空队列queue1把数依次进入空数列queue2，直到queue1中到最后一个数为止，然后将queue1中的数出队列，模拟出栈的后进先出操作。 代码模拟 Stackby_two_queue.h #pragma once...
用一个队列实现栈用c语言编写
05-14
以下是使用队列实现栈的 C 语言代码： ```c #include #include #define MAX_SIZE 10 // 定义队列结构体 typedef struct { int data[MAX_SIZE]; int front; int rear; } Queue; // 初始化队列 void ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值