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

解题思路:

Stack_by_2queue.h

#pragma once

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

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

typedef char DataType;


typedef struct Queue
{
	DataType data[MaxSize];
	int head;
	int tail;
	int size;
}Queue;


typedef struct Stack
{
	Queue queue1;
	Queue queue2;
	int size;
}Stack;


void StackInit(Stack* stack); //初始化
void StackDestroy(Stack* stack);//销毁
void StackPrint(Stack* stack,const char* msg);//打印栈
void StackPush(Stack* stack,DataType value);//入栈
void StackPop(Stack* stack);//出栈
int StackGet(Stack* stack,DataType* value);//取栈顶元素

Stack_by_2queue.c

#include"Stack_by_2queue.h"

//队列初始化
void QueueInit(Queue* queue)
{
	if(queue == NULL)
	{
		//非法输入
		return;
	}
	queue->head = 0;
	queue->tail = 0;
	queue->size = 0;
}

//销毁队列
void QueueDestroy(Queue* queue)
{
	if(queue == NULL)
	{
		return;
	}
	queue->head = 0;
	queue->tail = 0;
	queue->size = 0;
}

//入队列
void QueuePush(Queue* queue,DataType value)
{
	if(queue == NULL)
	{
		//非法输入
		return;
	}
	if(queue->size >= MaxSize)
	{
		//队列已满
		return;
	}
	queue->data[queue->tail++] = value;
	queue->size++;
	if((queue->tail) > MaxSize && (queue->size < MaxSize))
	{
		//tail到达队尾
		queue->tail = 0;
	}
}

//出队列
void QueuePop(Queue* queue)
{
	if(queue == NULL)
	{
		//非法输入
		return;
	}
	if(queue->size == 0)
	{
		//空队列
		return;
	}
	if(queue->head >= MaxSize)
	{
		//说明head已经到达队尾最后一个元素
		//应让head回到队首
		queue->head = 0;
		queue->size--;
		return;
	}
	queue->head++;
	queue->size--;
	if(queue->size == 0)
	{
		//队列已经空了
		queue->head = 0;
		queue->tail = 0;
	}
	return;
}

DataType QueueGet(Queue* queue)
{
	if(queue == NULL)
	{
		//非法输入
		return;
	}
	if(queue->size == 0)
	{
		//空队列
		return;
	}
	return queue->data[queue->head];
}

//打印(按理说队列不允许被打印，此处为了为了测试代码是否正确)
void Print(Queue* queue)
{
	if(queue == NULL)
	{
		//非法输入
		return;
	}
	if(queue -> size == 0)
	{
		//空队列
		return;
	}

	//tail在head后面
	if(queue->head < queue->tail)
	{
		int i = queue->head;
		for(;i<queue->tail;i++)
		{
			printf("%c ",queue->data[i]);
		}
	}
	//tail在head前面
	if(queue->head > queue->tail)
	{
		int i = queue->head;
		for(;i<MaxSize;i++)
		{
			printf("%c ",queue->data[i]);
		}
		i = 0;
		for(;i<queue->tail;i++)
		{
			printf("%c ",queue->data[i]);
		}
	}
	printf("\n");
}

//初始化栈
void StackInit(Stack* stack)
{
	if(stack == NULL)
	{
		//非法输入
		return;
	}
	QueueInit(&stack->queue1);
	QueueInit(&stack->queue2);
	stack->size = 0;
}

//销毁栈
void StackDestroy(Stack* stack)
{
	if(stack == NULL)
	{
		//非法输入
		return;
	}
	QueueDestroy(&stack->queue1);
	QueueDestroy(&stack->queue2);
	stack->size = 0;
}

//打印栈元素
void StackPrint(Stack* stack,const char* msg)
{
	printf("[%s]\n",msg);
	if(stack == NULL)
	{
		//非法输入
		return;
	}
	if(stack->size == 0)
	{
		//空栈
		return;
	}
	Queue* print = NULL;
	if(stack->queue1.size == 0)
	{
		print = &stack->queue2;
	}
	else
	{
		print = &stack->queue1;
	}
	Print(print);
}

