【数据结构】用队列实现栈 + 用栈实现队列 + 循环队列

最新推荐文章于 2024-05-31 21:10:27 发布
最新推荐文章于 2024-05-31 21:10:27 发布
阅读量569 收藏 8
点赞数 17
分类专栏： 数据结构 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_77156410/article/details/138955813
版权

一 . 用队列实现栈 

 

1.1栈的初始化创建 

malloc  使其能在函数外还能存在  初始化两个队列

MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

 1.2入栈

如果队列1非空 入队队列1 反之 入队队列2

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

1.3出栈

用假设法来实现判断哪个队列为空 

int myStackPop(MyStack* obj) {
    //假设
    Queue* Empty = &obj->q1;
    Queue* noEmpty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        Empty = &obj->q2;
        noEmpty = &obj->q1;
    }
    //不为空  前size-1个数据导到空队列去 删除最后一个就是栈顶数据
    while(QueueSize(noEmpty)>1)
    {
        QueuePush(Empty,QueueFront(noEmpty));
        QueuePop(noEmpty);
    }
    int top = QueueFront(noEmpty);
    QueuePop(noEmpty);

    return top;
}

1.4取栈顶数据加判空

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);
}

1.5销毁栈

不可以直接free(obj)  要先销毁队列1 2

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

代码如下： 

由于C语言OJ题没有接口 所有我们要自己“造轮子 ” 引入队列的接口实现。

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType val;
}QNode;

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}

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

	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);

		cur = next;
	}

	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

// 队尾插入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->next = NULL;
	newnode->val = x;

	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}

	pq->size++;
}

// 队头删除
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);
		// 一个节点
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else // 多个节点
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}

	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);

	return pq->phead->val;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);

	return pq->ptail->val;
}


int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->size == 0;
}


typedef struct {
    Queue q1;
    Queue 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) {
    //假设
    Queue* Empty = &obj->q1;
    Queue* noEmpty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        Empty = &obj->q2;
        noEmpty = &obj->q1;
    }
    //不为空  前size-1个数据导到空队列去 删除最后一个就是栈顶数据
    while(QueueSize(noEmpty)>1)
    {
        QueuePush(Empty,QueueFront(noEmpty));
        QueuePop(noEmpty);
    }
    int top = QueueFront(noEmpty);
    QueuePop(noEmpty);

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

二. 用栈实现队列 

由于栈 后进先出  的性质  我们只需要让一个栈为pushst 一个栈为popst 

 

2.1 队列的初始化创建


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&obj->pushst);
    STInit(&obj->popst);
    return obj;
}

2.2入队

void myQueuePush(MyQueue* obj, int x) {
    STPush(&(obj->pushst),x);
}

 2.3出队

int myQueuePop(MyQueue* obj) {
    int cur = myQueuePeek(obj);
    STPop(&(obj->popst));
    return cur;
}

2.4取队头数据加判空

int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&(obj->popst)))
    {
        while(!STEmpty(&(obj->pushst)))
        {
            int top = STTop(&(obj->pushst));
            STPush(&(obj->popst),top);
            STPop(&(obj->pushst));
        }
    }
    return STTop(&(obj->popst));
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&(obj->pushst)) && STEmpty(&(obj->popst));
}

2.5销毁队列

void myQueueFree(MyQueue* obj) {
    STDestroy(&(obj->pushst));
    STDestroy(&(obj->popst));
    free(obj);
}

代码如下：

由于C语言OJ题没有接口 所有我们要自己“造轮子 ” 引入栈的接口实现。

 typedef int STDataType;
 typedef struct stack
 {
    STDataType* a;
    int top;
    int capacity;
 }ST;
void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;
}
 
void STDestroy(ST* pst)
{
	assert(pst);
 
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}
 
void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}
 
void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
 
	pst->top--;
}
 
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
 
	return pst->a[pst->top - 1];
}
 
bool STEmpty(ST* pst)
{
	assert(pst);
 
	return pst->top == 0;
}
 
int STSize(ST* pst)
{
	assert(pst);
 
	return pst->top;
}

typedef struct {
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&obj->pushst);
    STInit(&obj->popst);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    STPush(&(obj->pushst),x);
}

int myQueuePop(MyQueue* obj) {
    int cur = myQueuePeek(obj);
    STPop(&(obj->popst));
    return cur;
}

