【数据结构】栈和队列（实现源码）以及高频面试OJ题详解

已于 2022-03-06 16:27:09 修改
阅读量182 收藏 1
点赞数 3
分类专栏： 数据结构 C语言 文章标签： 数据结构 c语言 栈 队列 c++
于 2021-12-14 17:17:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57018588/article/details/121911961
版权

目录


秃头侠们好呀，今天来聊聊 栈和队列

本章重点

1、栈
2、队列
3、栈和队列的一些高频面试题

栈

栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。
在这里插入图片描述

栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。但是你想如果你用链表实现，你还得先找尾。
在这里插入图片描述
实现：

Stack.h

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

typedef int STDataType;
typedef struct stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

void StackInit(ST* ps);

void StackDestroy(ST* ps);

void StackPush(ST* ps, STDataType x);

void StackPop(ST* ps);

bool StackEmpty(ST* ps);

STDataType StackTop(ST* ps);

int StackSize(ST* ps);

Stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

队列

队列的概念及结构

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

队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。你想想，如果从队头删除数据，需要将整个数组向前移动，效率很低，而链表直接头删很方便。

实现：

Queue.h

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int QDataType;

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

typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

void  QueueInit(Queue* pq);

void  QueueDestroy(Queue* pq);

void  QueuePush(Queue* pq,QDataType x);

void  QueuePop(Queue* pq);

QDataType  QueueFront(Queue* pq);

QDataType  QueueBack(Queue* pq);

int QueueSize(Queue* pq);

bool QueueEmpty(Queue* pq);

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "queue.h"

void  QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
}

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

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	newnode->data = x;
	newnode->next = NULL;

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


bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head ==NULL;
}

void  QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}

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

int QueueSize(Queue* pq)
{
	assert(pq);
	int n = 0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		n++;
		cur = cur->next;
	}
	return n;
}

栈和队列的一些高频面试题

1、括号匹配问题OJ链接

//前面加上栈的实现
bool isValid(char * s){
    ST st;
    StackInit(&st);
    while(*s)
    {
        if(*s=='('||*s=='['||*s=='{')
        {
            StackPush(&st,*s);
            s++;
        }
        else
        {
            if(StackEmpty(&st))
            {
                StackDestroy(&st);
                return false;
            }
            STDataType top=StackTop(&st);
            StackPop(&st);
            if((*s==')'&&top!='(')||(*s=='}'&&top!='{')||(*s==']'&&top!='['))
            {
                StackDestroy(&st);
                return false;
            }
            else
            {
                s++;
            }
        }
    }
    bool ret=StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}

2、用队列实现栈OJ链接

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


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

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))
    {
        emptyQ=&obj->q2;
        nonemptyQ=&obj->q1;
    }
    while(QueueSize(nonemptyQ)>1)
    {
         QueuePush(emptyQ,QueueFront(nonemptyQ));
         QueuePop(nonemptyQ);
    }
    int 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->q2);
    free(obj);
}

难点在于用队列实现出栈。
那怎么实现的呢？
在这里插入图片描述其实就是运用两个队列，先把数据都入列，入列跟入栈差不多，
然后我们现在要出栈了，出队列是要在队头，所以把1，2，3依次出去放另一个队列，就剩下最后一个4了，然后再出这个4，就相当于是出栈了，
之后的要出栈3，跟4一样，先把1，2出队列，放到另一个空队列，剩3自己，然后出3。

3、用栈实现队列OJ链接

typedef struct {
    ST pushST;
    ST popST;
} MyQueue;


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

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

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

int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            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) {
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    free(obj);
    }

与队列实现栈一样难点在出队列
在这里插入图片描述

同样，使用两个栈来实现队列，先把1，2，3，4入栈，
现在我们要出队列，出队列是从队头出，所以我们需要出1，但是栈是后进先出，所以我们4，3，2，1依次出栈到另一个栈里，现在1就是栈顶了，所以pop就是出的1，也就是队列的队头。

4、设计循环队列OJ链接

typedef struct {
    int*a;
    int front;
    int tail;
    int k;
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

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

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->tail]=value;
    obj->tail++;
    obj->tail%=(obj->k+1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    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[obj->k];
    }
    else
    {
        return obj->a[obj->tail-1];
    }
}

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

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

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

可以用数组实现，也可以用链表实现，我这里是使用数组实现的。