//入栈
void StackPush(Stack* stack,DataType value)
{
	if(stack == NULL)
	{
		//非法输入
		return;
	}
	if(stack->size > MaxSize)
	{
		//栈已满
		return;
	}
	if(stack->queue1.size != 0)
	{
		QueuePush(&stack->queue1,value);
		stack->size++;
		return;
	}
	else
	{
		QueuePush(&stack->queue2,value);
		stack->size++;
		return;
	}
}

//出栈
void StackPop(Stack* stack)
{
	if(stack == NULL)
	{
		//非法输入
		return;
	}
	if(stack->size == 0)
	{
		//空栈
		return;
	}
	Queue* from = NULL;
	Queue* to = NULL;
	if(stack->queue1.size != 0)
	{
		from = &stack->queue1;
		to = &stack->queue2;
	}
	else
	{
		from = &stack->queue2;
		to = &stack->queue1;
	}
	while(from->size != 1)
	{
		DataType head;
		//取得队首元素后，将其出队列
		head = QueueGet(from);
		QueuePop(from);
		//将from的队首元素的data入队列到to
		QueuePush(to,head);
	}
	//经过循环后，取得队尾元素，将其出队列,完成出栈
	QueuePop(from);
}

//取栈顶元素
int StackGet(Stack* stack,DataType* value)
{
	if(stack == NULL)
	{
		//非法输入
		return 0;
	}
	if(stack->size == 0)
	{
		//空栈
		return 0;
	}
	Queue* from = NULL;
	Queue* to = NULL;
	if(stack->queue1.size != 0)
	{
		from = &stack->queue1;
		to = &stack->queue2;
	}
	else
	{
		from = &stack->queue2;
		to = &stack->queue1;
	}
	while(from->size != 1)
	{
		DataType head;
		//取得队首元素后，将其出队列
		head = QueueGet(from);
		QueuePop(from);
		//将from的队首元素的data入队列到to
		QueuePush(to,head);
	}
	//循环结束后，取得队尾元素即为栈顶元素
	*value = from->data[from->head];	

	//取得栈顶元素后，将from队列的最后一个元素入队列到to队列
	DataType head = QueueGet(from);
	QueuePop(from);
	//将from的队首元素的data入队列到to
	QueuePush(to,head);
	return 1;
	
}

///
//               以下为测试函数              //
//

void TestStackPush()
{
	TITLE;
	Stack stack;
	StackInit(&stack);
	StackPush(&stack,'a');
	StackPush(&stack,'b');
	StackPush(&stack,'c');
	StackPush(&stack,'d');
	
	StackPrint(&stack,"入栈4个元素");
}
void TestStackPop()
{
	TITLE;
	Stack stack;
	StackInit(&stack);
	StackPush(&stack,'a');
	StackPush(&stack,'b');
	StackPush(&stack,'c');
	StackPush(&stack,'d');
	StackPrint(&stack,"入栈4个元素");
	StackPop(&stack);
	StackPrint(&stack,"出栈1个元素");
	StackPop(&stack);
	StackPop(&stack);
	StackPop(&stack);
	StackPrint(&stack,"出栈3个元素");
}

void TestStackGet()
{
	TITLE;
	Stack stack;
	DataType value;
	StackInit(&stack);
	StackPush(&stack,'a');
	StackPush(&stack,'b');
	StackPush(&stack,'c');
	StackPush(&stack,'d');
	StackPrint(&stack,"入栈4个元素");
	int ret = StackGet(&stack,&value);
	printf("取栈顶元素:expect is [1|d],actul is [%d|%c]\n",ret,value);

	StackPop(&stack);
	StackPrint(&stack,"出栈1个元素");
	ret = StackGet(&stack,&value);
	printf("去栈顶元素:expect is [1|c],actul is [%d|%c]\n",ret,value);

}

int main()
{
	TestStackPush();
	TestStackPop();
	TestStackGet();
	return 0;
}

运行结果：