int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&(obj->popst)))
    {
        while(!STEmpty(&(obj->pushst)))
        {
            int top = STTop(&(obj->pushst));
            STPush(&(obj->popst),top);
            STPop(&(obj->pushst));
        }
    }
    return STTop(&(obj->popst));
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&(obj->pushst)) && STEmpty(&(obj->popst));
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&(obj->pushst));
    STDestroy(&(obj->popst));
    free(obj);
}

 三.设计循环队列 

typedef struct {
  int front;
  int rear;
  int size;
  int *data;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
  //队列的创建（注意队列在创建时大小为k，即数组的size为k+1）
  //front指的是头指针，rear为尾指针，但该尾指针是尾指针的下一个【下一次插入的位置】
  //队列为空时，front与rear相同，队列为满时，rear与front相减的绝对值为k）
  MyCircularQueue *obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
  obj -> front = obj -> rear = 0;
  obj -> data = (int*)malloc(sizeof(int)*(k+1));
  obj -> size = k+1;
  return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
  if(obj -> front == ((obj -> rear + 1)%(obj -> size))){
  //判断队列为满
      return false;
  }
  obj -> data[obj -> rear] = value;
  obj -> rear = (obj -> rear + 1)%(obj -> size);
  return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
  if(obj -> front == obj -> rear){//判断队列为空
      return false;
  }
  obj -> front = (obj -> front + 1)%(obj -> size);
  if(obj -> front == obj -> rear){
      obj -> front = obj -> rear = 0;
  }
  return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
  if(obj -> front == obj -> rear){//判断队列为空
      return -1;
  }
  int num = obj -> data[obj -> front];
  return num;
}

int myCircularQueueRear(MyCircularQueue* obj) {
  if(obj -> front == obj -> rear){//判断队列为空
      return -1;
  }
  int num = obj -> data[(obj -> rear-1 + obj -> size)%(obj ->size)];
  return num;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
  if(obj -> front == obj -> rear){
      return true;
  }
  return false;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
  if((obj -> rear +1)%(obj -> size) == (obj -> front)%(obj -> size)){
      return true;
  }
  return false;
}

void myCircularQueueFree(MyCircularQueue* obj) {
  free(obj -> data);
  free(obj);
}

 要熟练掌握队列和栈的结构与接口实现

