【c语言】两个栈实现一个队列

两个栈实现一个队列

核心思想：模拟出队列先进先出的数据结构
假设有两个栈input和output，input模拟栈的数据插入，当需要模拟出队列操作时，input栈中的A,B,C,D会按照D,C,B,A的顺序进入栈output。 只要output栈不为空，出队列操作就可以通过output的出栈操作来实现。
若output栈为空，则继续从input栈导入数据。
若两个栈都为空，即整个队列为空。

代码模拟：
Queueby_two_stack.h

#pragma once

typedef int 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 QueueDestory(Queue *queue);
//入栈函数
void QueuePush(Queue *queue, DataType value);
//出栈函数
void QueuePop(Queue *queue);
//取栈顶元素函数
DataType QueueFront(Queue *queue);

Queueby_two_stack.c

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "Queueby_two_stack.h"

void StackInit(Stack* stack,DataType capacity)
{
	if (stack == NULL)
	{
		assert(0);
		return -1;
	}
	stack->capacity = capacity;
	stack->size = 0;
	stack->Data = (DataType*)malloc(sizeof(DataType)* stack->capacity);
}

//栈销毁函数
void StackDestory(Stack* stack)
{
	if(stack == NULL)
	{
		assert(0);
		return -1;
	}
	free(stack->Data);
	stack->Data = NULL;
	stack->capacity = 0;
	stack->size = 0;
}

//入栈操作
void StackPush(Stack* stack,DataType value)
{
	if (stack == NULL)
	{
		assert(0);
		return -1;
	}
	if (StackFull(stack))
	{
		int new_capacity = stack->capacity * 2;
		DataType *newDate = (DataType *)malloc(sizeof(DataType) * new_capacity);
		if (newDate == NULL)
		{
			assert(0);
		}
		for (int i = 0; i < stack->size; ++i)
		{
			newDate[i] = stack->Data[i];
		}
		stack->Data = newDate;
		stack->capacity = new_capacity;
	}
	else
	{
		stack->Data[stack->size + 1] = value;
		stack->size++;
	}
}

int StackFull(Stack* stack)
{
	if(stack == NULL)
	{
		assert(0);
		return -1;
	}
	if (stack->size == stack->capacity)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

int StackEmpty(Stack* stack)
{
	if (stack == NULL)
	{
		assert(0);
		return -1;
	}
	if (stack->size == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

//出栈操作
int StackPop(Stack* stack)
{
	if (stack == NULL)
	{
		assert(0);
		return -1;
	}
	if(stack->size == 0)
	{
		return ;
	}
	stack->size--;
}

//取栈顶元素
DataType StackGetTop(Stack* stack)
{
	if (stack == NULL)
	{
		assert(0);
		return -1;
	}
	if (stack->size == 0)
	{
		return ; 
	}
	else
	{
		return stack->Data[stack->size-1];
	}
}

//队列初始化函数
void QueueInit(Queue* queue,DataType capacity)
{
	if (queue == NULL)
	{
		assert(0);
	}
	StackInit(&queue->input,capacity);
	StackInit(&queue->output, capacity);
	queue->size = 0;
}

//队列销毁函数
void QueueDestory(Queue *queue)
{
	if (queue == NULL)
	{
		assert(0);
	}
	StackDestory(&queue->input);
	StackDestory(&queue->output);
	queue->size = 0;
}

//入队列函数
void QueuePush(Queue *queue, DataType value)
{
	if (queue == NULL)
	{
		assert(0);
		return -1;
	}
	StackPush(&queue->input, value);
	queue->size++;
}

//出队列函数
void QueuePop(Queue* queue)
{
	if (queue == NULL)
	{
		assert(0);
		return -1;
	}
	if (StackEmpty(&queue->output))
	{
		if (StackEmpty(&queue->input))
		{
			return ;
		}
		else
		{
			int newsize = queue->input.size;
			for(int i = 0;i< newsize;++i)
			{
				DataType tmp = StackGetTop(&queue->input);
				StackPop(&queue->input);
				StackPush(&queue->output,tmp);
			}
		}
	}
	StackPop(&queue->output);
	queue->size--;

}

//取队首元素函数
DataType QueueFront(Queue* queue)
{
	if (queue == NULL)
	{
		assert(0);
		return -1;
	}
	if (StackEmpty(&queue->output))
	{
		if (StackEmpty(&queue->input))
		{
			return ;
		}
		else
		{
			int newsize = queue->input.size;
			for (int i = 0; i <newsize ; ++i)
			{
				DataType tmp = StackGetTop(&queue->input);
				StackPop(&queue->input);
				StackPush(&queue->output, tmp);
			}
		}
	}
	return StackGetTop(&queue->output);
}
int main()
{
	Queue queue;
	QueueInit(&queue,10);
	//入队列函数测试
	QueuePush(&queue, 1);
	QueuePush(&queue, 2);
	QueuePush(&queue, 3);
	QueuePush(&queue, 4);
	QueuePop(&queue);
	DataType tmp = QueueFront(&queue);
	printf("%d \n", tmp);
	system("pause");
	return 0;
}