数据结构 4.栈和队列

已于 2024-06-01 16:25:27 修改
阅读量1.7k 收藏 20
点赞数 29
文章标签： 数据结构 c语言
于 2024-06-01 00:02:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54346126/article/details/139332688
版权

1.栈（Stack）

        栈是只允许在一端进行插入或删除操作的线性表

特点：后进先出（Last In First Out ）LIFO

基本操作：

 InitStack(&S)：初始化栈，构造一个空栈S，分配内存空间。

 DestroyStack(&L):销毁栈，销毁并释放S所占用的内存空间。

 Push(&S,x):进栈，若栈S未满，则将x加入使之成为新栈顶。

 Pop(&S,&x):出栈，若栈S非空，则弹出栈顶元素，并用x返回。

 GetTop(S,&x):读栈顶元素，若栈S非空，则用x返回栈顶元素。

................

2.栈的顺序存储

//顺序栈的定义
#define MaxSize 10 //定义栈中元素的最大个数 
typedef struct{
	ElemType data[MaxSize];//静态数组存放栈中元素 
	int top; //栈顶指针 
}SqStack;

//初始化
void InitStack(SqStack &S){
	S.top=-1; //初始化栈顶指针 
} 

//判断栈空
bool isEmpty(SqStack S){
	return S.top == -1;
} 

//入栈
 bool Push(SqStack &S,ElemType x){
	if(S.top == MaxSize-1)  //栈满 
	 	return false; 
	S.top=S.top+1;  //指针+1 
	S.data[S.top] = x;  //入栈 
	return true;
 } 
 
//出栈
bool Pop(SqStack &S,ElemType &x){
	if(S.top == -1)  //栈空 
	 	return false; 
	x=S.data[S.top]; //栈顶元素出栈 
	S.top=S.top-1;  //指针-1 
	return true;
} 
//读栈顶元素
bool GetTop(SqStack S,ElemType &x){
	if(S.top == -1)
		return false;
	x=S.data[S.top];
	return true;
} 
 
 int main(){
 	SqStack S;//声明一个顺序栈（分配空间） 
 }

   综合案例：

#include<stdio.h>
#define MaxSize 10 //定义栈中元素的最大个数 
typedef struct{
	int data[MaxSize];//静态数组存放栈中元素 
	int top; //栈顶指针 
}SqStack;

//初始化
void InitStack(SqStack &S){
	S.top=-1; //初始化栈顶指针 
} 

//判断栈空
bool isEmpty(SqStack S){
	return S.top == -1;
} 

//入栈
 bool Push(SqStack &S,int x){
	if(S.top == MaxSize-1)  //栈满 
	 	return false; 
	S.top=S.top+1;  //指针+1 
	S.data[S.top] = x;  //入栈 
	return true;
 } 
 
//出栈
bool Pop(SqStack &S,int &x){
	if(S.top == -1)  //栈空 
	 	return false; 
	x=S.data[S.top]; //栈顶元素出栈 
	S.top=S.top-1;  //指针-1 
	return true;
} 
//读栈顶元素
bool GetTop(SqStack S,int &x){
	if(S.top == -1)
		return false;
	x=S.data[S.top];
	return true;
} 
 
 int main(){
 	SqStack S;//声明一个顺序栈（分配空间） 
 	InitStack(S);
 	printf("push:");
 	if(isEmpty(S)){
 		Push(S,20);//入栈 
 		Push(S,21);
 		Push(S,22);
 		Push(S,23);
 		Push(S,24);
 		Push(S,25);
 		Push(S,26);
 		Push(S,27);
 		Push(S,28);
 		Push(S,29);
	}
	Push(S,30);//此时栈满，不再存入数据 
	//打印数据 
 	for(int i=0;i<=S.top;i++){
 		printf("%d\t",S.data[i]); 
	}
	//出栈 
	printf("\npop:\n");
	int x; 
	Pop(S,x);
	printf("%d\n",x);
	Pop(S,x);
	printf("%d\n",x);
	Pop(S,x); 
	printf("%d\n",x);
	Pop(S,x);
	printf("%d\n",x);
	//获取栈顶元素 
 	int y;
 	GetTop(S,y);
 	printf("top number：%d",y);
 }

 结果：

push:20 21      22      23      24      25      26      27      28      29
pop:
29
28
27
26
top number：25
--------------------------------