注意的几点：
1、循环队列也符合先进先出。
2、循环队列的空间大小是确定的。
3、但是空间可以重复利用，就是你一边入队列，也一边可以出队列，当然，满了就不能入了。
4、关键是判断满和空，空好判断就是front和tail指针相等的时候为空，
那满的时候呢？总不能也是两指针相等的时候吧？所以要多开一个空间，当tail+1等于front的时候就是满的时候。

感谢阅读，我们下期再见
如有错 欢迎提出一起交流
关注周周汪哦

关注三连么么么哒

周周汪
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
栈、队列(详细图解与代码实现)
YOLO97的博客
09-07 3913
栈 栈是一种只能在一端进行插入和删除的线性数据结构。主要有进栈(Push)和出栈(POP)两个操作。 - 栈的存储结构 栈一般使用一段连续的空间进行存储，通常预先分配一个长度，可以简单地使用数组去实现，具体的存储结构如下图所示： - 栈的特点 只能在一端进行操作，在遵循先进后出(FILO,First In Last Out)或后进先出(LIFO,Last In First Out...
C语言中断言库与断言函数assert()的用法总结
qq_42595610的博客
06-15 765
包含在头文件assert.h中他接受一个整形表达式作为参数(z > 40)：如果表达式为假，则assert()函数就在标准错误流中写入一条错误信息，也就是报错嘛。并且会调用abort()函数终止程序（**abort()函数的原型就在stdib.h**中）。如果表达式为真，则程序顺利通过。
栈和队列的实现（详解+图解！文末附完整代码）
逃离枷锁，冲向天空！
11-25 535
当capacity和top相等时其实是有两种情况的，一种时为空，另一种是栈满，，我们在这里就用一个三目操作符，如果为0，就将capacity初始化为4，否则将capacity的原来的值乘2，然后动态开辟realloc一块新的空间，大小就是newcapacity，这样我们就完成了扩容。在后面的增删查改等操作我们需要断言，为了增加代码的可读性，我们直接写一个函数 ，更加容易理解，如果栈顶元素下标为0，那么这个栈就为空 ，所以直接return top等于 0这个表达式的值，为空则返回 1，不为空则返回0。
[C语言数据结构]栈
本科在读，致力于Linux/C++方向的学习，同时涉及数据结构与算法，操作系统，数据库mysql等等
11-15 891
用数组实现栈的详细操作-----C语言；
数据结构之栈与队列（完整代码）
起个名字真难的博客
07-24 1857
栈与队列顺序栈链栈（带头结点）顺序队列循环队列栈的应用匹配括号中缀表达式转后缀表达式递归（斐波那契数列） 顺序栈 //栈，先进后出 #include<iostream> #include<algorithm> using namespace std; typedef int ElemType; #define MaxSize 10 typedef struct{ ElemType data[MaxSize]; int top; }SqStack; void
西南科技大学SWUST OJ 数据结构 图相关题题解 图.zip
01-01
SWUST OJ ： 1055、1056、1057、1058、1059、1060、1061、1062、1063、1064、1065、1066、1067、1068、1069、1070、1071、1072、1075、1086题答案
swust西南科技大学OJ数据结构80题答案
10-14
整理了西南科技大学OJ上的全部80道数据结构考试题目代码
西南科技大学SWUST OJ 数据结构 树和二叉树答案 树和二叉树.zip
01-01
SWUST OJ： 971、972、973、975、976、977、978、979、980、981、982、983、984、985、986、987、1051、1052、1053、1105题答案
数据结构（清华大学版）——栈和队列
04-19
数据结构（清华大学版）——栈和队列
mooc-清华数据结构与算法(邓俊辉) OJ习题.zip
最新发布
06-17
mooc-清华数据结构与算法(邓俊辉) OJ习题.zip
数据结构实验--栈和队列操作
跳跳糖°的博客
04-17 3388
数据结构实验–顺序栈的操作 文章目录数据结构实验--顺序栈的操作一、实验要求二、实验核心算法二、实验代码示例 一、实验要求 编程实现栈的以下基本操作：建栈，取栈顶元素，入栈，出栈，显示顺序栈元素 二、实验核心算法 （1）定义顺序栈的存储结构，用base表示栈底指针，top表示栈顶指针，stacksize表示栈的容量 typedef struct { SElemType *base; //栈底指针 SElemType *top; //栈顶指针 int s
【数据结构】栈和队列：栈的功能实现代码（c语言实现，结尾附代码）
weixin_49088965的博客
03-31 105
本文适合数据结构初学者及实验课代码作为参考
c语言--栈和队列
weixin_61558111的博客
09-24 1564
栈的入栈和出栈操作 通常用指针top指向栈顶的位置，用指针bottom指向栈底，栈顶指针top动态反映栈的当前位置。栈是一种特殊的线性表，因此栈可采用顺序存储结构存储，也可以使用链式存储结构存储。栈中的数据元素用一个预设的足够长的一维数组来实现：。栈底位置可以设置在数组的任意端点，用来作为栈顶指针。 若现在有一个栈，StackSize是5，则栈的普通情况、空栈、满栈的情况分别如下图所示： 通常将0下标端设为栈底，这样空栈时栈顶指针s->top = -1；入栈时，栈顶指针s->top++；出栈时，s->
数据结构 - 栈的实现（c语言）
qq_61386381的博客
05-19 3271
目录 前言： 栈的实现方式讨论 栈的实现 栈的定义 接口函数 接口函数实现 1、初始化栈（StackInit） 2、销毁（StackDestroy） 3、入栈（StackPush） 4、出栈（StackPop） 5、返回栈顶数据（StackTop） 6、计算栈的大小（StackSize） 7、判断栈是否为空（StackIfEmpty） 完整代码： Stack.h Stack.c 前言： 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行.
assert()函数用法总结
gh2663287的博客
06-02 3525
assert()函数用法总结 　　assert宏的原型定义在中，其作用是如果它的条件返回错误，则终止程序执行，原型定义： #include void assert( int expression ); 　　assert的作用是现计算表达式 expression ，如果其值为假（即为0），那么它先向stderr打印一条出错信息，然后通过调用 abort 来终止程序运行。请看下面的程
断言（ASSERT)的用法
weixin_34032827的博客
03-12 1382
　　我一直以为assert仅仅是个报错函数，事实上，它居然是个宏，并且作用并非“报错”。 　　在经过对其进行一定了解之后，对其作用及用法有了一定的了解，assert()的用法像是一种“契约式编程”，在我的理解中，其表达的意思就是，程序在我的假设条件下，能够正常良好的运作，其实就相当于一个if语句： if(假设成立){ 程序正常运行；}else{ 报错&amp;&amp;终...
数据结构：栈与队列（三）
qq_73978222的博客
01-15 558
了解队列的基本原理后实现队列并不难，但是要细心，不能在细节上出错。
c语言 栈和队列的实现
编程爱好者的博客
08-14 6670
前提知识 顺序表 优点：可以随机访问，cpu高速缓存利用率高，不涉及（较少）进行插入和删除操作，应该使用顺序表 一般而言，我们使用顺序表（数组）的形式建立 栈这一数据结构。   栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。 其特点是先进后出，模仿c++stl的stack和queue，我...
《数据结构初阶》实现顺序循环队列和链式队列
m0_62171658的博客
03-28 4053
数组实现循环队列、单链表实现队列接口实现全解
西南科技oj数据结构
09-09
西南科技oj数据结构是指西南科技大学开发的一套用于编程竞赛的在线评测系统中，用于测试和评判学生对数据结构知识的掌握情况的题目。数据结构是计算机科学中的重要内容，它主要研究如何组织和存储数据以及如何高效地处理各种数据操作。 西南科技oj数据结构题目的特点是，它们涵盖了数据结构的各个方面，如线性表、栈、队列、链表、树、图等。每个题目都要求学生根据题目描述和要求，设计和实现相应的数据结构，然后使用合适的算法对数据进行操作和处理。 在解决这些题目时，学生需要具备一定的数据结构基础知识，如数组、链表、栈和队列的基本操作，以及树和图的遍历算法、最短路径算法等。此外，对于每个题目，学生还需要分析问题的特点和要求，选择合适的数据结构和算法，使得程序能够高效地运行。 通过西南科技oj数据结构题目的练习，学生能够加深对数据结构的理解和运用能力，同时也能够提高编程和算法设计的水平。这对于学生在进行编程竞赛和实际工程开发中都非常有帮助。 总之，西南科技oj数据结构题目的设计旨在帮助学生掌握和应用数据结构知识，提高编程和算法设计的能力。通过解决这些题目，学生能够在实践中提升自己的能力，并为日后的学习和工作打下坚实的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

周周汪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值