【数据结构】栈和队列，看完这一篇就够了（万字配动图配习题）

置顶 已于 2022-09-14 15:49:41 修改
阅读量1.6k 收藏 12
点赞数 25
分类专栏： C语言 数据结构 文章标签： 数据结构 算法 链表
于 2021-08-10 20:01:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52344401/article/details/119569271
版权

栈和队列

前言

栈和队列在数据结构中也是重要的一部分，他们都是特殊的线性表，许多需要用到我们的栈和队列，回想一下，我们以前写过的递归，其实都是可以通过我们的栈去模拟实现，而队列的使用也是十分多的，让我们一起学习学习他们的实现

一、栈

1.栈的结构

我们模拟实现栈的结构非常简单，只是在我们的线性表的基础上更改，不允许了我们的随机访问，而是得通过接口来实现数据的插入和删除，
我们的数据都是得从栈顶入栈，从栈顶出栈

注释：
压栈/进栈/入栈：栈的插入操作，入数据在栈顶
出栈： 站的删除操作，出数据也在栈顶

来看看下面这个动图加深理解吧：在这里插入图片描述
代码展示栈的结构:

typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;

解释：这上面_a数组表示我们要的是一个动态开辟的数组，_top表示我们图中所示的数组，_capacity表示我们的容量大小，当_top与_capacity相同的时候我们就可以进行扩容操作了
首先我们创建一个stack.h,stack.c,和一个用来测试接口的test_stack_queue.c文件

在这里插入图片描述
常见接口：

// 初始化栈 
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 StackDestroy(Stack* ps);

2.初始化栈

听过我之前讲的函数栈帧的同学肯定知道我要写的第一个接口是什么
–初始化，不清楚的同学点击跳转函数栈帧
看完之后你就能明白为什么要初始化？不初始化的后果？

void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}

3.压栈操作

每次只是需要将top位置更新，因为是底层实现用的数组，所以说内存不够需要扩容，我们就分开一个函数CheckCapacity（），每次检测容量是否用完，
这里的增容是可以1.5或者2倍，但是增容意味着空间开太大会造成浪费，增容太少又造成频繁增容效率低下，所以我们一般选择适中的2倍。

void CheckCapacity(Stack* ps)
{
	assert(ps);
	if (ps->_capacity == ps->_top)
	{
		int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp= (STDataType*)realloc(ps->_a,sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("增容失败\n");
			exit(-1);
		}
		ps->_a = tmp;
		ps->_capacity = newcapacity;
	}
}

void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	CheckCapacity(ps);
	ps->_a[ps->_top] = data;
	ps->_top++;
}

4.出栈操作

出栈的时候需要检测是否栈内有无元素，没有元素的话我们就报错处理 ，当然这里判断栈是否为空我们也可以封装一个函数

栈是否为空

int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top ==0;//0为空
}

void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->_top--;
}

5.获取栈顶元素

也是要判断一下是否在栈内有无元素

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->_a[ps->_top-1];
}

6.获取栈中有效元素个数

_top的位置就是元素的总数

在这里插入图片描述

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}

7.销毁栈

销毁栈的过程，销毁栈是重要的过程，我们的_a数组是动态开辟的，没有释放会造成内存泄漏
当然，注意看这里的ps指针是不能置空的，在之前的详解指针这一节的常见错误中有提及！

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	//free(ps); 错误
	ps->_capacity = ps->_top = 0;
}

二、队列

1.队列的结构

队列的结构会比栈的难懂一些，因为队列的属性就是先入先出，所以采用顺序表的话我们的头删就要去移动数据覆盖第一个位置，或者用一个指针记录头的位置，头删的时候用移动头节点来表示，但是这都不如链表来的方便，链表在我们的头部删除是O（1）的时间复杂度，并且不用删除队尾元素，所以我们这里使用我们的单链表结构来实现队列！
链表的初阶
链表的进阶

// 链式结构：表示队列 
typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;//队列中结点的结构

// 队列的结构 
typedef struct Queue
{
	QNode* _front;//头指针
	QNode* _rear;//尾指针
}Queue;

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头

动图：在这里插入图片描述

我们先封装队列中的一个结点，结点中有指向下一个元素的指针，和自身的值，然后因为我们的队列是用单链表实现的，而队列有一个获取队尾元素的接口，所以我们设置尾指针_rear能够是我们不用每次遍历找到尾在进行插入

2.队列的初始化

void QueueInit(Queue* q)
{
	assert(q);
	q->_front = NULL;
	q->_rear = NULL;
}

