C语言用队列实现栈

biter down

已于 2023-03-30 23:17:14 修改

阅读量160

点赞数 1

文章标签： c语言

于 2023-03-30 23:14:04 首次发布

本文链接：https://blog.csdn.net/m0_73919066/article/details/129869118

版权

该文描述了一个C语言实现的栈，它利用两个队列（q1和q2）作为底层数据结构。当向栈push元素时，如果q1非空，则将元素入q1，否则入q2。pop操作会将非空队列的所有元素转移到另一个空队列，然后返回队列顶部的元素。myStackTop函数则返回栈顶但不移除的元素。myStackEmpty检查两个队列是否都为空。整个实现涉及到了动态内存分配和链表操作。

摘要由CSDN通过智能技术生成

//创建两个队列，将队列中前面的值放入另一个空队列中，以求队列中的最后一个值取出

#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
#include<stdio.h>

//队列的实现
typedef int QDataType;

typedef struct QueueNode
{
struct QueueNode* next;
QDataType data;

}QNode;

//将队列的首尾指针独立出来一个新的结构体以方便管理

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

//将结构Queue中的值初始化

void QueueInit(Queue* pq)
{
assert(pq);

pq->head = pq->tail = NULL;
pq->size = 0;
}

//队列的销毁

void QueueDestroy(Queue* pq)
{
   assert(pq);
   QNode* cur = pq->head;
   while (cur)
   {
       QNode* next = cur->next;
       free(cur);
       cur = next;
   }
   pq->head = pq->tail = NULL;
   pq->size = 0;
}

void QueuePush(Queue* pq, QDataType x)
{
   QNode* newnode = (QNode*)malloc(sizeof(QNode));
   if (newnode == NULL)
   {
       perror("malloc fail");
       return;
   }
   newnode->data = x;
   newnode->next = NULL;

   if (pq->head == NULL)
   {
       assert(pq->tail == NULL);
       pq->head = pq->tail = newnode;
   }
   else
   {
       pq->tail->next = newnode;
       pq->tail = newnode;
   }
   pq->size++;
}

void QueuePop(Queue* pq)
{
assert(pq);
assert(pq->head != NULL);

   QNode* next = pq->head->next;
   free(pq->head);
   pq->head = next;

   if (pq->head == NULL)
   {
       pq->tail = NULL;
   }
   pq->size--;
}

int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}

bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->size == 0;
}

QDataType QueueFront(Queue* pq)
{
   assert(pq);
   assert(!QueueEmpty(pq));
   return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
   assert(pq);
   assert(!QueueEmpty(pq));
   return pq->tail->data;
}

//在MyStack中放入两个队列来实现栈
typedef struct {
Queue q1;
Queue q2;
} MyStack;

MyStack* myStackCreate() {
   MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
   if (pst == NULL)
   {
       perror("malloc fail");
       return NULL;
   }
   QueueInit(&pst->q1);
   QueueInit(&pst->q2);

return pst;
}

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

int myStackPop(MyStack* obj) {
   Queue* emptyQ = &obj->q1;
   Queue* nonemptyQ = &obj->q2;
   if (!QueueEmpty(&obj->q1))
   {
       nonemptyQ = &obj->q1;
       emptyQ = &obj->q2;
   }

   while (QueueSize(nonemptyQ) > 1)
   {
       QueuePush(emptyQ, QueueFront(nonemptyQ));
       QueuePop(nonemptyQ);
   }
   QDataType top = QueueFront(nonemptyQ);
   QueuePop(nonemptyQ);
   return top;
}

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->q1);
   free(obj);
}