数据结构：栈和队列

最新推荐文章于 2024-06-26 18:08:54 发布
最新推荐文章于 2024-06-26 18:08:54 发布
阅读量60 收藏 3
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/decade777555/article/details/132591818
版权

目录

文章目录

前言

一、栈

1.1 栈的概念和结构

1.2 栈的实现

二、队列

2.1 队列的概念和结构

 2.2 队列的实现

2.3 循环队列

 三、栈和队列的面试题

3.1 括号匹配问题。OJ链接

3.2 用队列实现栈。OJ链接

 3.3 用栈实现队列。OJ链接

 3.4 设计循环队列。OJ链接

前言

栈和队列是一种重要的数据结构，本文章将介绍栈和队列的结构以及一些关于栈和队列的面试题。

一、栈

1.1 栈的概念和结构

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

1.2 栈的实现

  栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。 

以下是栈实现的代码

stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef char DataType;

typedef struct stack
{
	DataType *data;
	int top;
	int capacity;
}ST;

//初始化栈
void STInit(ST* ps);
//销毁栈
void STDestroy(ST* ps);
//插入
void STPush(ST* ps,DataType x);
//删除
void STPop(ST* ps);
//取栈顶元素
DataType STTop(ST* ps);
//栈的大小
int STSize(ST* ps);
//栈是否为空
bool STEmpty(ST* ps);

stack.c

#define  _CRT_SECURE_NO_WARNINGS
#include"Stack.h"
void STInit(ST* ps)
{
	assert(ps);
	ps->data = NULL;
	ps->capacity =0;
	ps->top = 0;
}

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

void STPush(ST* ps,DataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newsize = ps->capacity == 0 ? 4 : ps->capacity * 2;
		DataType* tmp = (DataType*)realloc(ps->data,sizeof(DataType)*newsize);
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		ps->data = tmp;
		ps->capacity = newsize;
	}
	ps->data[ps->top] = x;
	ps->top++;
}

//删除
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}

//取栈顶元素
DataType STTop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->data[ps->top-1];
}

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

bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

二、队列

2.1 队列的概念和结构

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

 

 2.2 队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

Queue.h

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

typedef int DataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	DataType data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que;
//队列的初始化
void QueueInit(Que* pq);
//销毁队列
void QueueDestroy(Que* pq);
//入队
void QueuePush(Que* pq, DataType x);
//出队
void QueuePop(Que* pq);
//取队首元素
DataType QueueFront(Que* pq);
//取队尾元素
DataType QueueBack(Que* pq);
//判断对是否为空
bool QueueEmpty(Que* pq);
//队的大小
int QueueSize(Que* pq);

 Queue.c

#define  _CRT_SECURE_NO_WARNINGS
#include"Queue.h"
void QueueInit(Que* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}


void QueueDestroy(Que* 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(Que* pq,DataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}

DataType QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;

}

void QueuePop(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* newnode = pq->head->next;
		free(pq->head);
		pq->head = newnode;
	}
	pq->size--;
}

DataType QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

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

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


typedef struct {
	Que* q1;
	Que* q2;
} MyStack;


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

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

int myStackPop(MyStack* st) {
	Que* empty = st->q1;
	Que* noempty = st->q2;
	if (!QueueEmpty(st->q1))
	{
		noempty = st->q1;
		empty = st->q2;
	}
	while (QueueSize(noempty) > 1)
	{
		QueuePush(empty, QueueFront(noempty));
		QueuePop(noempty);
	}
	int top = QueueFront(noempty);
	QueuePop(noempty);
	return top;
}

int myStackTop(MyStack* st) {
	if (QueueEmpty(st->q1))
	{
		QueueBack(st->q1);
	}
	else
	{
		QueueBack(st->q2);
	}

}

bool myStackEmpty(MyStack* st) {
	return QueueEmpty(st->q1) && QueueEmpty(st->q2);

}

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

2.3 循环队列

实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型
时可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。