3.队列的插入

队列的插入就和单链表的头插一模一样，就是记得判断一开始我们的队头和队尾都是NULL，后续只需要移动_rear(队尾指针)！！！

动图：在这里插入图片描述

void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	tmp->_next = NULL;
	tmp->_data = data;

	if (q->_rear == NULL)
	{
		q->_front = q->_rear = tmp;
	}
	else
	{
		q->_rear->_next = tmp;
		q->_rear = tmp;
	}
}

4.队列的删除

动图:(当删除最后一个结点时易忽略处理_front 指针)

在这里插入图片描述

尾删需要注意是否队列中存在元素！！这里

的逻辑比较简单，但要注意当队列元素只剩一个的时候我们的队尾指针也要置成NULL，不然就会造成野指针

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	QNode* first = q->_front->_next;
	if (first == NULL)
		q->_rear = NULL;//处理这一步
	free(q->_front);
	q->_front = first;
}

5.获取队列头/尾部元素

这个就很简单啦!!

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

6.获取队列中有效元素个数

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

7.检测队列是否为空

如果为空返回非零结果，如果非空返回0

int QueueEmpty(Queue* q)
{
	assert(q);
	return q->_front == NULL;
}

8.销毁队列

这里要遍历队列,因为每一个结点都是我们从堆上开辟的,我们就要一个个的释放

void QueueDestroy(Queue* q)
{
	assert(q);
	while (!QueueEmpty(q))
	{
		QNode* tmp = q->_front->_next;//保存下一个结点
		free(q->_front);
		q->_front = tmp;
	}
	q->_front = q->_rear = NULL;
}

从上面的图我们就能看出来，出栈的时候我们只能从栈顶出，出来的结果刚好与入的值相反，其实同一组数据入栈在出栈顺序不同的时候是有不同的结果的，

三、循环队列

解释:
循环队列的使用场景:当我们在去打疫苗的时候排队,注射疫苗的位置有限,我们前面排队的先打,后面的后进去的后打.
循环队列就是固定了队列的大小空间

设计循环队列
题目分析:这道题目是让我们设计一个循环队列,先说结论我们这里的循环队列所用的是循序表实现,因为我们在这个场景下不需要扩容,顺序表随机访问率高.其次如果使用单链表,在进行删除头部元素的时候我们需要找到上一个指针,为了效率就得有双向链表,但有简单又高效的结构我们优先去使用顺序表.
在这里插入图片描述

循环链表的结构

