队列实现栈

用两个队列实现一个栈

题目链接

题目描述

 

解题思路

首先梳理下队列和栈的概念, 队列是所有数据先入先出, 而栈是后入先出

第二步, 用两个队列结构模拟出一个栈结构

第三步，思考如何用模拟出来的栈，完成入栈, 出栈, 取栈顶数据和判空操作，这里说一下我的思路

入栈: 入不为空的队列,  如果两个队列都为空则入队列2

出栈: 将不为空队列中的数据导入到空的队列中, 让不为空队列只剩一个数据, 最后将这个数据出队, 这样就模拟了出栈操作

取栈顶数据: 取不为空的队尾数据, 就是取栈顶数据

判断栈是否为空: 如果两个队列都没有数据，就表示栈为空

下面代码实现

typedef int QueDataType;
typedef struct QueNode
{
	QueDataType data;
	struct QueNode* next;
}QueNode;

typedef struct Queue
{
	QueNode* head;
	QueNode* tail;
	int size;
}Queue;

// 初始化队列
void QueInit(Queue* pq);
// 销毁队列
void QueDestroy(Queue* pq);
// 入队
void QuePush(Queue* pq, QueDataType x);
// 出队
void QuePop(Queue* pq);
// 计算队列中数据个数
int QueSize(Queue* pq);
// 判空
bool isQueEmpty(Queue* pq);
// 取队头数据
QueDataType QueFront(Queue* pq);
// 取队尾数据
QueDataType QueBack(Queue* pq);
// 初始化
void QueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
// 销毁
void QueDestroy(Queue* pq)
{
	assert(pq);
	QueNode* cur = pq->head;
	while (cur)
	{
		QueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
// 入队
void QuePush(Queue* pq, QueDataType x)
{
	assert(pq);
	QueNode* newnode = (QueNode*)malloc(sizeof(QueNode));
	if (NULL == newnode)
	{
		perror("QuePush::malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;

	if (NULL == pq->head)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}
// 出队
void QuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	// 处理单个节点的特殊情况
	if (NULL == pq->head->next)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QueNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}
// 计算队列中数据个数
int QueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
// 判空
bool isQueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}
// 取队头数据
QueDataType QueFront(Queue* pq)
{
	assert(pq);
	assert(!isQueEmpty(pq));
	return pq->head->data;
}
// 取队尾数据
QueDataType QueBack(Queue* pq)
{
	assert(pq);
	assert(!isQueEmpty(pq));
	return pq->tail->data;
}

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


MyStack* myStackCreate() {
    MyStack* st = malloc(sizeof(MyStack));
    // 初始化
    QueInit(&st->q1);
    QueInit(&st->q2);
    return st;
}

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

int myStackPop(MyStack* obj) {
    Queue* EmptyQue = &obj->q2;
    Queue* NoneEmptyQue = &obj->q1;
    if (isQueEmpty(&obj->q1))
    {
        EmptyQue = &obj->q1;
        NoneEmptyQue = &obj->q2;
    }
    while (QueSize(NoneEmptyQue) > 1)
    {
        QuePush(EmptyQue, QueFront(NoneEmptyQue));
        QuePop(NoneEmptyQue);
    }
    int ret = QueFront(NoneEmptyQue);
    QuePop(NoneEmptyQue);
    return ret;
}

int myStackTop(MyStack* obj) {
    if (isQueEmpty(&obj->q1))
    {
        return QueBack(&obj->q2);
    }
    else 
    {
        return QueBack(&obj->q1);
    }
}

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

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

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/