循环队列的实现：

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 myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front==obj->rear;
}

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

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    return false;
    (obj->a)[obj->rear++]=value;
    obj->rear%=(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;

    return (obj->a)[(obj->rear+obj->k)%(obj->k+1)];
}

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

 三、栈和队列的面试题

3.1 括号匹配问题。OJ链接

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

本题使用栈来实现，栈的实现代码前面已经给过了，在后面加上解题代码：

bool isValid(char* s) {
	ST s1;
	STInit(&s1);
	char ch;
	while (*s)
	{
		if (*s=='('||*s=='['||*s=='{')
		{
			STPush(&s1, *s);
		}
		else
		{
			if (STEmpty(&s1))
			{
				STDestroy(&s1);
				return false;
			}
			ch = STTop(&s1);
			STPop(&s1);
				if((*s == '}' && ch != '{') 
					||(*s == ']' && ch != '[') 
					||(*s == ')' && ch != '('))
				{
					STDestroy(&s1);
					return false;
				}
		}
		++s;
		}
	bool ret = STEmpty(&s1);
	STDestroy(&s1);
	return ret;
}

3.2 用队列实现栈。OJ链接

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

 队列实现代码前面也有，下面是实现栈的函数：

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


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

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

int myStackPop(MyStack* st) {
	Que* empty = &st->q1;
	Que* noempty = &st->q2;
	if (!QueueEmpty(&st->q1))
	{
		noempty = &st->q1;
		empty = &st->q2;
	}
	while (QueueSize(noempty) > 1)
	{
		QueuePush(empty, QueueFront(noempty));
		QueuePop(noempty);
	}
	int top = QueueFront(noempty);
	QueuePop(noempty);
	return top;
}

int myStackTop(MyStack* st) {
	if (!QueueEmpty(&st->q1))
	{
		return QueueBack(&st->q1);
	}
	else
	{
		return QueueBack(&st->q2);
	}
}

bool myStackEmpty(MyStack* st) {
	return QueueEmpty(&st->q1) && QueueEmpty(&st->q2);

}

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

 3.3 用栈实现队列。OJ链接

 实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false
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) {
    if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst,STTop(&obj->pushst));
						STPop(&obj->pushst);
        }
    }
    int tmp=STTop(&obj->popst);
    STPop(&obj->popst);
    return tmp;
}

int myQueuePeek(MyQueue* obj) {
 if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst,STTop(&obj->pushst));
						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);
}

 3.4 设计循环队列。OJ链接

你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。

循环队列代码2.3已经给过，大家可以尝试实现。