typedef struct {
int *a;//指向我们的数组
int front;//队头
int rear;//队尾,指向的位置是我们存放的位置
int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj =(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a =(int*)malloc(sizeof(int)*(k+1));
    obj->front =obj->rear=0;
    obj->k = k;
    return obj;
}

循环链表的实现

题目看起来并不难,但有一个点确实需要琢磨,我们用顺序表的时候,一开始我们的队头元素的指针和队首元素的指针是指向同一处的,这个时候我们是认为他是题目看起来并不难,但有一个点确实需要琢磨,我们用顺序表的时候,一开始我们的队头元素的指针和队首元素的指针是指向同一处的,
这个时候是整个数组我们都已经放满了呢还是一个元素都没放入,这就会出现分歧
在这里插入图片描述

解决方案:
方案1.

聪明的同学可能一下子就想着说我们可能可以开一个标记矩阵,放过元素的我们标记一下,删除的时候我们把他的状态也标记一下,这个方案毫无疑问是可行的,但是空间开的就比较多了,下面有一种更好的

方案2.

我们在原来的基础上多开一个数组,当我们的队头指针与队尾指针相遇时是我们的数组还没元素,当_rear的下一个元素是我们的_front时才是我们整个数组放满了,下图为放满的情况

在这里插入图片描述

然后这题要对下标进行判断,下标若走到-1,则更新成k,若走到k+1则更新成0

typedef struct {
int *a;//指向我们的数组
int front;//队头
int rear;//队尾,指向的位置是我们存放的位置
int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj =(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a =(int*)malloc(sizeof(int)*(k+1));
    obj->front =obj->rear=0;
    obj->k = k;
    return obj;
}

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

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(obj->front == obj->rear)//删除元素front指针往前走
return false;
obj->front++;
if(obj->front == obj->k+1)
obj->front =0;
return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
if(obj->front == obj->rear)
return -1;

return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
if(obj->front ==obj->rear)
return -1;
int x = obj->rear -1;
if(x ==-1)
x= obj->k;
return obj->a[x];
}

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

bool myCircularQueueIsFull(MyCircularQueue* obj) {
return ((obj->rear+1)%(obj->k+1)) ==obj->front;
}

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

四、一些习题

1.有效的括号

链接:有效的括号

这题要用到我们的栈,对于C语言的学习者,我们并没有库,大家可以用下面我在码云发布的栈的代码来写
思路:我们遇到左括号的时候就入栈,遇到右括号的时候就拿栈顶数据比较,只要不符合就返回false,若字符遍历完且栈里的数据都出完了,则括号都能一一匹配

class Solution {
public:
    bool isValid(string s) {
//只要是左括号我们就入栈，遇到右括号我们就从栈顶pop一个数据看与他是否匹配
        stack<char> st;
        int len =s.size();
        for(int i =0;i<len;i++)
        {
            char ch =s[i]; 
            if(ch =='('||ch =='{'||ch=='[')
            {
                st.push(ch);
            }
            else
            {
                if(st.empty())
                {
                    return false;
                }          
                else 
                {
                    char ch2 = st.top();
                    st.pop();
                    if((ch ==')'&&ch2 !='(')
                    || (ch =='}'&&ch2 !='{')
                    || (ch ==']'&&ch2!='['))
                    
                    return false;
                }
            }
        }
        if(st.empty())
        return true;

        return false;
    }
};

2. 用队列实现栈

看到前面的不要慌,只是队列的实现而已,我们为了练习队列可以就用我们实现的队列
思路:用两个队列分别为q1,q2,每次push数据往其中为有数据的入,都没有就随便选一个入,pop数据的时候就将有数据的导入到没数据的,在判断是否为最后一个,是的话我们就pop掉且不用入有空的队列了

myStackPush数据的时候只用往nonempty(不为空)的队列入,动图:在这里插入图片描述
myStackPop都要导到另一个为空的队列在pop掉最后一个数据,动图:在这里插入图片描述

typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;//队列中结点的结构

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
}Queue,queue;

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);
void QueueInit(Queue* q)
{
	assert(q);
	q->_front = NULL;
	q->_rear = NULL;
}
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	tmp->_next = NULL;
	tmp->_data = data;

	if (q->_rear == NULL)
	{
		q->_front = q->_rear = tmp;
	}
	else
	{
		q->_rear->_next = tmp;
		q->_rear = tmp;
	}
}
void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	QNode* first = q->_front->_next;
	if (first == NULL)
		q->_rear = NULL;//处理这一步
	free(q->_front);
	q->_front = first;
}
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;
}
int QueueSize(Queue* q)
{
	assert(q);
	int n = 0;
	QNode* cur = q->_front;
	while (cur)
	{
		n++;
		cur = cur->_next;
	}
	return n;
}
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->_front == NULL;
}
void QueueDestroy(Queue* q)
{
	assert(q);
	while (!QueueEmpty(q))
	{
		QNode* tmp = q->_front->_next;
		free(q->_front);
		q->_front = tmp;
	}
	q->_front = q->_rear = NULL;
}


typedef struct {
queue q1;
queue q2;
} MyStack;

/** Initialize your data structure here. */

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

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
    MyStack* empty = &obj->q1;
    MyStack* nonempty =&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty =&obj->q2;
        nonempty =&obj->q1;
    }
    QueuePush(nonempty,x);
}

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
    MyStack* empty = &obj->q1;
    MyStack* nonempty =&obj->q2;
    if(!QueueEmpty(&obj->q1))//这段逻辑大家可以思考一下
    {
        empty =&obj->q2;
        nonempty =&obj->q1;
    }
    int x;
    while(!QueueEmpty(nonempty))
    {
        x =QueueFront(nonempty);
        QueuePop(nonempty);
        if(!QueueEmpty(nonempty))
        QueuePush(empty,x);
    }
    return x;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
    MyStack* empty = &obj->q1;
    MyStack* nonempty =&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty =&obj->q2;
        nonempty =&obj->q1;
    }
    return QueueBack(nonempty);
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

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

3.用栈实现队列

链接:用栈实现队列

这道题之前的类似
我们用两个栈解决问题,一个为pushst,用来存放数据,popst用来出数据

StackPush数据我们可以一直往我们的pushst入,当我们要出的时候popst没有数据则导入数据,有就直接出,并且注意我们导数据到popst的时候正常的pop数据就可以保证他是按照队列先进先出的顺序了,一些小细节在代码有注释
动图展示:

