【数据结构与算法】数据结构C_使用两个栈实现一个队列&&使用两个队列实现一个栈

1.使用两个栈实现一个队列

因为栈的特性是后进先出，队列的特性是先进先出，根据题意我们可以设出两个栈s1，s2，s1可以用来入队，只需将数据保存到s1中即可，如果s2为空，则将s1中的数据依次导入到s2中，这样一来s1的栈顶元素成了s2的栈底元素，s1的栈底元素成了s2的栈顶元素，然后从s2中依次导出数据，这样便完成了队列的操作；如果s2不为空，则先将s2中的的栈顶元素，然后进一个数据出一个数据即可，同样完成了队列的操作。

实现：Topic.h

#include "Queue.h"
#include "Stack.h"

typedef struct QueueByTwoStack
{
	Stack s1;
	Stack s2;
}QueueByTwoStack;

void QueueByTwoStackInit(QueueByTwoStack* qts);
void QueueByTwoStackDestory(QueueByTwoStack* qts);
void QueueByTwoStackPush(QueueByTwoStack* qts, QUDataType x);
void QueueByTwoStackPop(QueueByTwoStack* qts);
QUDataType QueueByTwoStackFront(QueueByTwoStack* qts);
int QueueByTwoStackSize(QueueByTwoStack* qts);
int QueueByTwoStackEmpty(QueueByTwoStack* qts);

void TestQueueByTwoStack();

Topic.c

#include "Queue.h"
#include "Stack.h"
#include "Topic.h"


void QueueByTwoStackInit(QueueByTwoStack* qts)
{
	assert(qts);
	StackInit(&(qts->s1));
	StackInit(&(qts->s2));
}

void QueueByTwoStackDestory(QueueByTwoStack* qts)
{
	assert(qts);
	StackDestory(&(qts->s1));
	StackDestory(&(qts->s2));
}

void QueueByTwoStackPush(QueueByTwoStack* qts, QUDataType x)
{
	assert(qts);
	StackPush(&(qts->s1), x);
}

void QueueByTwoStackPop(QueueByTwoStack* qts)
{
	if (StackEmpty(&(qts->s2)))
	{
		StackPop(&(qts->s2));
	}
	else if (StackEmpty(&(qts->s1)))
	{
		while (StackEmpty(&(qts->s1)))
		{
			StackPush(&(qts->s2), StackTop(&(qts->s1)));
			StackPop(&(qts->s1));
		}
	}
}

QUDataType QueueByTwoStackFront(QueueByTwoStack* qts)
{
	assert(qts);
	return StackTop(&(qts->s2));
}

int QueueByTwoStackSize(QueueByTwoStack* qts)
{
	assert(qts);
	return StackSize(&(qts->s1)) + StackSize(&(qts->s2));
}

int QueueByTwoStackEmpty(QueueByTwoStack* qts)
{
	assert(qts);
	return StackEmpty(&(qts->s1)) || StackEmpty(&(qts->s2));
}

void TestQueueByTwoStack();

 

2.使用两个队列实现一个栈

题目要求使用两个队列实现一个栈，如上，将数据首先导入q1中，因为队列的特性是先进先出，所以我们只需将q1中除队尾的所有元素导入到q2中即可，然后将q1中队尾元素出队置外，然后将q2中的元素依次导入q1中，再次将除队尾外的所有元素导入q2中，并将队尾元素出队置外，反复进行多次操作，就实现了栈即后进先出的特点。

实现：Topic.h

#include "Queue.h"
#include "Stack.h"


typedef struct StackByTwoQueue
{
	Queue q1;
	Queue q2;
}StackByTwoQueue;


void StackByTwoQueueInit(StackByTwoQueue* stq);
void StackByTwoQueueDestory(StackByTwoQueue* stq);
STDataType StackByTwoQueueTop(StackByTwoQueue* stq);
int StackByTwoQueueEmpty(StackByTwoQueue* stq);
int StackByTwoQueueSize(StackByTwoQueue* stq);

void StackByTwoQueuePush(StackByTwoQueue* stq, STDataType x);
void StackByTwoQueuePop(StackByTwoQueue* stq);

void TestStackByTwoQueue();

Topic.c

void StackByTwoQueueInit(StackByTwoQueue* stq)
{
	assert(stq);
	QueueInit(&(stq->q1));
	QueueInit(&(stq->q2));
}

void StackByTwoQueueDestory(StackByTwoQueue* stq)
{
	assert(stq);
	QueueDestory(&(stq->q1));
	QueueDestory(&(stq->q2));
}

STDataType StackByTwoQueueTop(StackByTwoQueue* stq)
{
	assert(stq);
	if (QueueEmpty(&(stq->q1)))
	{
		return (&(stq->q1))->_back->_data;
	}
	else if (QueueEmpty(&(stq->q2)))
	{
		return (&(stq->q2))->_back->_data;
	}
	else
	{
		printf("栈顶为空\n");
	}
}

int StackByTwoQueueEmpty(StackByTwoQueue* stq)
{
	assert(stq);
	return QueueEmpty(&(stq->q1)) || QueueEmpty(&(stq->q2));
}

int StackByTwoQueueSize(StackByTwoQueue* stq)
{
	assert(stq);
	return QueueSize(&(stq->q1)) + QueueSize(&(stq->q2));
}

void StackByTwoQueuePush(StackByTwoQueue* stq, STDataType x)
{
	assert(stq);
	QueuePush(&(stq->q1),x);
}

void StackByTwoQueuePop(StackByTwoQueue* stq)
{
	assert(stq);
	assert(&stq->q1 || &stq->q2);
	if (QueueEmpty(&(stq->q1)))
	{
		while (QueueEmpty(&(stq->q1)) != 1)
		{
			QueuePush(&(stq->q2), QueueFront(&(stq->q1)));
			QueuePop(&(stq->q1));
		}
		QueuePop(&(stq->q1));
	}
	else
	{
		while (QueueEmpty(&(stq->q2)) != 1)
		{
			QueuePush(&(stq->q1), QueueFront(&(stq->q2)));
			QueuePop(&(stq->q2));
		}
		QueuePop(&(stq->q2));
	}
}


void TestStackByTwoQueue();