基础数据结构——利用两个栈实现一个队列

规则

入队：一直向stack1中插入数据
出队：1.如果stack2不空，则从stack2中出；
2.如果stack2空，则先把stack1中的数据导入到stack2中，再从stack2出栈。

示例：

栈是先入后出，队列是先入先出。
如图，将数据1，2，3插入栈stack1中，把stack1中的数据出到stack2中，这时候是按3，2，1插入stack2中，再从stack2中出数据，保持先入后出原则。
整体来看，是数据1，2，3入，又以1，2，3出，
两个栈以这样的形式实现先入先出原则，就实现了一个队列。

结构体定义

#include "stack.h"

//设计我们需要的那个结构体：two_stack_to_queue
typedef struct TSTQueue
{
	Stack s1;//每次入队的时候从给栈s1入栈
	Stack s2;//出队的时候，如果栈s2不空，则s2出栈，
	         //若栈s2为空，则将栈s1保存的数据导入到栈s2中，再从栈s2中出栈
}TSTQueue, *PTSTQueue;

调用头文件stack.h，这个头文件已经在文章基础数据结构——栈中实现过。
链接:
https://blog.csdn.net/m0_56257585/article/details/119914551

队列的操作

初始化

//初始化
void my_Init_Queue(PTSTQueue pq)
{
	assert(pq != nullptr);

	Init_stack(&pq->s1);
	Init_stack(&pq->s2);
}

入队

向stack1中插入数据

//入队 push
bool my_Push(PTSTQueue pq, ElemType val)
{
	assert(pq != nullptr);

	return Push(&pq->s1, val);
}

出队

//出队 pop 需要删除操作
bool my_Pop(PTSTQueue pq, ElemType* rtval)
{
	assert(pq != nullptr);
	if(my_IsEmpty(pq))
	{
		return false;
	}

	if(IsEmpty(&pq->s2))//s2为nullptr
	{
		while(!IsEmpty(&pq->s1))//将s1的数据全部导入到s2
		{
			int tmp;
			Pop(&pq->s1, &tmp);
			Push(&pq->s2, tmp);
		}

		return Pop(&pq->s2, rtval);//再将s2里的数据出出来
	}
	else
	{
		return Pop(&pq->s2, rtval);//s2不为空，直接把s2里的数据出出来
	}
}

清空和销毁

//清空
void my_Clear(PTSTQueue pq)
{
	Clear(&pq->s1);
	Clear(&pq->s2);
}

//销毁
void my_Destroy(PTSTQueue pq)
{
	Destroy(&pq->s1);
	Destroy(&pq->s2);
}

只读接口

//top  获取队头元素值， 不需要删除操作
bool my_Top(PTSTQueue pq, ElemType* rtval)
{
	assert(pq != nullptr);
	if(my_IsEmpty(pq))
	{
		return false;
	}

	if(IsEmpty(&pq->s2))//s2为空
	{
		while(!IsEmpty(&pq->s1))//将s1的数据全部导入到s2
		{
			int tmp;
			Pop(&pq->s1, &tmp);
			Push(&pq->s2, tmp);
		}

		return Top(&pq->s2, rtval);//再将s2里的数据出出来
	}
	else
	{
		return Top(&pq->s2, rtval);//再将s2里的数据出出来
	}
}

//获取其有效元素个数
int my_Get_length(PTSTQueue pq)
{
	int count = Get_length(&pq->s1) + Get_length(&pq->s2);
	return count;
}

//判空
bool my_IsEmpty(PTSTQueue pq)
{
	if(IsEmpty(&pq->s1) && IsEmpty(&pq->s2))
	{
		return true;
	}
	return false;
}