从入栈123变换popst出栈时也123的顺序

在这里插入图片描述

typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}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 StackDestroy(Stack* ps);
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}
void CheckCapacity(Stack* ps)
{
	assert(ps);
	if (ps->_capacity == ps->_top)
	{
		int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp= (STDataType*)realloc(ps->_a,sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("增容失败\n");
			exit(-1);
		}
		ps->_a = tmp;
		ps->_capacity = newcapacity;
	}
}
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	CheckCapacity(ps);
	ps->_a[ps->_top] = data;
	ps->_top++;
}
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->_top--;
}
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->_a[ps->_top-1];
}
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top ==0;//0为空
}
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	//free(ps); 错误
	ps->_capacity = ps->_top = 0;
}
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}


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

/** Initialize your data structure here. */

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

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
StackPush(&obj->pushst,x);
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
if(!StackEmpty(&obj->popst))
{
    return StackTop(&obj->popst);
}
//如果是popst为空就入，不然就直接出
while(!StackEmpty(&obj->pushst))
{
    int x =StackTop(&obj->pushst);
    StackPop(&obj->pushst);
    StackPush(&obj->popst,x);
}
    return StackTop(&obj->popst);
}

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
int tmp =myQueuePeek(obj);
StackPop(&obj->popst);
return tmp;
}



/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
return StackEmpty(&obj->pushst)&&StackEmpty(&obj->popst);
}

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

附上栈和队列的代码

码云: <代码链接>
三道习题若大家没有动手实现可以用这里的!!

总结

本篇文章讲述了栈和队列,其中链表实现还有问题一定要去看看我之前写的两篇链表文章,这篇文章的细节有很多,但弄懂之后其实都还好,对于文章有任何问题的都欢迎私信我.
看到这里不妨一键三连!!!一键三连!!!一键三连!!!

上集回顾:
链表的初阶
链表的进阶

^jhao^
关注
  • 25
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 18
    评论
