数据结构 两个栈实现一个队列

解题思路：

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

#define TITLE printf("\n=======================%s=========================\n",__FUNCTION__);

typedef char DataType;

typedef struct Stack
{
	DataType* data;
	int size;
	int capacity;
}Stack;

typedef struct Queue
{
	Stack input;
	Stack output;
	int size;
}Queue;

void QueueInit(Queue* queue);//初始化队列
void QueueDestroy(Queue* queue);//销毁队列
void QueuePush(Queue* queue,DataType value);//入队列
void QueuePop(Queue* queue);//出队列
int QueueGet(Queue* queue,DataType* value);//取队首元素
void QueuePrint(Queue* queue,const char* msg);//打印
====================================================================

#include"Queue_by_2stack.h"

void StackInit(Stack* stack)
{
	if(stack == NULL)
	{
		//非法输入
		return;
	}
	stack->size = 0;
	stack->capacity = 1000;
	stack->data = (DataType*)malloc(stack->capacity * sizeof(DataType));
}

void StackDestroy(Stack* stack)
{
	if(stack == NULL)
	{
		//非法输入
		return;
	}
	free(stack->data);
	stack->size = 0;
	stack->capacity = 0;
	return;
}


void StackPush(Stack* stack,DataType value)
{
	if(stack == NULL)
	{
		//非法输入
		return;
	}
	if(stack->size >= stack->capacity)
	{
		//栈已满
		return;
	}
	stack->data[stack->size++] = value;
	return;
}


void StackPop(Stack* stack)
{
	if(stack == NULL)
	{
		//非法输入
		return;
	}
	if(stack->size == 0)
	{
		//空栈
		return;
	}
	stack->size -= 1;
	return;
}

int StackGet(Stack* stack,DataType* value)
{
	if(stack == NULL)
	{
		//非法输入
		return 0;
	}
	if(stack->size == 0)
	{
		//空栈
		return 0;
	}
	*value = stack->data[stack->size-1];
	return 1;
}

void QueueInit(Queue* queue)
{
	StackInit(&queue->input);
	StackInit(&queue->output);
	queue->size = 0;
}

void QueueDestroy(Queue* queue)
{
	if(queue == NULL)
	{
		//非法输入
		return;
	}
	StackDestroy(&queue->input);
	StackDestroy(&queue->output);
	queue->size = 0;
}


void QueuePrint(Queue* queue,const char* msg)
{
	printf("[%s]\n",msg);
	if(queue == NULL)
	{
		return;
	}
	if(queue->size == 0)
	{
		//空队列
		return;
	}
	//统一从input中打印
	while(1)
	{
		DataType front;
		int ret = StackGet(&queue->output,&front);
		if(ret == 0)
		{
			//output中没有元素
			break;
		}
		//从output中出栈
		StackPop(&queue->output);		
		//将front插入栈intput
		StackPush(&queue->input,front);
	}
	int i = 0;
	for(i = 0;i < queue->input.size;i++)
	{
		printf("%c ",queue->input.data[i]);
	}
	printf("\n");
	

}

//入队列
void QueuePush(Queue* queue,DataType value)
{
	if(queue == NULL)	
	{
		//非法输入
		return;
	}
	//将output中的数据转到input
	while(1)
	{
		DataType front;
		int ret = StackGet(&queue->output,&front);
		if(ret == 0)
		{
			//output中没有元素
			break;
		}
		//从output中出栈
		StackPop(&queue->output);		
		//将front插入栈intput
		StackPush(&queue->input,front);
	}
	//倒完数据后，将新元素插入input栈中
	StackPush(&queue->input,value);
	queue->size++;
}

//出队列
void QueuePop(Queue* queue)
{
	if(queue == NULL)
	{
		return;
	}
	if(queue->size == 0)
	{
		//空队列
		return;
	}
	//将input中的数据转到output
	while(1)
	{
		DataType front;
		int ret = StackGet(&queue->input,&front);
		if(ret == 0)
		{
			//input中没有元素
			break;
		}
		//从input中出栈
		StackPop(&queue->input);		
		//将front插入栈output
		StackPush(&queue->output,front);
	}
	//倒完数据后，从output中出栈一个元素
	StackPop(&queue->output);
	queue->size--;
}

//取队首元素
int QueueGet(Queue* queue,DataType* value)
{
	if(queue == NULL)
	{
		//非法输入
		return 0;
	}
	if(queue->size == 0)
	{
		//空队列
		return 0;
	}
	//将input中的数据转到output
	while(1)
	{
		DataType front;
		int ret = StackGet(&queue->input,&front);
		if(ret == 0)
		{
			//input中没有元素
			break;
		}
		//从input中出栈
		StackPop(&queue->input);		
		//将front插入栈output
		StackPush(&queue->output,front);
	}
	//倒完数据后，从output中取出栈顶元素
	char ret;
	StackGet(&queue->output,&ret);
	*value = ret;
	return 1;
}
///
//             以下为测试函数              //
///

void TestQueuePush()
{
	TITLE;
	struct Queue queue;
	QueueInit(&queue);
	QueuePush(&queue,'a');
	QueuePush(&queue,'b');
	QueuePush(&queue,'c');
	QueuePush(&queue,'d');
	QueuePrint(&queue,"入队列4个元素");
}

void TestQueuePop()
{
	TITLE;
	struct Queue queue;
	QueueInit(&queue);
	QueuePush(&queue,'a');
	QueuePush(&queue,'b');
	QueuePush(&queue,'c');
	QueuePush(&queue,'d');
	QueuePrint(&queue,"入队列4个元素");
	QueuePop(&queue);
	QueuePrint(&queue,"出队列1个元素");
	QueuePop(&queue);
	QueuePop(&queue);
	QueuePop(&queue);
	QueuePrint(&queue,"出队列3个元素");
}

void TestQueueGet()
{
	TITLE;
	struct Queue queue;
	QueueInit(&queue);
	QueuePush(&queue,'a');
	QueuePush(&queue,'b');
	QueuePush(&queue,'c');
	QueuePush(&queue,'d');
	QueuePrint(&queue,"入队列4个元素");
	char front;
	int ret = QueueGet(&queue,&front);
	printf("expect is 1,actul is %d\n",ret);
	printf("expect is a,actul is %c\n\n",front);

	QueuePop(&queue);
	QueuePop(&queue);
	QueuePop(&queue);
	QueuePop(&queue);
	QueuePrint(&queue,"出队列4个元素");
	ret = QueueGet(&queue,&front);
	printf("expect is 0,actul is %d\n",ret);
}

int main()
{
	TestQueuePush();
	TestQueuePop();
	TestQueueGet();
	return 0;
}

运行结果：