思如雪
关注
  • 17
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
数据结构——java栈+队列实现简单的停车场管理问题
weixin_38927257的博客
01-10 2177
文章目录源码地址：重要问题描述要求：问题分析代码实现：ParkingLotManagementSystem.class测试：车辆停在停车场离开：车辆停在便道离开： 源码地址： 源码地址：https://gitee.com/zenghua3300/Data-Structures 喜欢的小伙伴麻烦帮点一个star 重要 本文设计和代码是基于 以下博客（请点击） 数据结构——栈的java实现(一)-使...
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构与算法2：用队列实现栈 +循环队列
weixin_45984258的博客
01-14 422
这里写目录标题用队列实现栈循环队列 用队列实现栈 当要弹出元素3 时 必须先弹出元素1 并将1 添加到queueB中，再弹出元素2 将2 添加到queueB的元素1 后面queueB中的元素顺序为1，2 此时若想添加元素4 则直接在queueB中添加即可。 与用栈实现队列不同的是queueA和QueueB 交替使用（因为顺序未发生改变） import p1.接口.Stack; import java.util.Iterator; public class QueueToStack {
数据结构＜4＞栈和队列——原理+实现
qq_62745420的博客
08-31 572
队列只能用链表来实现，数组实现栈效率太低，例如：将数组0下标位置当作是队头，那么出队列的时候就要将后面的数据都向前移动时间复杂度是O（N），如果将0下标位置当作是队尾，那么每次插入数据都需要向后移动已经插入好的数据，所以数组不适合用来实现队列。循环队列是一种队列的变形，也就是将队列的首位链接起来成为一个环状的队列，循环队列的长度是一定的，一旦确定了元素个数也就确定了环的大小，这个环就不可以在改变了。队列是一种先进先出（FIFO）的结构，结构的一端是队头另一端是队尾，入数据只能在队尾，出数据在队头。.....
【数据结构】栈和队列OJ练习(栈和队列相互实现+循环队列实现)
Edward_Asia的博客
11-03 2561
前言 前面在学习了栈和队列的实现之后，相信大家对栈和队列的结构和使用方式都有了一些理解。 下面我们就来进行一些练习，这这章的练习相对于原来在难度上有了一些提升。 原来的题只需要实现一个接口，而今天的练习题需要实现多个接口。 1.用队列实现栈 225. 用队列实现栈 - 力扣（LeetCode） (leetcode-cn.com) 栈：后进先出；队列：先进先出 方法： 创建两个队列，用来来回导数据。 入栈：将数据放入不为空的队列。 出栈：将不为空的队列中的数据以出队入栈的方式.
【数据结构与算法】用队列实现栈&&用栈实现队列&&设计循环队列
joy.728的博客
10-18 1401
三道经典的OJ题：用队列实现栈、用栈实现队列和设计循环队列，点进来保证你能学会！！！
【数据结构】栈实现队列 & 队列实现栈
qq_42996461的博客
07-11 1352
🏷️力扣地址：🌈232. 用栈实现队列请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作 实现 类：示例1： 💫关键思路：1️⃣pop接口🌠动图解析：👇🏻2️⃣peek接口🌠动图解析：👇🏻3️⃣push接口🌠动图解析：👇🏻4️⃣empty接口💡代码实现： 🏷️力扣地址：🌈225. 用队列实现栈请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（、、 和 ）。实现 类：示例1 🌍解题关键：💫关键思路：那到底是如何实......
【数据结构】队列篇| 超清晰图解和详解：循环队列模拟、用栈实现队列、用队列实现栈
Yaoyao2024的博客
08-28 783
一、 模拟实现循环队列 二、用栈实现队列⭐ 三、225. 用队列实现栈
【数据结构】数据结构练习题2——栈+队列
xtcc的博客
12-18 4654
一、选择题 1.假定一个循环顺序队列的队首和队尾指针分别为f和r，则判断队空的条件是（D） A f+1==r B r+1==f C f==0 D f==r 2.假定一个链队（有头结点）的队首和队尾指针分别为front和rear，则判断队空的条件是（A） A front==rear B front!=NULL C rear!=NULL D front==NULL 3.循环队列用数组A[0，m-1]存放其元素值，已知其头尾指针分别是front和rear，则当前队列中的元素个数是 （A） A (rear-fron
C++数据结构实验_实现共享栈，链栈，循环队列，链队列
12-07
根据栈和队列的抽象数据类型的定义，按要求实现一个栈或一个队列。 要求： 1、 实现一个共享栈 2、 实现一个链栈 3、 实现一个循环队列 4、 实现一个链队列
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
详解数据结构C语言实现之循环队列
09-01
在我们生活中有很多队列的影子，可以说与时间相关的问题，一般都会涉及到队列问题；本文详细介绍了如何使用C语言实现循环队列，下面一起来看看。
数据结构与算法 ：数据结构绪论，时间和空间复杂度 推导大O阶
最新发布
2301_79840227的博客
05-31 723
算法（Algorlthm）：就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列计算步骤，用来将输入数据转化成数据结果。大家可能不理解，那么我就举个例子吧。上面例子中举例了一个数学问题，1一直加到100的值，很显然如果我们一步一步的进行计算非常的麻烦，时间效率非常高，如果用算法解释非常的简单了。i < N;++ i)j < N;k < 2 * N;int M = 10;++count;
二叉树顺序结构实现【堆的实现】【详细图解】
LiU11e的博客
05-28 999
二叉树（堆）顺序结构的实现，并带有堆排序拓展
二叉树的链式结构（二叉树）与顺序结构（堆）---数据结构
Zjxbxv11的博客
05-28 642
下面是树的示意图：注意：在树形结构中，子树之间不能有交集，否则就不是树形结构！！！例如下面的这几棵树就不是树形结构：1->结点的度：一个结点所含的子树的个数称为该结点的度； 如上图：A的有6颗子树，故A的度为6。2->叶结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I、P、Q、....等结点都为叶结点。3->非终端结点或分支结点：度不为0的结点； 如上图：A、D、E、F、G...等结点为分支结点。4->双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的
C-数据结构-树转存广义表-广义表转成树-实例
aqiangdeba的博客
05-28 246
【代码】C-数据结构-树转存广义表-广义表转成树-实例。
深入理解二叉树及其在C语言中的实现
2301_79642159的博客
05-28 458
本文介绍了二叉树的基本概念、特性以及在C语言中的实现方式。通过定义二叉树节点的结构体，我们可以轻松地实现二叉树的插入、遍历等操作。二叉树作为数据结构的重要组成部分，对于理解树形结构、递归算法等方面都有着重要意义。希望本文能够帮助读者更好地掌握二叉树的相关知识。
数据结构复习队列和栈
07-30
顺序队列使用数组来存储元素，而循环队列是一种特殊的顺序队列，可以循环利用数组空间。链队列是一种使用链表实现的队列，它具有队头指针和队尾指针。队列的常见基本操作包括初始化、判队空、求队列长度、入队和出队...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值