专栏目录
【数据结构和算法】动图+万字，详解栈和队列（实例讲解）
Linux猿
09-26 7752
???? 作者：Linux猿 ???? 简介：CSDN博客专家????，华为云享专家????，C/C++、面试、刷题、算法尽管咨询我，关注我，有问题私聊！ ???? 关注专栏：C/C++面试通关集锦（优质好文持续更新中……）???? ???? 欢迎小伙伴们点赞????、收藏⭐、留言???? 目录 一、栈 1.1 什么是栈 1.2 实现方式 1.3 数组实现栈 1.3.0 类封装 1.3.1 push 操作 1.3.2 pop 操作 1.3.3 empty 操作 1.3.4 top
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时刻，对每一组输入数据进行操作后的输出数据为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车离去；则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。栈以顺序结构实现，队列以链表实现。 需另设一个栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车，也用顺序存储结构实现。输入数据按到达或离去的时刻有序。栈中每个元素表示一辆汽车，包含两个数据项：汽车的牌照号码和进入停车场的时刻。
数据结构之栈的讲解（源代码+图解+习题）
最新发布
2302_76941579的博客
10-25 634
/用顺序表模拟栈int top;}ST;
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
数据结构和算法-Flash动画演示
02-03
该资源使用flash动画来演示相关算法的运算过程，内容包括查找、排序、链表、栈与队列，树、图等等。演示时，可以输入数字，如果别的播放器不好使，可以使用qq播放器。
LeetCode栈和队列经典例题
m0_70811813的博客
01-09 666
这里有四道关于栈和队列的经典题型
问题 A: 算法3-7：银行排队
weixin_51988154的博客
07-02 1502
时间限制:1 Sec内存限制:32 MB 提交:751解决:509 题目描述 我们大多都有在银行排队的经历，唉，那坑爹的排队啊！现在就让我们来算算我们这些客户平均需要等多久吧。 每天刚开始时银行会开m个窗口来为我们total个客户办理业务，当有客户需要办理业务时，先选择可以办理业务的窗口，如果有多个窗口可以办理业务就选择空闲时间最长的窗口，如果有多个窗口空闲的时间一样长，则选择序号小的窗口办理业务。假设我们每个人来到的时间和办理业务所需要的时间（为了简化问题，采用整数表示时间）都知道...
【数据结构与算法-栈、队列、堆经典例题汇总】
是小武呀
03-03 1355
【数据结构与算法-栈、队列、堆经典例题汇总】典例1、使用队列实现栈（easy）典例2、使用栈实现队列（easy）典例3、包含min函数的栈（easy）典例4、合法的出栈顺序（medium）典例5、简单的计算器（hard）典例6、数组中第K大的数（medium）典例7、寻找中位数（hard） 典例1、使用队列实现栈（easy） 题目描述： 预备知识 栈：先进后出 基本操作： 队列：先进先出 思路：在元素入栈时候，利用临时队列调换元素的顺序 。 使得 存入队列的元素顺序与栈的顺序
栈和队列——相关例题
每天进步一点点！
11-26 1407
栈和队列例题
栈与队列经典题目
m0_49687898的博客
04-22 123
1. 括号匹配问题 2. 采用队列实现栈 3. 栈实现队列 4. 设计循环队列
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
数据结构栈和队列练习题答案.doc
04-02
数据结构
队列结构及其算法动画演示系统
05-17
队列结构及其算法动画演示系统里面包括队列的简介，顺序存储结构以及链式存储结构，算法描述， 算法源代码， 演示系统，可以独立运行。
数据结构作业：第三章-栈和队列题目.docx
12-17
数据结构作业：第三章-栈和队列题目.docx
循环队列的基本操作和实现
11-22
循环队列的基本操作和实现循环队列的基本操作和实现
《数据结构》-第三章 栈和队列（习题）
热门推荐
大家一起进步叭
07-27 1万+
第三章 栈和队列 栈与队列作为操作受限的线性表，在考试中常以选择题、填空题出现，也会有部分算法题目涉及对栈或队列的知识（如求解阶乘n！、括号匹配等场景）。栈部分相对常考内容为进栈、出栈操作、栈空栈满判断共享栈两端进出栈的操作（考研）；对于队列常以真假溢出判断、循环队列队空（队满）判断方向进行出题。 一、选择题（第1-10题为基础难度，第11-20题难度适合考研） 1.若进栈序列为a,b,c，则通过入出栈操作可能得到的a,b,c的不同排列个数为 A) 4 B) 5...
【数据结构】——栈、队列及串的相关习题
小宇y的博客
08-09 2172
入队操作针对Q.rear，入队的代码通过取余运算实现，队尾指针加1，即Q.rear=(Q.rear+1)%MaxSize，不管前面(Q.rear+1)为多少，它与MaxSize（例如，MaxSize=5）取余的结果只可能是0、1、2、3、4，也就是队尾指针Q.rear的每次移动加1。1、设栈S和队列Q的初始状态为空，元素a，b，c，d，e，f依次通过栈S，一个元素出栈后即进队列Q，若6个元素出队的序列是a，c，f，e，d，b，则栈S的容量至少应该是（）。b、c通过栈S后，c首先出栈通过队列，得到出队为。
[算法总结] 6 道题搞定 BAT 面试——堆栈和队列
尾尾部落
09-04 547
本文首发于我的个人博客：尾尾部落 0. 基础概念 栈：后进先出（LIFO） 队列：先进先出（FIFO） 1. 栈的 java 实现 import java.util.Arrays; public class Stack { private int size = 0; //栈顶位置 private int[] array; public...
【数据结构】栈与队列经典oj题
睿的博客
04-08 849
学会了栈与队列相关知识，快来刷题提升自己吧！
数据结构栈和队列课后习题头歌
10-18
根据提供的引用内容，我可以为您解答数据结构栈和队列课后习题的相关问题。 根据引用中的内容，我们可以知道栈和队列都是线性结构，栈是一种特殊的线性表，允许插入和删除运算的一端称为栈顶，不允许插入和删除运算的一端称为栈底。而队列是被限定为只能在表的一端进行插入运算，在表的另一端进行删除运算的线性表。 对于栈的操作，进栈操作是将元素压入栈顶，出栈操作是将栈顶元素弹出。根据引用中的内容，进行栈操作时，按a1、a2、a3、a4次序每次进入一个元素。现要进行的栈操作是进栈两次，出栈一次，再进栈两次，出栈一次；这时，第一次出栈得到的元素是a4，第二次出栈得到的元素是a3。 对于队列的操作，进队操作是将元素插入队尾，出队操作是将队首元素删除。根据引用中的内容，进行队列操作时，按a1、a2、a3、a4次序每次进入一个元素。现要进行的队列操作是进队两次，出队一次，再进队两次，出队一次；这时，第一次出队得到的元素是a1，第二次出队得到的元素是a2。 经过以上操作后，栈中或队列中最后剩余的元素是a4和3个元素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

^jhao^

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值