LeetCode225. 用队列实现栈

描述

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例

示例：

输入：
[“MyStack”, “push”, “push”, “top”, “pop”, “empty”]
[[ ], [1], [2], [ ], [ ], [ ]]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 Fals

解题思路以及代码

两个队列，Push数据时，谁不为空就入谁，保持一个队列为空，出栈的时候，倒一下。

typedef int QEDatatype;

typedef struct QENode
{
	QEDatatype data;
	struct QENode* next;
}QENode;

typedef struct Queue
{
	QENode* head;
	QENode* tail;
}QE;

//初始化
void QueueInit(QE* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}


//销毁
void QueueDestroy(QE* pq)
{
	assert(pq);
	QENode* cur = pq->head;
	while (cur)
	{
		QENode* del = cur;
		cur = cur->next;
		free(del);
	}
	pq->head = pq->tail = NULL;
}


//判空
bool QueueEmpty(QE* pq)
{
	assert(pq);
	return pq->head == NULL && pq->tail == NULL;
}

//入队
void QueuePush(QE* pq, QEDatatype x)
{
	assert(pq);
	QENode* newnode = (QENode*)malloc(sizeof(QENode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	//1.空
	//2.不为空
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = pq->tail->next;
	}
}


//出队
void QueuePop(QE* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	//链表只剩下一个结点，特殊处理。
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QENode* del = pq->head;
		pq->head = pq->head->next;
		free(del);
		del = NULL;
	}

}


//获取队头元素
QEDatatype QueueFront(QE* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	 
	return pq->head->data;
}


//获取队尾元素
QEDatatype QueueBack(QE* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	
	return pq->tail->data;
}

//队列中有效数据
int QueueSize(QE* pq)
{
	int count = 0;
	QENode* cur = pq->head;
	while (cur)
	{
		++count;
		cur = cur->next;
	}
	return count;
}


typedef struct {
    QE q1;
    QE q2;
} MyStack;


MyStack* myStackCreate() {
	//在堆申请空间，防止函数调用结束，变量生命周期结束，有野指针的问题
    MyStack* obj=(MyStack*)malloc(sizeof(MyStack));
    //初始化
    QueueInit(&(obj->q1));
    QueueInit(&(obj->q2));

    return obj;

}

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&(obj->q1)))
    {
        QueuePush(&(obj->q1),x);
    }
    else
    {
        QueuePush(&(obj->q2),x);
    }
}

int myStackPop(MyStack* obj) {
	//假设一下，这样写避免代码冗余
    QE* empty=&obj->q1;
    QE* noempty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty=&obj->q2;
        noempty=&obj->q1;
    }
    while(QueueSize(noempty) > 1)
    {
        QueuePush(empty,QueueFront(noempty));
        QueuePop(noempty);
    }
    int ret=QueueFront(noempty);
    QueuePop(noempty);
    return ret;

}

int myStackTop(MyStack* obj) {

    if(!QueueEmpty(&(obj->q1)))
    {
      return QueueBack(&(obj->q1));
    }
    else 
    {
        return QueueBack(&(obj->q2));
    }

}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&(obj->q1)) && QueueEmpty(&(obj->q2));
}

void myStackFree(MyStack* obj) {
	
    QueueDestroy(&(obj->q1));
    QueueDestroy(&(obj->q2));
    free(obj);

}

注意最后一个释放函数。一定不能直接free(obj)，因为我们申请的空间是如下图所示，所以先释放两个队列，在释放obj，不然会造成内存泄漏！