栈与队列刷题(循环队列，队列实现栈，栈实现队列)

最新推荐文章于 2023-03-21 09:00:00 发布
最新推荐文章于 2023-03-21 09:00:00 发布
阅读量220 收藏
点赞数 3
分类专栏： 数据结构入门 文章标签： c++ 算法 数据结构 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pythoniiiiii/article/details/127174025
版权

在了解了栈和队列的概念与源代码以后，我们可以做几道题练练手
栈
队列

在这里插入图片描述

栈与队列刷题

1.用栈实现队列

我们都知道，栈是后进先出，队列是先进先出，那么怎么用栈来实现队列呢？
在这里插入图片描述
这是一个栈，栈顶元素是5，栈底元素是1，如果出栈肯定是5先出去了，我们想让1先出去，那就可以借助两个栈，我们先把12345按照54321的顺序出栈，出栈的元素不是没了，而是进入到了另一个栈中：
在这里插入图片描述

那么按照队列的性质先进先出，1就可以出去了，正好也符合pop栈中后进先出的性质。
所以我们可以使用两个栈来实现一个队列（一个出栈，一个入栈），当用来出队的栈没有元素时，就把入队的栈里的元素放到出栈中，根据栈的性质，会反过来，就达到了我们的目的。
代码：

typedef int STDataType;
typedef struct Stack
{
	STDataType* array;
	int capacity;		
	int size;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps); 
// 入栈 
void StackPush(Stack* ps, STDataType data); 
// 出栈 
void StackPop(Stack* ps); 
// 获取栈顶元素 
STDataType StackTop(Stack* ps); 
// 获取栈中有效元素个数 
int StackSize(Stack* ps); 
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps); 
// 销毁栈 
void StackDestory(Stack* ps); 
#define DEFSTACKSIZE 100
 
void CheckCapacity(Stack* ps)
{
	if (ps->size >= ps->capacity)
	{
		ps->capacity *= 2;
		ps->array = (STDataType *)realloc(ps->array, ps->capacity * sizeof(STDataType));
	}
}
 
void StackInit(Stack* ps)
{
	ps->array = (STDataType *)calloc(DEFSTACKSIZE, sizeof(STDataType));
	ps->capacity = DEFSTACKSIZE;
	ps->size = 0;
}
 
void StackPush(Stack* ps, STDataType x)
{
	CheckCapacity(ps);
 
	ps->array[ps->size] = x;
	ps->size++;
}
 
void StackPop(Stack* ps)
{
	if (ps->size == 0)
	{
		return;
	}
	ps->size--;
}
 
STDataType StackTop(Stack* ps)
{
	if (ps->size == 0)
	{
		return (STDataType)0;
	}
	return ps->array[ps->size - 1];
}
 
int StackEmpty(Stack* ps)
{
	return ps->size == 0;
}
 
int StackSize(Stack* ps)
{
	return ps->size;
}
 
void StackDestory(Stack* ps)
{
	if (ps->array)
	{ 
		free(ps->array);
		ps->array = NULL;
		ps->size = 0;
		ps->capacity = 0;
	}
}
//以上为栈
typedef struct 
{
    Stack pushST;
    Stack popST;
} MyQueue;


MyQueue* myQueueCreate() 
{
    MyQueue* nQueue = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&nQueue->pushST);
    StackInit(&nQueue->popST);
    return nQueue;
}

void myQueuePush(MyQueue* obj, int x) 
{
    StackPush(&obj->pushST,x);

}

int myQueuePop(MyQueue* obj) {
        if(StackEmpty(&obj->popST)!=0)
        {
            while(StackEmpty(&obj->pushST)==0)
            {
                StackPush(&obj->popST,StackTop(&obj->pushST));
                StackPop(&obj->pushST);
            }
        }
        int f = StackTop(&obj->popST);
        StackPop(&obj->popST);
        return f;
}

int myQueuePeek(MyQueue* obj) 
{
   if(StackEmpty(&obj->popST)!=0)
        {
            while(StackEmpty(&obj->pushST)==0)
            {
                StackPush(&obj->popST,StackTop(&obj->pushST));
                StackPop(&obj->pushST);
            }
        }
        return StackTop(&obj->popST);
}

bool myQueueEmpty(MyQueue* obj) 
{
    return StackEmpty(&obj->pushST)&&StackEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj) {
        StackDestory(&obj->popST);
        StackDestory(&obj->pushST);
        free(obj);
        
}

别看有点多，其实是前面有栈的实现，所以占了几十行。

