目录
void myStackPush(MyStack* obj, int x)
bool myStackEmpty(MyStack* obj)
void myStackFree(MyStack* obj)
题目描述
请你仅使用两个队列实现一个后入先出（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（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
示例
提示
题目分析
队列的性质：先进先出，后进后出。
栈的性质：后进先出，先进后出。
1、最开始我们初始化两个队列，利用它们的性质来模拟栈
2、最开始我们先在第一个空队列中存储数据
3、当我们存储数据时，在不为空的队列尾插入数据 ，这时候就来模拟栈存储数据过程
4、当我们取出栈顶数据时，也就是最后插入的数据（7），这时候我们可以把不为空的队列的数据（除了队尾的数据），拷贝到空队列中，并不断删除原来的不为空的队列的数据。在删除最后一个数据之前，保存该数据，并返回这个数据。这样就相当于于取出了栈顶数据。
总结：
存数据时：在不为空的队列里插入数据，如果两个队列都为空，那么就先在一个空队列中插入数据。
取数据时：找到不为空的队列，先把除了队尾以外的数据拷贝到空队列里，然后删除原来的不为空的队列里的数据。但是，在删除最后一个数据之前，保存该数据，并返回这个数据。
在实现功能之前，我们先模拟队列，在这里就不讲述了，详细请看：
队列的模拟实现（单链链表模拟）_暴走的橙子～的博客-优快云博客
结构体的创建
typedef struct
{
Queue q1;//q1指向一个队列
Queue q2;//q2指向一个队列
} MyStack;
MyStack* myStackCreate()
{
MyStack* st = (MyStack*)malloc(sizeof(MyStack));//st指向这个存放两个队列的结构体
QueueInit(&st->q1);
QueueInit(&st->q2);
return st;
}typedef struct
{
Queue q1;//q1指向一个队列
Queue q2;//q2指向一个队列
} MyStack;
MyStack* myStackCreate()
{
MyStack* st = (MyStack*)malloc(sizeof(MyStack));//st指向这个存放两个队列的结构体
QueueInit(&st->q1); //初始化q1队列
QueueInit(&st->q2);//初始化q2队列
return st;//返回这个结构体的地址(MyStack)
}
函数接口
void myStackPush(MyStack* obj, int x)
void myStackPush(MyStack* obj, int x)
{
assert(obj);
if (!QueueEmpty(&obj->q1))
{
QueuePush(&obj->q1, x);
}
else
{
QueuePush(&obj->q2, x);
}
}void myStackPush(MyStack* obj, int x)
{
assert(obj);
if (!QueueEmpty(&obj->q1)) //当q1非空时，就往q1插入数据
{
QueuePush(&obj->q1, x);
}
else //如果q1为空，就往q2插入数据，此时q2无论是否为空都不影响
{
QueuePush(&obj->q2, x);
}
}
int myStackPop(MyStack* obj)
int myStackPop(MyStack* obj)
{
assert(obj);
Queue* emptyQ = &obj->q1;
Queue* noemptyQ = &obj->q2;
if (QueueEmpty(&obj->q2))
{
noemptyQ = &obj->q1;
emptyQ = &obj->q2;
}int myStackPop(MyStack* obj)
{
assert(obj);
Queue* emptyQ = &obj->q1;//假设q1队列为空
Queue* noemptyQ = &obj->q2;//假设q2队列不为空
if (QueueEmpty(&obj->q2))//如果q2为空，交换上面定义的两个指针变量
{
noemptyQ = &obj->q1;
emptyQ = &obj->q2;
}
int myStackTop(MyStack* obj)
int myStackTop(MyStack* obj)
{
assert(obj);
if (!QueueEmpty(&obj->q1))
{
return QueueTail(&obj->q1);
}
else
{
return QueueTail(&obj->q2);
}
}int myStackTop(MyStack* obj)
{
assert(obj);
if (!QueueEmpty(&obj->q1)) //找到不为空的队列，返回队尾数据
{
return QueueTail(&obj->q1);
}
else
{
return QueueTail(&obj->q2);
}
}
bool myStackEmpty(MyStack* obj)
bool myStackEmpty(MyStack* obj)
{
assert(obj);
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);//当两个队列都为空时，条件为真
}bool myStackEmpty(MyStack* obj)
{
assert(obj);
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);//当两个队列都为空时，条件为真
}
void myStackFree(MyStack* obj)
void myStackFree(MyStack* obj)
{
assert(obj);
QueueDestroy(&obj->q1);
QueueDestroy(&obj->q2);
free(obj);
}void myStackFree(MyStack* obj)
{
assert(obj);//先释放队列
QueueDestroy(&obj->q1);
QueueDestroy(&obj->q2);//在释放掉结构体，否则两个队列的那块空间就会找不到了
free(obj);
}
完整代码
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueueNode
{
struct QueueNode* next;
QDataType data;
}QNode;
typedef struct Queue
{
QNode* head;
QNode* tail;
}Queue;
void QueueInit(Queue* q);
void QueuePush(Queue* q, QDataType x);
void QueuePop(Queue* q);
QDataType QueueTail(Queue* q);
QDataType QueueHead(Queue* q);
int QueueSize(Queue* q);
void QueueDestroy(Queue* q);
bool QueueEmpty(Queue* q);
void QueueInit(Queue* q)
{
assert(q);
q->head = NULL;
q->tail = NULL;
}
void QueuePush(Queue* q, QDataType x)
{
assert(q);
//开辟一个结点
QNode* tmp = (QNode*)malloc(sizeof(QNode));
if (tmp == NULL)
{
printf("malloc fail\n");
exit(-1);
}
tmp->data = x;
tmp->next = NULL;
if (QueueEmpty(q))
{
q->head = q->tail = tmp;
}
else
{
q->tail->next = tmp;
q->tail = tmp;
}
}
void QueuePop(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
QNode* next = q->head->next;
free(q->head);
q->head = next;
if (q->head == NULL)
{
q->tail = NULL;
}
}
QDataType QueueTail(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
return q->tail->data;
}
QDataType QueueHead(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
return q->head->data;
}
int QueueSize(Queue* q)
{
assert(q);
QNode* cur = q->head;
int size = 0;
while (cur)
{
cur = cur->next;
size++;
}
return size;
}
void QueueDestroy(Queue* q)
{
assert(q);
QNode* cur = q->head;
while (cur)
{
QNode* next = cur->next;
free(cur);
cur = next;
}
//空间释放完之后，头结点和尾结点还记着原来的地址，在这里需要置空
q->tail = q->head = NULL;
}
bool QueueEmpty(Queue* q)
{
assert(q);
return q->head == NULL;
}
typedef struct
{
Queue q1;//q1指向一个队列
Queue q2;//q2指向一个队列
} MyStack;
MyStack* myStackCreate()
{
MyStack* st = (MyStack*)malloc(sizeof(MyStack));//st指向这个存放两个队列的结构体
QueueInit(&st->q1);
QueueInit(&st->q2);
return st;
}
void myStackPush(MyStack* obj, int x)
{
assert(obj);
if (!QueueEmpty(&obj->q1))
{
QueuePush(&obj->q1, x);
}
else
{
QueuePush(&obj->q2, x);
}
}
int myStackPop(MyStack* obj)
{
assert(obj);
Queue* emptyQ = &obj->q1;
Queue* noemptyQ = &obj->q2;
if (QueueEmpty(&obj->q2))
{
noemptyQ = &obj->q1;
emptyQ = &obj->q2;
}
while (QueueSize(noemptyQ) > 1)
{
QueuePush(emptyQ, QueueHead(noemptyQ));
QueuePop(noemptyQ);
}
QDataType tmp = QueueHead(noemptyQ);
QueuePop(noemptyQ);
return tmp;
}
int myStackTop(MyStack* obj)
{
assert(obj);
if (!QueueEmpty(&obj->q1))
{
return QueueTail(&obj->q1);
}
else
{
return QueueTail(&obj->q2);
}
}
bool myStackEmpty(MyStack* obj)
{
assert(obj);
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);//当两个队列都为空时，条件为真
}
void myStackFree(MyStack* obj)
{
assert(obj);
QueueDestroy(&obj->q1);
QueueDestroy(&obj->q2);
free(obj);
}测试结果：
扫一扫
1413
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
