出栈:哪个队列不为空,将该队列中前n-1个元素挪到另一个空队列中,然后将该队列中仅剩的元素出队列。
入栈:哪个队列不为空,将元素放到哪个队列中即可。
获取栈顶元素:哪个队列不为空,该队列的队尾就是栈顶元素。
typedef int QDataType;
typedef struct QNode
{
struct QNode* next;
QDataType data;
}QNode;
typedef struct Queue
{
QNode* front; // 队头
QNode* back; // 队尾
}Queue;
typedef struct {
Queue q1;
Queue q2;
} MyStack;
QNode* buyQNode(QDataType data)
{
QNode* newNode = (QNode*)malloc(sizeof(QNode));
if (NULL == newNode)
{
assert(0);
return NULL;
}
newNode->data = data;
newNode->next = NULL;
return newNode;
}
// 初始化队列
void QueueInit(Queue* q)
{
assert(q);
q->front = buyQNode(0);
q->back = q->front;
}
// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
assert(q);
QNode* newNode = buyQNode(data);
q->back->next = newNode;
q->back = newNode;
}
// 检测队列是否为空,如果为空返回非零结果,如果非空返回0
int QueueEmpty(Queue* q)
{
assert(q);
return q->front == q->back;
}
// 队头出队列
void QueuePop(Queue* q)
{
QNode* delNode = NULL;
if (QueueEmpty(q))
return;
delNode = q->front->next;
q->front->next = delNode->next;
// 注意:队列中刚好只有一个元素,删除之后应该要将队尾back放在头节点的位置
if (delNode == q->back)
q->back = q->front;
free(delNode);
}
// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
assert(q);
return q->front->next->data;
}
// 获取队列尾部元素
QDataType QueueBack(Queue* q)
{
assert(q);
return q->back->data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
assert(q);
QNode* cur = q->front->next;
int count = 0;
while (cur)
{
count++;
cur = cur->next;
}
return count;
}
// 销毁队列
void QueueDestroy(Queue* q)
{
assert(q);
QNode* cur = q->front->next;
while (cur)
{
q->front->next = cur->next;
free(cur);
cur = q->front->next;
}
free(q->front);
q->front = q->back = NULL;
}
//模拟栈初始化
MyStack* myStackCreate() {
MyStack* mystack=(MyStack*)malloc(sizeof(MyStack));
if(mystack==NULL)
{
return NULL;
}
QueueInit(&mystack->q1);
QueueInit(&mystack->q2);
return mystack;
}
//用队列模拟入栈
void myStackPush(MyStack* obj, int x) {
assert(obj);
if(!QueueEmpty(&obj->q1))
{
QueuePush(&obj->q1,x);
}
else
QueuePush(&obj->q2,x);
}
///获取模拟栈的栈顶元素
int myStackTop(MyStack* obj) {
assert(obj);
if(!QueueEmpty(&obj->q1))
{
return QueueBack(&obj->q1);
}
else
{
return QueueBack(&obj->q2);
}
}
//用队列模拟出栈
int myStackPop(MyStack* obj) {
int ret;
assert(obj);
if(!QueueEmpty(&obj->q1))
{
while(QueueSize(&obj->q1)>1)
{
QueuePush(&obj->q2, QueueFront(&obj->q1));
QueuePop(&obj->q1);
}
ret= QueueFront(&obj->q1);
QueuePop(&obj->q1);
}
else
{
while(QueueSize(&obj->q2)>1)
{
QueuePush(&obj->q1, QueueFront(&obj->q2));
QueuePop(&obj->q2);
}
ret=QueueFront(&obj->q2);
QueuePop(&obj->q2);
}
return ret;
}
//判断模拟栈是否为空
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);
}