共享栈：（栈满：top0+1==top1）

//共享栈
#define MaxSize 10 //定义栈中元素的最大个数 
typedef struct{
	ElemType data[MaxSize];//静态数组存放栈中元素 
	int top0; //栈顶指针 
	int top1;
}ShStack; 
//初始化
void InitStack(ShStack &S){
	S.top0=-1; //初始化栈顶指针 
	S.top1=MaxSize;
}

3.栈的链式存储

//栈的链式存储
//定义 （只能在表头的位置进行插入和删除） 
typedef struct LinkNode{
	ElemType data; //数据域 
	struct LinkNode *next; //指针域 
}*LiStack;

综合案例：

//栈的链式存储
//定义 （只能在表头的位置进行插入和删除） 
#include<stdio.h>
#include<malloc.h>

typedef struct LinkNode{
	int data; //数据域 
	struct LinkNode *next; //指针域 
}*LiStack; 
void InitStack(LiStack &S){
	S=(LinkNode*)malloc(sizeof(LinkNode));
	S->next=NULL;
}

bool Insert(LiStack S,int x){
	LinkNode *p;
	p=(LinkNode*)malloc(sizeof(LinkNode));
	p->data=x;
	p->next=S->next;
	S->next=p;
	return true;
}
bool isEmpty(LiStack S){
	return S->next==NULL;
}
bool Delete(LiStack S,int &x){
	LinkNode *q;
	q=S->next;
	x=q->data;
	S->next=q->next;
	free(q);
	return true;
}


int main(){
	LiStack S;
	InitStack(S);
	if(isEmpty(S)){
		Insert(S,30);
		Insert(S,31);
		Insert(S,32);
		Insert(S,33);
		Insert(S,34);
		Insert(S,35);
	}
	LiStack p=S->next;
	while(p!=NULL){
		printf("%d\t",p->data);
		p=p->next;	
	}
	printf("\n");
	int x;
	Delete(S,x);
	printf("delete num: %d\n",x);
	Delete(S,x);
	printf("delete num: %d\n",x);
	Delete(S,x);
	printf("delete num: %d\n",x);
}

结果：

35      34      33      32      31      30
delete num: 35
delete num: 34
delete num: 33

4.队列（Queue）

        队列是只允许在一端进行插入，在另一端删除的线性表

        队尾：允许插入的一端

        队头：允许删除的一端

特点：先进先出（First In First Out）FIFO

基本操作：

 InitQueue(&Q)：初始化队列，构造一个空队列。

 DestroyQueue(&Q):销毁队列，销毁并释放队列所占用的内存空间。

 EnQueue(&Q,x):入队，若队列Q未满，则将x加入使之成为新队尾。

 DeQueue(&Q,&x):出队，若队列Q非空，则删除队头元素，并用x返回。

 GetHead(Q,&x):读队头元素，若队列Q非空，则将队头元素赋值给x。

................

5.队列的顺序存储

//队列的顺序存储
#define MaxSize 10
typedef struct{
	ElemType data[MaxSize]; //静态数组存放队列元素 
	int front,rear;  //队头和队尾指针 
}SqQueue; 
//初始化队列 
void InitQueue(SqQueue &Q){
	Q.front=Q.front=0;
}
//判断是否为空
bool QueueEmpty(SqQueue Q){
	return Q.front==Q.rear;
} 

//入队
bool EnQueue(SqQueue &Q,ElemType x){
	if((Q.rear+1)%MaxSize == Q.front)
		return false;
	Q.data[Q.rear]=x;
	Q.rear=(Q.rear+1)%MaxSize;
	return true;
} 


//出队
bool DeQueue(SqQueue &Q,ElemType &x){
	if(Q.rear == Q.front)
		return false;
	x=Q.data[Q.front];
	Q.front=(Q.front+1)%MaxSize;
	return true;
} 
//获得队头元素的值 
bool GetHead(SqQueue Q,ElemType &x){
	if(Q.rear == Q.front)
		return false;
	x=Q.data[Q.front];
	return true;
} 

//队列元素的个数：（rear+MaxSize-front）% MaxSize
int main(){
	SqQueue Q;
	InitQueue(Q); 
}

综合案例：