2.用队列实现栈

用队列实现栈也是差不多的思路，用两个队列实现一个栈。
在这里插入图片描述

怎么让5先出去呢？队列是先入先出的，你转移到另一个队列也还是1 2 3 4 5的顺序，那么这回我们就让队列中只剩五，再出队列，不就可以先让5出去了？
在这里插入图片描述
然后再让1出栈，实现了出栈顶。
在这里插入图片描述
注意，一定要保证一个空的队列用于储存其他的元素。
代码：

typedef int QDataType;
typedef struct QlistNode
{
    struct QlistNode* _next;
    QDataType _data;
}QNode;

typedef struct Queue
{
    QNode* _front;//队列头
    QNode* _rear;//队列尾
}Queue;
QNode* BuyQueueNode(QDataType x)
{
    QNode* cur = (QNode*)malloc(sizeof(QNode));
    cur->_data = x;
    cur->_next = NULL;
    return cur;
}
void QueueInit(Queue* q)
{
    q->_front = NULL;
    q->_rear = NULL;
}
void QueuePush(Queue* q, QDataType data)
{
    QNode* cur = BuyQueueNode(data);
    if (q->_front == NULL)
    {
        q->_front = q->_rear = cur;
    }
    else//有节点就在队列最后尾插，让rear后移一位 
    {
        q->_rear->_next = cur;
        q->_rear = cur;
    }
}
void QueuePop(Queue* q)
{
    assert(q);//出队列就相当于链表的头删一样
    if (q->_front == NULL)
        return;
    QNode* cur = q->_front->_next;
    free(q->_front);
    q->_front = cur;
}

int QueueEmpty(Queue* q)
{
    if (q->_front == NULL)
        return 1;
    else return 0;
}

void QueueDestroy(Queue* q)
{
    if (q->_front == NULL)
        return;
    while (q->_front)
    {
        QueuePop(q);
    }
}

int QueueSize(Queue* q)
{
    assert(q);
    QNode* cur = q->_front;
    int count = 0;
    while (cur)
    {
        count++;
        cur = cur->_next;
    }
    return count;

}
QDataType QueueFront(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));
    return q->_front->_data;

}

QDataType QueueBack(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));
    return q->_rear->_data;
}
//上方为队列（C语言无队列封装）
//
//
//
//
typedef struct {
    Queue q1;//用两个队列实现栈
    Queue q2;
}MyStack;


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

    return pst;
}

void myStackPush(MyStack* obj, int x)
{
    //给非空队列入队
    if (QueueEmpty(&obj->q1) == 1 && QueueEmpty(&obj->q2) == 1)//如果队列确实是空的就入队
    {
        QueuePush(&obj->q1, x);
    }
    else if (QueueEmpty(&obj->q2) != 1)
    {
        QueuePush(&obj->q2, x);
    }
    else
    {
        QueuePush(&obj->q1, x);
    }
}

int myStackPop(MyStack* obj)
{
    //把非空队列的除最后一个元素之前的元素全都移动到另一个队列
    Queue* pEmpty = &obj->q1, * pNonEmpty = &obj->q2;
    if (QueueEmpty(&obj->q1) != 1)
    {
        pEmpty = &obj->q2;
        pNonEmpty = &obj->q1;//判断空队列
    }
    while (QueueSize(pNonEmpty) > 1)
    {
        QueuePush(pEmpty, QueueFront(pNonEmpty));
        QueuePop(pNonEmpty);//把非空队列其余元素移动到空队列
    }
    int top = QueueFront(pNonEmpty);
    QueuePop(pNonEmpty);
    return top;
}

int myStackTop(MyStack* obj) {
    //栈顶就是非空队列的队尾
    if (QueueEmpty(&obj->q1) != 1)
    {
        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);
}

3.循环队列

在这里插入图片描述
假如一个队列有40字节，那么我们储存10个数据就顶天了，这时候我们出队一个，还是不能入队了，因为队列已经满了，即使是没用的元素塞满了，你也不能再进去了。
我们采用数组的方式来实现这个循环队列:
在这里插入图片描述
这时候要是一般的队列，你就不能往下存了，可是我们是循环队列，我们要再存数据，就把tail往前移动就可以了。
在这里插入图片描述
继续存，什么时候存满呢？
在这里插入图片描述
当tail == head的时候就存满了，但是这和队列为空的条件冲突了，因此，我们要区分空和满，可以给他增加一个空间
在这里插入图片描述
这样，tail和head就会始终保持1距离，只有为空的时候才相等，满的时候，tail+1 == head。
具体还有一些细节需要说，直接先上代码：
代码：