Faiz..
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
数据结构： 栈和队列
11-03
数据结构中 栈 队列 算法 得讲解。欢迎大家下载，学习。
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
C++数据结构：栈和队列的应用
攻城狮的博客
05-29 1879
C++ 是一种面向对象的编程语言，它提供了多种数据结构，前面文章已介绍过数组、链表、hash表，并用自己的方法实现。用于存储和操作数据的结构在STL中还有很多，其中两种常用的数据结构是栈和队列。本文将介绍栈和队列的概念，特点，实现方式和应用场景。
数据结构:栈和队列
WangSir
10-26 1617
队列是在一端进行插入数据，另一端进行删除数据操作的特殊线性表，队列遵循先进先出原则。从集合框架中，Stack继承了Vector，Vector和ArrayList类似，都是动态顺序表。在使用中我们还会用到一种队列叫循环队列。栈、虚拟机栈、栈帧有什么区别呢？是一种特殊的线性表，只允许在。循环队列通常使用数组实现。
数据结构：栈和队列（详细讲解）
xiaoyubuhuiqiche的博客
01-07 5405
详细的讲解了栈和队列，内容理解轻松适合初学者学习
图解数据结构：栈和队列
Sicimike的博客
10-22 4708
前言 上一篇 图解数据结构：数组和单链表 主要讲解了数组和链表这两种线性结构的特点、区别、时间复杂度分析等。对数组和链表的划分，实际上是物理结构（存储结构）的划分。 物理结构有两种基本的结构：顺序存储结构、链式存储结构。而本篇说讲解的栈和队列属于逻辑结构上的划分。逻辑结构分为线性结构、非线性结构。 线性结构：有且仅有一个开始节点和一个终端节点，每个节点最多只有一个直接前驱和一个直接后继。代表结构...
数据结构：栈和队列 思维导图
weixin_43808478的博客
12-22 1585
数据结构：栈和队列（c语言）
qq_37253540的博客
07-21 1160
一、栈和队列基本介绍 栈和队列是两种重要的线性结构。从数据结构角度来看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表操作的子集，他们是操作受限制的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，它们是和线性表大不相同的两类重要的抽象数据类型。由于它们广泛应用在各种软件系统中，因此在面向对象的程序设计中，它们是多型数据类型。 二、栈 栈是限定仅在表尾进行插入或者删除操作的线性表。因此，对栈来说，表尾端有特殊含义，称为栈顶，相应的，表头称为栈底。不含元素的空表称为空栈。 栈的修改
数据结构：栈和队列概念和代码实现解析
2301_80005105的博客
05-10 812
顺序表、单链表、双链表学完以后就开始学习栈和队列啦，前面的不知道的可以看一下我的专栏数据结构呀，大家多多关照我希望可以用较为浅显的语言来让你搞懂栈和队列，那么就步入正文啦。
数据结构：单调栈和单调队列
m0_63997099的博客
03-29 1710
单调队列和单调栈，有LeetCode典型例题哦~
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
C#中两种数据结构：栈和队列
05-22
栈和队列是软件设计中常用的两种数据结构，它们的逻辑结构和线性表相同。 其不同之处在于，栈和队列的相关操作具有特殊性，它们只是线性表相关操作的一个子集。 更准确地说，一般线性表上的插入、删除操作不受限制，...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构-分析期末选择题考点（排序）
最新发布
2301_79201049的博客
06-26 397
再找比基准大的元素，找到后交换。（2）归并排序是一种二分排序算法，每次都需要给 n 个元素排序，排序的过程需要 logn，即树的高度，所以时间复杂度为 nlogn。快速排序以基准值为中心，对元素进行划分，这里 28 为基准值，则小于 28 的和大于 28 的进行交换，完成一次划分。排序的思想是每次选出最值，放在已排序序列的末尾，如果最值有多个，而选出的为最后一个最值，会导致相对位置发生变化。这种题就考的是对所有排序的模拟了，需要你了解所有排序的实现原理，属于偏难的题目，小概率会出。题型大概就是初始化建堆。
数据结构 —— 哈夫曼树
qq_67693066的博客
06-24 943
数据结构与算法 —— 哈夫曼树
北航数据结构与程序设计查找与排序编程题
zxy13149285776的博客
06-20 1023
先对漏排的座位进行修正：已安排的最大座位号为27，学号为18373017和18373013的学生分别安排了27号座位，按照漏排座位修正规则，先将18373017学生安排在1号座位，再将18373013学生安排在3号座位；当前安排的最大座位号为22，还有2号和18号座位重复，将2号重复的学号较大的18373029号学生安排在23号座位，将18号重复的学号较大的18373026号学生安排在24号座位。1：在单词表中以顺序查找方式查找，因为单词表已排好序，遇到相同的或第一个比待查找的单词大的单词，就要终止查找；
2. 数据结构分析即索引库的crud
weixin_39563769的博客
06-23 244
put /hotel//id需要进行crud操作，但是不需要分词"id":{},//需要进行检索，也需要进行分词"name":{},//地址不需要检索},//需要参与检索"price":{},//需要参与检索"score":{},//需要参与检索"brand":{},"city":{},},},//需要参与检索，地理信息类型的数据},"pic":{},"all":{
专升本数据结构第三-四章+栈+队列.pdf
01-14
这篇资料主要介绍了数据结构中的栈和队列，这是计算机科学中基础且重要的数据结构概念，尤其对于专升本的学生来说，理解和掌握这些内容至关重要。在第三章和第四章中，详细阐述了栈的定义、特性以及各种操作。 栈是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值