//队列的顺序存储
#include<stdio.h>
#define MaxSize 10
typedef struct{
	int data[MaxSize]; //静态数组存放队列元素 
	int front,rear;  //队头和队尾指针 
}SqQueue; 
//初始化队列 
void InitQueue(SqQueue &Q){
	Q.front=Q.front=0;
}
//判断是否为空
bool QueueEmpty(SqQueue Q){
	return Q.front==Q.rear;
} 
//入队
bool EnQueue(SqQueue &Q,int x){
	if((Q.rear+1)%MaxSize == Q.front)
		return false;
	Q.data[Q.rear]=x;
	Q.rear=(Q.rear+1)%MaxSize;
	return true;
} 
//出队
bool DeQueue(SqQueue &Q,int &x){
	if(Q.rear == Q.front)
		return false;
	x=Q.data[Q.front];
	Q.front=(Q.front+1)%MaxSize;
	return true;
} 
//获得队头元素的值 
bool GetHead(SqQueue Q,int &x){
	if(Q.rear == Q.front)
		return false;
	x=Q.data[Q.front];
	return true;
} 

int main(){
	SqQueue Q;
	InitQueue(Q); 
	if(QueueEmpty(Q)){
		EnQueue(Q,15);
		EnQueue(Q,16);
		EnQueue(Q,17);
		EnQueue(Q,18);
		EnQueue(Q,19);
		EnQueue(Q,20);
		EnQueue(Q,21);
	}

	int x;
	DeQueue(Q,x);
	printf("delete:%d\n",x);
	DeQueue(Q,x);
	printf("delete:%d\n",x);
	int y;
	GetHead(Q,y);
	printf("head number:%d",y);
}

结果：

delete:15
delete:16
head number:17

6.队列的链式存储

//队列的链式存储
#include<stdio.h>
#include<malloc.h>
typedef struct LinkNode{
	ElemType data; //数据域 
	struct LinkNode *next; //指针域 
}LinkNode; 
typedef struct{
	LinkNode *front,*rear;
}LinkQueue;


//初始化(带头节点) 
void InitQueue(LinkQueue &Q){
	Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
	Q.front->next=NULL;
}

//初始化(不带头节点) 
void InitQueue(LinkQueue &Q){
	Q.front=Q.rear=NULL;
}

//入队(带头节点)
 void EnQueue(LinkQueue &Q,ElemType x){
 	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
 	s->data=x;
 	s->next=NULL;
 	Q.rear->next=s;
 	Q.rear=s;
 } 
 
 //入队(不带头节点)
 void EnQueue(LinkQueue &Q,ElemType x){
 	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
 	s->data=x;
 	s->next=NULL;
 	if(Q.front == NULL){
 		Q.front=s;
 		Q.rear=s;
	}else{
		Q.rear->next=s;
 		Q.rear=s;	
	} 
 } 
 //出队(带头节点)
 void DeQueue(LinkQueue &Q,ElemType &x){
 	if(Q.front==Q.rear)
 		return false;
 	LinkNode *p=Q.front->next;
 	x=p->data;
 	Q.front->next=p->next;
 	if(Q.rear == p){
 		Q.front=Q.rear;
	 }
	 free(p);
	 return true;
 } 
 
 
//出队(不带头节点)
 void DeQueue(LinkQueue &Q,ElemType &x){
 	if(Q.front==NULL)
 		return false;
 	LinkNode *p=Q.front;
 	x=p->data;
 	Q.front=p->next;
 	if(Q.rear == p){
 		Q.front=NULL;
 		Q.rear=NULL;
	 }
	 free(p);
	 return true;
 } 
 
//判断是否为空
bool isEmpty(LinkQueue Q){
	return Q.front == Q.rear; 
} 
int main(){
	LinkQueue Q;
	InitQueue(Q);
}

综合案例：

//队列的链式存储
#include<stdio.h>
#include<malloc.h>
typedef struct LinkNode{
	int data; //数据域 
	struct LinkNode *next; //指针域 
}LinkNode; 
typedef struct{
	LinkNode *front,*rear;
}LinkQueue;

//初始化(带头节点) 
void InitQueue(LinkQueue &Q){
	Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
	Q.front->next=NULL;
}

void EnQueue(LinkQueue &Q,int x){
 	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
 	s->data=x;
 	s->next=NULL;
 	Q.rear->next=s;
 	Q.rear=s;
 } 
 
 