typedef struct 
{
    int *a;
    int front;
    int tail;
    int k;
} MyCircularQueue;
bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue * nq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    nq->a = malloc(sizeof(int)*(k+1));
    nq-> tail = 0;
    nq-> front = 0;
    nq-> k  = k;
    return nq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    //插入一个元素
    if(myCircularQueueIsFull(obj))
    {
        return false;   
    }
    else
    {
        obj->a[obj->tail] = value;
        obj->tail++;
        obj->tail %= (obj->k+1);
        return true;
    }
  
  
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
        if(myCircularQueueIsEmpty(obj))
        return false;
        else
        {
            ++obj->front;
            obj->front %= (obj->k+1);
            return true;
        }
}

int myCircularQueueFront(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    return -1;
        return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    return -1;
    /*if(obj->tail==0)
    return obj->a[k];
    else
    return obj->a[obj->tail-1];
    */
    int i = (obj->tail+obj->k)%(obj->k+1);
    return obj->a[i];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
        return obj->front == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
        return obj->front == (obj->tail+1)%(obj->k+1);//为了防止tail转一圈回到前面，和front不一样
}

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

k就是容量，我们每次插入让tail指针加1的同时还会让他 obj->tail %= (obj->k+1);这是为了防止特殊情况，假如tail到了数组的0位置，他的值不一定是0，可能是0+n*（k+1），所以我们采用取模的方法，让tail下标的范围一直在
数组的范围当中。同理，front指针也进行相应的操作

小结

这三道习题是帮助大家加深理解，有多种实现方法，尤其是循环队列（链表实现），建议大家敲一敲，锻炼一下。

