如何用两个队列模拟实现一个栈

q1和q2分别是一个队列（链队列），用两个队列模拟实现一个栈的规则如下：

如何入栈：

直接向q2里边入。

如何出栈：

如果q2不空，将q2除了最后一个数据外，剩余数据放到q1里，这个时候q2仅仅剩下一个数据，这个时候就可以出来。

如果q2为空，代表着数据都在q1里，将q1除了最后一个数据外，剩余数据放在q2里，这个时候q1只剩下最后一个数据，直接出即可。

注意：下边的代码需要链队列能实现的相关函数，链队列文章链接如下：

(34条消息) 数据结构——队列（链队列）_张淑芬~的博客-CSDN博客

用两个队列模拟实现的栈的结构体声明：

//用两个队列模拟实现的栈的结构体声明

typedef struct Two_queue_stack
{
	struct LQueue q1;
	struct LQueue q2;
}Two_queue_stack, * PTwo_queue_stack;

可执行函数声明：

//初始化
void my_Init_two_queue_stack(struct Two_queue_stack* tqs);

//入栈
bool my_Push(PTwo_queue_stack tqs, ELEM_TYPE val);

//出栈（还需要一个输出参数，帮助我将出队的值带出来）
bool my_Pop(PTwo_queue_stack tqs, ELEM_TYPE* rtval);

//获取栈顶元素值（还需要一个输出参数，帮助我将出队的值带出来）
bool my_Top(PTwo_queue_stack tqs, ELEM_TYPE* rtval);

//判空
bool my_IsEmpty(PTwo_queue_stack tqs);

//有效元素个数
int my_Get_length(PTwo_queue_stack tqs);

//打印
void my_Show(PTwo_queue_stack tqs);

//清空
void my_Clear(PTwo_queue_stack tqs);

//销毁
void my_Destroy(PTwo_queue_stack tqs);

下面来依次实现相关函数：

初始化：

void my_Init_two_queue_stack(struct Two_queue_stack* tqs)
{
	assert(tqs != NULL);
	Init_LQueue(&tqs->q1);//这里调用队列的初始化函数，分别对q1,q2进行初始化
	Init_LQueue(&tqs->q2);
}

入栈，出栈：

//入栈
bool my_Push(PTwo_queue_stack tqs, ELEM_TYPE val)
{
	assert(tqs != NULL);
	return Push(&tqs->q2,val);
}

//出栈（还需要一个输出参数，帮助我将出队的值带出来）
bool my_Pop(PTwo_queue_stack tqs, ELEM_TYPE* rtval)
{
	assert(tqs != NULL);
	if (my_IsEmpty(tqs))
	{
		return false;
	}
	if (!IsEmpty(&tqs->q2))//q2不空  直接出（仅剩下一个元素，其他的全部挪到另一边）
	{
		int len = Get_length(&tqs->q2);
		while (len>1)
		{
			ELEM_TYPE tmp;
			Pop(&tqs->q2, &tmp);
			Push(&tqs->q1, tmp);
			len--;
		}
		return Pop(&tqs->q2, rtval);
	}
	else//q2为空  确定值都在q1里面
	{
		int len = Get_length(&tqs->q1);

		while (len > 1)
		{
			ELEM_TYPE tmp;
			Pop(&tqs->q1, &tmp);
			Push(&tqs->q2, tmp);
			len--;
		}

		return Pop(&tqs->q1, rtval);
	}
}

获取栈顶元素值（还需要一个输出参数，帮助我将出队的值带出来）

bool my_Top(PTwo_queue_stack tqs, ELEM_TYPE* rtval)
{
	assert(tqs != NULL);
	if (my_IsEmpty(tqs))
	{
		return false;
	}
	if (!IsEmpty(&tqs->q2))//q2不空  直接出（仅剩下一个元素，其他的全部挪到另一边）
	{
		int len = Get_length(&tqs->q2);
		while (len > 1)
		{
			ELEM_TYPE tmp;
			Pop(&tqs->q2, &tmp);
			Push(&tqs->q1, tmp);
			len--;
		}
		Pop(&tqs->q2, rtval);
		Push(&tqs->q1, *rtval);

		return true;
	}
	else//q2为空  确定值都在q1里面
	{
		int len = Get_length(&tqs->q1);

		while (len > 1)
		{
			ELEM_TYPE tmp;
			Pop(&tqs->q1, &tmp);
			Push(&tqs->q2, tmp);
			len--;
		}

		Pop(&tqs->q1, rtval);
		Push(&tqs->q2, *rtval);

		return true;
	}
}

判空，获取有效个数

//判空
bool my_IsEmpty(PTwo_queue_stack tqs)
{
	assert(tqs != NULL);
	if (IsEmpty(&tqs->q1) && IsEmpty(&tqs->q2))
	{
		return true;
	}
	return false;
}

//有效元素个数
int my_Get_length(PTwo_queue_stack tqs)
{
	return Get_length(&tqs->q1) + Get_length(&tqs->q2);
}

打印，清空，销毁

//打印
void my_Show(PTwo_queue_stack tqs)
{
	assert(tqs != NULL);
	Show(&tqs->q1);
	Show(&tqs->q2);
}

//清空
void my_Clear(PTwo_queue_stack tqs)
{
	assert(tqs != NULL);
	Clear(&tqs->q1);
	Clear(&tqs->q2);
}

//销毁
void my_Destroy(PTwo_queue_stack tqs)
{
	assert(tqs != NULL);
	Destroy(&tqs->q1);
	Destroy(&tqs->q2);
}

测试案例：

int main()
{
	struct Two_queue_stack head;//两个队列实现一个栈的结构体声明
	my_Init_two_queue_stack(&head);//初始化

	for (int i = 1; i <= 3; i++)
	{
		my_Push(&head, i);//1到3入栈
	}
	my_Show(&head);//打印1到3

	ELEM_TYPE flag;
	bool tag = my_Pop(&head, &flag);//出栈顶元素，也就是3
	if (tag)
	{
		printf("Pop = %d\n", flag);//如果tag为真，打印栈顶元素3
	}
	my_Show(&head);//打印函数，此时应该只剩1,2

	for (int i = 4; i <= 6; i++)
	{
		my_Push(&head, i);将4到6入栈
	}
	my_Show(&head);//打印

	my_Pop(&head, &flag);//出栈顶元素
	printf("Pop = %d\n", flag);//打印栈顶元素
	my_Pop(&head, &flag);//出栈顶元素
	printf("Pop = %d\n", flag);//打印栈顶元素
	my_Pop(&head, &flag);//出栈顶元素
	printf("Pop = %d\n", flag);//打印栈顶元素
	my_Pop(&head, &flag);//出栈顶元素
	printf("Pop = %d\n", flag);//打印栈顶元素
	printf("length = %d\n", my_Get_length(&head));//打印有效长度

	my_Top(&head, &flag);//获取栈顶元素并打印
	printf("Top = %d\n", flag);

	printf("length = %d\n", my_Get_length(&head));//打印有效长度

	my_Destroy(&head);//销毁

	return 0;
}

测试结果：