bool DeQueue(LinkQueue &Q,int &x){
 	if(Q.front== Q.rear)
 		return false;
 	LinkNode *p=Q.front->next;
 	x=p->data;
 	Q.front->next=p->next;
 	if(Q.rear == p){
 		Q.front=Q.rear;
	 }
	 free(p);
	 return true;
 } 

bool isEmpty(LinkQueue Q){
	return Q.front == Q.rear; 
} 
int main(){
	LinkQueue Q;
	InitQueue(Q);
	if(isEmpty(Q)){
		EnQueue(Q,13);
		EnQueue(Q,14);
		EnQueue(Q,15);
		EnQueue(Q,16);
		EnQueue(Q,17);
		EnQueue(Q,18);
	}
	
	int x;
	DeQueue(Q,x);
	printf("del:%d\n",x);
	DeQueue(Q,x);
	printf("del:%d\n",x);
}

结果：

del:13
del:14

7.双端队列

        双端队列：只允许从两端插入、两端删除的线性表

        输入受限的双端队列：只允许从一端插入、两端删除的线性表

        输出受限的双端队列：只允许从两端插入、一端删除的线性表

8.栈的应用

括号匹配：

//栈的应用（括号匹配）
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 10
typedef struct{
	char data[MaxSize];
	int top;
}SqStack; 

void InitStack(SqStack &S){
	S.top=-1; 
}

bool isEmpty(SqStack &S){
	return 	S.top == -1; 
}
bool Push(SqStack &S,char x){
	if(S.top == MaxSize-1)
		return false;
	S.top++;
	S.data[S.top]=x;
	return true;
}

bool Pop(SqStack &S,char &x){
	if(S.top == -1)
		return false;
	x=S.data[S.top];
	S.top--;
	return true;
}
bool bracketCheck(char str[],int length){
	SqStack S;
	InitStack(S);//初始化
	for(int i=0;i<length;i++){
		if(str[i]=='('||str[i]=='{'||str[i]=='['){
			Push(S,str[i]);//左括号入栈 
		}else{
			if(isEmpty(S))
				return false; //栈空
			char topElem;
			Pop(S,topElem);//栈顶元素出栈 
			if(str[i]==')' && topElem!='(')
				return false;
			if(str[i]==']' && topElem!='[')
				return false;
			if(str[i]=='}' && topElem!='{')
				return false;	
		} 
	}
	return isEmpty(S);
}

int main(){
	char str[]="{(()[])}";
	int len=8;
	bool flag=bracketCheck(str,len);
	printf("%d",flag); 		//打印结果：1 
}