struggle2003
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
如何使用JavaScript实现栈与队列
12-11
使用队列处理数据，实现web浏览器的事件循环处理事件(单击click、悬停hoover等)。 等等，先想象一下我们作为用户和程序员，每天使用栈和队列的次数，这太惊人了吧！由于它们在设计上有普遍性和相似性，我决定从这里...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
【数据结构与算法】用队列实现栈
Welcome home | Jian Liao 's blog
03-21 1756
😼前面我们相继实现了栈和队列，是不是愁没有练手的地方呢？别担心，本章带大家用队列来实现一个栈！😽我们都知道，栈和队列可以看作为兄弟，一个后进先出(LIFO)，一个先进先出(FIFO)，他们虽有不同的性质，但总的来说还是不分家的，因为，我们既可以用队列实现栈，也可以用栈实现队列，而本章就先来带大家来了解如何使用队列来实现栈。💝学会了用队列实现栈，那么下一篇文章就是教大家如何用栈实现队列了。栈和队列还真是有趣呢！❤️‍🔥后续将会持续输出有关数据结构的文章，你们的支持就是我写作的最大动力！
ADT栈与队列的C语言编程与实现
timerring的博客
07-10 5万+
一 、目的：加深对抽象数据类型 ADT 栈和队列的理解；二 、环境：operating system version：Win11CPU instruction set: x64Integrated Development Environment：Viusal Studio 2022三 、内容：编写程序实现ADT栈的定义，及常用操作（数组或指针实现1) 生成栈2) Push3) Pop编写程序实现ADT队列的定义，及常用操作：1) 生成队列2) Enqueues 入列3) Isempty 判断是否队列为空
十分钟手撕栈与队列——栈与队列实现详解
qq_61500888的博客
03-27 2619
十分钟带你一命通关栈与队列 既然选择远方，只顾风雨兼程！
用栈实现队列和用队列实现栈
SmileTimLi的博客
02-23 1762
第一 队列和栈的了解 栈 -- 先进后出(FILO—First-In/Last-Out) 队列 -- 先进先出(FIFO—first in first out) 对应的方法 栈 入栈：s.push(x) 出栈：s.pop() 访问栈顶：s.top() 判断栈空：s.empty() 访问栈中的元素个数：s.size() 队列  入队：q.push(x) 出队：q.pop(...
栈与队列刷题 （5/12更新 选择&判断）
hhx7777777777777的博客
05-12 3474
系列文章目录 考研刷题向（选择，判断，应用，算法） 《算法与数据结构考研试题精选》 ——陈守孔 胡潇琨 李玲 冯广惠 编著 前言 内容提要： 1.从数据结构角度讲，栈和队列属于线性结构，其操作是线性表操作的子集，是操作受荣的线性表。但从数据类型的角度看，它们是和线性表大不相同的重要抽象数据类型。 2。栈的定义及操作。栈是只准在端进 行插人和删除操作的线性表， 该端称为栈的顶端。 3.栈的顺序和链式存储结构，以及在这两种结构下实现栈的操作。 4.栈的应用:表达式求值，过程调用，递归过程，消除递归。 5.队列的
栈实现队列(队列实现栈)
weixin_55742319的博客
01-14 3002
数据结构与算法应用(栈与队列互相实现)
用两个栈实现队列（Java实现）
卜大爷的博客
11-14 2万+
用两个栈实现队列 题目 剑指 Offer 09. 用两个栈实现队列 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 ) 分析 想要用栈实现队列。我们先来回忆一下栈和队列的区别： 栈的特点是先进后出。 队列的特点是先进先出。 怎么能让先进后出的队列，来管理先进先出的数据呢？ 答案是再增加一个队列，先进后出2次，数据就变为了先
两个栈实现一个队列
ailunlee的博客
12-19 5万+
用栈实现队列 1、栈的特点 栈的特点是先进后出，进出元素都是在同一端（栈顶）。 入栈： 出栈： 2、队列的特点 队列的特点是先进先出，出入元素是在不同的两端（队头和队尾）。 入队： 出队： 3、两个栈实现队列 我们拥有两个栈，可以让其中一个栈作为队列的入口，负责插入新元素；另一个栈作为队列的出口，负责移除老的元素。 队列的主要操作无非有两个：入队和出队。在...
如何使用两个栈实现队列Java
08-25
主要介绍了如何使用两个栈实现队列Java,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Python实现栈和队列的简单操作方法示例
09-18
主要介绍了Python实现栈和队列的简单操作方法,结合实例形式详细分析了Python栈和队列的原理与简单实现技巧,需要的朋友可以参考下
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
JavaScript基于数组实现的栈与队列操作示例
11-27
本文实例讲述了JavaScript基于数组实现的栈与队列操作。分享给大家供大家参考，具体如下： 栈数据结构： 1、 后进先出 队列在列表的尾端添加项，从列表的尾端移除项 队列图： 实现代码： var colors = ["red",...
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、...
Java编程用两个栈实现队列代码分享
08-29
主要介绍了Java编程用两个栈实现队列代码分享，具有一定参考价值，这里给大家分享下，供需要的朋友了解。
JavaScript栈和队列相关操作与实现方法详解
10-17
主要介绍了JavaScript栈和队列相关操作与实现方法,结合实例形式较为详细的分析了javascript栈和队列的概念、原理、定义、用法及相关操作注意事项,需要的朋友可以参考下
Python 实现数据结构中的的栈队列
09-19
主要介绍了Python 实现数据结构中的的栈，队列,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
数据结构栈与队列代码c语言实现
最新发布
05-19
栈的C语言实现： ```c #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 typedef struct { int data[MAXSIZE]; int top; } Stack; void init(Stack *s) { // 初始化栈 s->top = -1; } int push(Stack *s, int x) { // 入栈操作 if (s->top == MAXSIZE - 1) { printf("Stack overflow.\n"); return 0; } s->data[++(s->top)] = x; return 1; } int pop(Stack *s) { // 出栈操作 if (s->top == -1) { printf("Stack underflow.\n"); return 0; } return s->data[(s->top)--]; } int top(Stack *s) { // 返回栈顶元素 if (s->top == -1) { printf("Stack underflow.\n"); return 0; } return s->data[s->top]; } int empty(Stack *s) { // 判断栈是否为空 return s->top == -1; } ``` 队列的C语言实现： ```c #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 typedef struct { int data[MAXSIZE]; int front, rear; } Queue; void init(Queue *q) { // 初始化队列 q->front = q->rear = 0; } int enqueue(Queue *q, int x) { // 入队操作 if ((q->rear + 1) % MAXSIZE == q->front) { printf("Queue overflow.\n"); return 0; } q->data[q->rear] = x; q->rear = (q->rear + 1) % MAXSIZE; return 1; } int dequeue(Queue *q) { // 出队操作 if (q->front == q->rear) { printf("Queue underflow.\n"); return 0; } int x = q->data[q->front]; q->front = (q->front + 1) % MAXSIZE; return x; } int empty(Queue *q) { // 判断队列是否为空 return q->front == q->rear; } ``` 以上是基本的栈和队列的实现，可以根据需要进行修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值