[LeetCode-225] Implement Stack using Queues（两个队列实现栈）
Implement the following operations of a stack using queues.
- push(x) -- Push element x onto stack.
- pop() -- Removes the element on top of the stack.
- top() -- Get the top element.
- empty() -- Return whether the stack is empty.
- You must use only standard operations of a queue -- which means only
push to back,peek/pop from front,size, andis emptyoperations are valid. - Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.
- You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).
Update (2015-06-11):
The class name of the Java function had been updated to MyStack instead of Stack.
思路
用两个队列模拟一个堆栈：
队列a和b
（1）取栈顶元素： 返回有元素的队列的首元素
（2）判栈空：若队列a和b均为空则栈空
（3）入栈：a队列当前有元素，b为空（倒过来也一样）则将需要入栈的元素先放b中，然后将a中的元素依次出列并入列倒b中。（保证有一个队列是空的）
（4）出栈：将有元素的队列出列即可。
比如先将1插入队a中 ，现在要将2入栈，则将2插入b总然后将a中的1出列入到b中，b中的元素变为 2 ，1
a为空，现在要压入3 则将3插入a中 ，依次将b中的2 ，1 出列并加入倒a中 ，a中的元素变为 3，2，1 b为空
总结：两个栈有一个为空，另一个有元素，或者两个都为空，只要哪个栈有元素，先把元素插入到这个队列。弹栈：将有元素的队列全部元素除去要弹出的元素，先从队列1删除，压入队列2，然后再将队列1最后一个元素删除。算法保证在任何时候都有一队列为空
struct QUEUE_NODE
{
int* pData;
int QueueLenMax;//队列最大长度
int head ;//队头指针
int tail;//队尾指针
int QueueCurLen;//队列元素当前个数
};
typedef struct {
struct QUEUE_NODE *pQueueNode_First;
struct QUEUE_NODE *pQueueNode_Second;
} Stack;
struct QUEUE_NODE* alloc_queue(int Queue_Max_Size)
{
if(Queue_Max_Size <= 0)
return NULL;
struct QUEUE_NODE* pQueueNode = NULL;
pQueueNode = (struct QUEUE_NODE*)malloc(sizeof(struct QUEUE_NODE));
if(NULL == pQueueNode) {
return NULL;
}
memset(pQueueNode, 0, sizeof(struct QUEUE_NODE));
pQueueNode->pData = (int*)malloc(sizeof(int) * Queue_Max_Size);
if(NULL == pQueueNode->pData) {
goto malloc_failed;
}
pQueueNode->QueueLenMax = Queue_Max_Size;//队列长度
pQueueNode->head = 0;
pQueueNode->tail = 0;
pQueueNode->QueueCurLen = 0;
return pQueueNode;
malloc_failed:
free(pQueueNode);
return NULL;
}
int free_queue(struct QUEUE_NODE* pQueueNode)
{
if(NULL == pQueueNode)
return -1;
if(NULL == pQueueNode->pData) {
free(pQueueNode);
return -1;
}
free(pQueueNode->pData);
free(pQueueNode);
return 0;
}
int queue_push(struct QUEUE_NODE* pQueueNode, int value)
{
if(NULL == pQueueNode)
return -1;
if(pQueueNode->QueueLenMax == pQueueNode->QueueCurLen)//判断是不是溢出
return -1;
pQueueNode->pData[pQueueNode->tail] = value;
pQueueNode->tail = (pQueueNode->tail + 1) % pQueueNode->QueueLenMax; //队尾指针位置
pQueueNode->QueueCurLen ++;
return 0;
}
int queue_pop(struct QUEUE_NODE* pQueueNode, int* value)
{
if(NULL == pQueueNode || NULL == value)
return -1;
if(0 == pQueueNode->QueueCurLen)
return -1;
*value = pQueueNode->pData[pQueueNode->head];
pQueueNode->pData[pQueueNode->head] = 0; //被弹出的位置赋值为0
pQueueNode->QueueCurLen --;
pQueueNode->head = (pQueueNode->head + 1) % pQueueNode->QueueLenMax;//重新定位队头指针的位置
return 0;
}
int get_queue_curlen(struct QUEUE_NODE* pQueueNode)
{
if(NULL == pQueueNode)
return -1;
return pQueueNode->QueueCurLen;
}
int get_queue_maxlen(struct QUEUE_NODE* pQueueNode)
{
if(NULL == pQueueNode)
return 0;
return pQueueNode->QueueLenMax;
}
void print_queue_node(struct QUEUE_NODE *pQueueNode)
{
/*1.输入的参数有误*/
if(NULL == pQueueNode) {
printf("[%d] pQueueNode is illegal! \n",__LINE__);
return;
}
/*2.输入的链式堆栈为空*/
if(0 == pQueueNode->QueueCurLen) {
printf("[%d] pQueueNode is empty!\n",__LINE__);
return ;
}
struct QUEUE_NODE *pQueueNodeTemp = pQueueNode;
int count = 0;
printf("The pQueueNode is: ");
while(count < pQueueNode->QueueCurLen) {
printf("%d ",pQueueNode->pData[pQueueNode->head+count]);
count++;;
}
printf("\n");
}
/* Create a stack */
void stackCreate(Stack *stack, int maxSize)
{
if(!stack) {
return;
}
if(maxSize<=0)
return;
/*创建两个队列*/
stack->pQueueNode_First = alloc_queue(maxSize);
stack->pQueueNode_Second= alloc_queue(maxSize);
}
/* Push element x onto stack */
void stackPush(Stack *stack, int element)
{
if(!stack)
return;
if(!stack->pQueueNode_First||!stack->pQueueNode_Second)
return;
/**
两个栈有一个为空，另一个有元素，或者两个都为空
只要哪个栈有元素，先把元素插入到这个队列
**/
if(stack->pQueueNode_First->QueueCurLen == 0 &&
stack->pQueueNode_Second->QueueCurLen == 0) {
queue_push(stack->pQueueNode_First,element);
return;
}
if(stack->pQueueNode_First->QueueCurLen != 0) {
queue_push(stack->pQueueNode_First,element);
}
if(stack->pQueueNode_Second->QueueCurLen != 0) {
queue_push(stack->pQueueNode_Second,element);
}
}
/* Removes the element on top of the stack */
void stackPop(Stack *stack)
{
if(!stack)
return;
if(!stack->pQueueNode_First&&!stack->pQueueNode_Second)
return;
int a = 0;
/*栈1为空*/
if(stack->pQueueNode_First->QueueCurLen == 0
&& stack->pQueueNode_Second->QueueCurLen == 0) {
return;
}
/*栈1保存数据*/
if(stack->pQueueNode_First->QueueCurLen != 0) {
/*栈1剩下最后一个要删除数据*/
while(1 != stack->pQueueNode_First->QueueCurLen) {
queue_pop(stack->pQueueNode_First,&a);
queue_push(stack->pQueueNode_Second,a);
}
/*实现栈弹出数据*/
queue_pop(stack->pQueueNode_First,&a);
return; /*及时退出*/
}
/*栈2保存数据*/
if(stack->pQueueNode_Second->QueueCurLen != 0) {
while(1 != stack->pQueueNode_Second->QueueCurLen) {
queue_pop(stack->pQueueNode_Second,&a);
queue_push(stack->pQueueNode_First,a);
}
/*实现栈弹出数据*/
queue_pop(stack->pQueueNode_Second,&a);
}
}
/* Get the top element */
int stackTop(Stack *stack)
{
if(!stack)
return -1;
if(!stack->pQueueNode_First&&!stack->pQueueNode_Second)
return -1;
int a = 0;
/*栈1为空*/
if(stack->pQueueNode_First->QueueCurLen == 0
&& stack->pQueueNode_Second->QueueCurLen == 0) {
return -1;
}
/*栈1保存数据*/
if(stack->pQueueNode_First->QueueCurLen != 0) {
/*栈1剩下最后一个要删除数据*/
while(0 != stack->pQueueNode_First->QueueCurLen) {
queue_pop(stack->pQueueNode_First,&a);
queue_push(stack->pQueueNode_Second,a);
}
return a; /*及时退出*/
}
/*栈2保存数据*/
if(stack->pQueueNode_Second->QueueCurLen != 0) {
while(0 != stack->pQueueNode_Second->QueueCurLen) {
queue_pop(stack->pQueueNode_Second,&a);
queue_push(stack->pQueueNode_First,a);
}
}
return a;
}
/* Return whether the stack is empty */
bool stackEmpty(Stack *stack)
{
if(!stack)
return 1;
if(!stack->pQueueNode_First&&!stack->pQueueNode_Second)
return 1;
if(stack->pQueueNode_First->QueueCurLen == 0
&& stack->pQueueNode_Second->QueueCurLen == 0) {
return 1;
}
return 0;
}
/* Destroy the stack */
void stackDestroy(Stack *stack)
{
/*1.输入的参数有误*/
if(!stack)
return;
if(!stack->pQueueNode_First&&!stack->pQueueNode_Second)
return;
free_queue(stack->pQueueNode_First);
free_queue(stack->pQueueNode_Second);
}
/* print the stack */
void print_stack_node(Stack *stack)
{
/*1.输入的参数有误*/
if(!stack)
return;
if(!stack->pQueueNode_First&&!stack->pQueueNode_Second)
return;
print_queue_node(stack->pQueueNode_First);
print_queue_node(stack->pQueueNode_Second);
}
全部代码如下所示：
// LeetCode225-Implement Stack using Queues.cpp : 定义控制台应用程序的入口点。
//
//两个队列实现一个栈
//Written by ZP1015
//2015.10.21
#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
struct QUEUE_NODE
{
int* pData;
int QueueLenMax;//队列最大长度
int head ;//队头指针
int tail;//队尾指针
int QueueCurLen;//队列元素当前个数
};
typedef struct {
struct QUEUE_NODE *pQueueNode_First;
struct QUEUE_NODE *pQueueNode_Second;
} Stack;
struct QUEUE_NODE* alloc_queue(int Queue_Max_Size)
{
if(Queue_Max_Size <= 0)
return NULL;
struct QUEUE_NODE* pQueueNode = NULL;
pQueueNode = (struct QUEUE_NODE*)malloc(sizeof(struct QUEUE_NODE));
if(NULL == pQueueNode) {
return NULL;
}
memset(pQueueNode, 0, sizeof(struct QUEUE_NODE));
pQueueNode->pData = (int*)malloc(sizeof(int) * Queue_Max_Size);
if(NULL == pQueueNode->pData) {
goto malloc_failed;
}
pQueueNode->QueueLenMax = Queue_Max_Size;//队列长度
pQueueNode->head = 0;
pQueueNode->tail = 0;
pQueueNode->QueueCurLen = 0;
return pQueueNode;
malloc_failed:
free(pQueueNode);
return NULL;
}
int free_queue(struct QUEUE_NODE* pQueueNode)
{
if(NULL == pQueueNode)
return -1;
if(NULL == pQueueNode->pData) {
free(pQueueNode);
return -1;
}
free(pQueueNode->pData);
free(pQueueNode);
return 0;
}
int queue_push(struct QUEUE_NODE* pQueueNode, int value)
{
if(NULL == pQueueNode)
return -1;
if(pQueueNode->QueueLenMax == pQueueNode->QueueCurLen)//判断是不是溢出
return -1;
pQueueNode->pData[pQueueNode->tail] = value;
pQueueNode->tail = (pQueueNode->tail + 1) % pQueueNode->QueueLenMax; //队尾指针位置
pQueueNode->QueueCurLen ++;
return 0;
}
int queue_pop(struct QUEUE_NODE* pQueueNode, int* value)
{
if(NULL == pQueueNode || NULL == value)
return -1;
if(0 == pQueueNode->QueueCurLen)
return -1;
*value = pQueueNode->pData[pQueueNode->head];
pQueueNode->pData[pQueueNode->head] = 0; //被弹出的位置赋值为0
pQueueNode->QueueCurLen --;
pQueueNode->head = (pQueueNode->head + 1) % pQueueNode->QueueLenMax;//重新定位队头指针的位置
return 0;
}
int get_queue_curlen(struct QUEUE_NODE* pQueueNode)
{
if(NULL == pQueueNode)
return -1;
return pQueueNode->QueueCurLen;
}
int get_queue_maxlen(struct QUEUE_NODE* pQueueNode)
{
if(NULL == pQueueNode)
return 0;
return pQueueNode->QueueLenMax;
}
void print_queue_node(struct QUEUE_NODE *pQueueNode)
{
/*1.输入的参数有误*/
if(NULL == pQueueNode) {
printf("[%d] pQueueNode is illegal! \n",__LINE__);
return;
}
/*2.输入的链式堆栈为空*/
if(0 == pQueueNode->QueueCurLen) {
printf("[%d] pQueueNode is empty!\n",__LINE__);
return ;
}
struct QUEUE_NODE *pQueueNodeTemp = pQueueNode;
int count = 0;
printf("The pQueueNode is: ");
while(count < pQueueNode->QueueCurLen) {
printf("%d ",pQueueNode->pData[pQueueNode->head+count]);
count++;;
}
printf("\n");
}
/* Create a stack */
void stackCreate(Stack *stack, int maxSize)
{
if(!stack) {
return;
}
if(maxSize<=0)
return;
/*创建两个队列*/
stack->pQueueNode_First = alloc_queue(maxSize);
stack->pQueueNode_Second= alloc_queue(maxSize);
}
/* Push element x onto stack */
void stackPush(Stack *stack, int element)
{
if(!stack)
return;
if(!stack->pQueueNode_First||!stack->pQueueNode_Second)
return;
/**
两个栈有一个为空，另一个有元素，或者两个都为空
只要哪个栈有元素，先把元素插入到这个队列
**/
if(stack->pQueueNode_First->QueueCurLen == 0 &&
stack->pQueueNode_Second->QueueCurLen == 0) {
queue_push(stack->pQueueNode_First,element);
return;
}
if(stack->pQueueNode_First->QueueCurLen != 0) {
queue_push(stack->pQueueNode_First,element);
}
if(stack->pQueueNode_Second->QueueCurLen != 0) {
queue_push(stack->pQueueNode_Second,element);
}
}
/* Removes the element on top of the stack */
void stackPop(Stack *stack)
{
if(!stack)
return;
if(!stack->pQueueNode_First&&!stack->pQueueNode_Second)
return;
int a = 0;
/*栈1为空*/
if(stack->pQueueNode_First->QueueCurLen == 0
&& stack->pQueueNode_Second->QueueCurLen == 0) {
return;
}
/*栈1保存数据*/
if(stack->pQueueNode_First->QueueCurLen != 0) {
/*栈1剩下最后一个要删除数据*/
while(1 != stack->pQueueNode_First->QueueCurLen) {
queue_pop(stack->pQueueNode_First,&a);
queue_push(stack->pQueueNode_Second,a);
}
/*实现栈弹出数据*/
queue_pop(stack->pQueueNode_First,&a);
return; /*及时退出*/
}
/*栈2保存数据*/
if(stack->pQueueNode_Second->QueueCurLen != 0) {
while(1 != stack->pQueueNode_Second->QueueCurLen) {
queue_pop(stack->pQueueNode_Second,&a);
queue_push(stack->pQueueNode_First,a);
}
/*实现栈弹出数据*/
queue_pop(stack->pQueueNode_Second,&a);
}
}
/* Get the top element */
int stackTop(Stack *stack)
{
if(!stack)
return -1;
if(!stack->pQueueNode_First&&!stack->pQueueNode_Second)
return -1;
int a = 0;
/*栈1为空*/
if(stack->pQueueNode_First->QueueCurLen == 0
&& stack->pQueueNode_Second->QueueCurLen == 0) {
return -1;
}
/*栈1保存数据*/
if(stack->pQueueNode_First->QueueCurLen != 0) {
/*栈1剩下最后一个要删除数据*/
while(0 != stack->pQueueNode_First->QueueCurLen) {
queue_pop(stack->pQueueNode_First,&a);
queue_push(stack->pQueueNode_Second,a);
}
return a; /*及时退出*/
}
/*栈2保存数据*/
if(stack->pQueueNode_Second->QueueCurLen != 0) {
while(0 != stack->pQueueNode_Second->QueueCurLen) {
queue_pop(stack->pQueueNode_Second,&a);
queue_push(stack->pQueueNode_First,a);
}
}
return a;
}
/* Return whether the stack is empty */
bool stackEmpty(Stack *stack)
{
if(!stack)
return 1;
if(!stack->pQueueNode_First&&!stack->pQueueNode_Second)
return 1;
if(stack->pQueueNode_First->QueueCurLen == 0
&& stack->pQueueNode_Second->QueueCurLen == 0) {
return 1;
}
return 0;
}
/* Destroy the stack */
void stackDestroy(Stack *stack)
{
/*1.输入的参数有误*/
if(!stack)
return;
if(!stack->pQueueNode_First&&!stack->pQueueNode_Second)
return;
free_queue(stack->pQueueNode_First);
free_queue(stack->pQueueNode_Second);
}
/* print the stack */
void print_stack_node(Stack *stack)
{
/*1.输入的参数有误*/
if(!stack)
return;
if(!stack->pQueueNode_First&&!stack->pQueueNode_Second)
return;
print_queue_node(stack->pQueueNode_First);
print_queue_node(stack->pQueueNode_Second);
}
int main()
{
Stack pStackNode;
stackCreate(&pStackNode,20);
print_stack_node(&pStackNode);
int i = 0;
for (i = 0;i<10;i++) {
stackPush(&pStackNode,i);/*入栈*/
}
print_stack_node(&pStackNode);
/*出栈*/
stackPop(&pStackNode);
print_stack_node(&pStackNode);
/*获得栈顶元素*/
printf("top %d\n",stackTop(&pStackNode));
printf("stackEmpty %d\n",stackEmpty(&pStackNode));
stackDestroy(&pStackNode);
getchar();
getchar();
return 0;
}