栈在表达式中求值：

        Reverse Polish notation(逆波兰表达式=后缀表达式)

        Polish notation(波兰表达式=前缀表达式）

中缀表达式：a+b （运算符在两个操作数中间）a+b-c        a+b-c*d

后缀表达式：ab+（运算符在两个操作数后面）ab+c-  /abc-+         ab+cd*-

前缀表达式：+ab（运算符在两个操作数前面）        -+abc        -+ab*cd

4a95e3f7b82c4c35a4b0ac1bac8cba53.png728dd4eb391a4effb867cb101812a448.png

栈在递归中的应用：

        最后被调用的函数最先执行结束（LIFO）

        适合“递归”算法解决：可以把原始问题转换为属性相同，但规模较小的问题

ba88878020344b78a53b46d564f78d83.png9.队列的应用

        树的层次遍历

        图的广度优先遍历

        多个进程争着使用有限的系统资源时，FCFS（First Come First Service，先来先服务）是一种常用策略

10.特殊矩阵的压缩存储 

91a7d815c2444eccb3262b4465a8a646.png

2a3ce6333605493aa760f6df8a280ffe.png

 0dbf9363cb724a7695dea0bf708f3d39.png

For you ，a thousand times over
关注
  • 29
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
数据结构3栈和队列.pdf
01-14
数据结构中的栈和队列是两种非常基础且重要的线性数据结构，它们在计算机科学中有着广泛的应用。栈，被称为“后进先出”（LIFO）的数据结构，因为元素的添加（入栈，Push）和移除（出栈，Pop）只能在栈顶进行。栈的...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
数据结构复习（3.栈和队列）
qq_53635710的博客
12-29 1936
3.1栈 重点：逻辑结构唯一 两种特殊的线性表：栈和队列 首先从数据结构的角度来看：栈和队列是操作受限的线性表。他们的逻辑结构都是一对一的关系。 3.1.1栈的逻辑结构 栈：限定仅在表尾进行插入和删除操作的线性表。 （a1, a2, ……, an） 空栈：不含任何数据元素的栈。 允许插入和删除的一端称为栈顶，另一端称为栈底。 栈的示意图 栈的插入：入栈，进栈，压栈 栈的删除：出栈，...
数据结构~07.栈和队列的基本概念
qq_41424688的博客
07-28 3万+
数据结构学习~07.栈和队列的基本概念 本文是上一篇文章的后续,详情点击该链接~ 栈的定义:        栈是一种只能在一端进行插入或删除的线性表。其中,允许插入或删除的一端为栈顶(TOP)。栈顶由一个称为栈顶指针的位置指示器来指示。它是动态变化的 ...
数据结构实验--栈和队列操作
跳跳糖°的博客
04-17 3422
数据结构实验–顺序栈的操作 文章目录数据结构实验--顺序栈的操作一、实验要求二、实验核心算法二、实验代码示例 一、实验要求 编程实现栈的以下基本操作：建栈，取栈顶元素，入栈，出栈，显示顺序栈元素 二、实验核心算法 （1）定义顺序栈的存储结构，用base表示栈底指针，top表示栈顶指针，stacksize表示栈的容量 typedef struct { SElemType *base; //栈底指针 SElemType *top; //栈顶指针 int s
Java数据结构之栈和队列
fear_wolf的博客
10-24 1078
我们可以从集合那一节的图中看出，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。我们可以采用头插法来入栈，每次出栈时删除的也是头节点，时间复杂度也是O（1），但仍没有顺序栈方便，毕竟顺序栈不用修改指向。：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有。，队不为空时，rear都是front之后，随着入队出队的操作，最终。：栈的插入操作，叫做进栈/压栈/入栈，入数据在栈顶。
[详解栈和队列]数据结构之栈与队列
Philosophy7的博客
05-12 3680
✅作者简介：大家好,我是Philosophy7？让我们一起共同进步吧！🏆 📃个人主页：Philosophy7的csdn博客 🔥系列专栏： 👑哲学语录: 承认自己的无知，乃是开启智慧的大门 💖如果觉得博主的文章还不错的话，请点赞👍+收藏⭐️+留言📝支持一下博>主哦🤞 文章目录栈和队列1.物理结构和逻辑结构2.什么是栈2.1栈的基本操作3.什么是队列队列的基本操作小结 栈和队列 1.物理结构和逻辑结构 再了解栈和队列之前，我们要先知道什么是逻辑结构和物理结构。 逻辑结构: 按照逻辑结构划分:数据结.
数据结构：单调栈和单调队列
m0_63997099的博客
03-29 1829
单调队列和单调栈，有LeetCode典型例题哦~
数据结构实验报告—栈和队列
VLOKL的博客
03-31 3434
数据结构实验报告，栈，队列，C语言
C++数据结构：栈和队列的应用
攻城狮的博客
05-29 1916
C++ 是一种面向对象的编程语言，它提供了多种数据结构，前面文章已介绍过数组、链表、hash表，并用自己的方法实现。用于存储和操作数据的结构在STL中还有很多，其中两种常用的数据结构是栈和队列。本文将介绍栈和队列的概念，特点，实现方式和应用场景。
数据结构栈和队列详解.zip
04-03
栈和队列是两种非常基础且重要的数据结构，它们在计算机科学和软件开发中都有着广泛的应用。下面我将详细解释这两种数据结构。 栈（Stack） 栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。这...
数据结构 Java实验4 栈和队列.doc
06-20
在本实验报告中，主要涉及了数据结构中的两种基本结构——栈和队列，并通过Java编程语言实现了它们的实例应用。栈是一种具有“后进先出”（LIFO）特性的数据结构，而队列则遵循“先进先出”（FIFO）的原则。 在第一...
数据结构精解：栈和队列
07-16
简述了栈和队列两种数据结构的基本构成和方法
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1061
如有错误，欢迎指出~
数据结构第32节 无锁编程
最新发布
hummhumm的专栏
07-17 840
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 829
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1894
栈超超超详解

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值