三、栈和队列

最新推荐文章于 2024-07-14 01:31:01 发布
最新推荐文章于 2024-07-14 01:31:01 发布
阅读量310 收藏 1
点赞数
分类专栏： # 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18534081/article/details/119783272
版权

栈和队列

一、栈(stack)

（一）定义：

只允许在一端进行插入和删除的线性表，逻辑结构和普通线性表相同，插入、删除操作有区别。
空栈：没有元素的栈
栈底：不允许插入、删除的一端
栈顶：允许插入删除的一端
在这里插入图片描述

（二）基本操作：

1.创建和销毁：

1.1.栈的创建：

InitStack(&S):初始化一个空栈S，并分配内存空间；

1.2.栈的销毁：

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

2.元素的增删查改：

2.1.进栈（增）：

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

2.2.出栈（删）：

Pop(&S,&x):若栈非空，则弹出栈顶元素，并用x返回【需要返回则使用&】

2.3.读栈（查）：

GetTop(S,&x):读栈顶元素，若栈S非空，则用x返回栈顶的元素
读栈顶与出栈的区别：出栈删除元素，读栈顶不删除
注意：在栈中，通常只需要访问（查）栈顶元素

3.其他操作：

3.1.判栈空：

StackEmpty(S):若为空，则返回true，否则返回false

（三）常见考试题型：

已知进栈顺序，写出有几种出战顺序：
在这里插入图片描述

（四）顺序栈的实现：

顺序栈：用顺序存储方式实现的栈

1.基本操作：

1.0.顺序栈的定义：
#define MaxSize 10//栈中元素的总个数 
typedef struct{
	int data[MaxSize];//静态数组存放 
	int top;//栈顶指针 
}SqStack;
1.1.创（初始化）：
void InitSqStack(SqStack &S){
	S.top = -1;//初始化栈顶指针 
	//问题：为什么初始化栈顶指针指向-1
	//答：数组下标从0开始，初始时没有元素，栈顶指针指向0不合理，故而指向-1 	
}
1.2.增（进栈）：
bool Push(SqStack &S,int x){
	if(S.top == MaxSize-1){
		return false;
	}
	S.top = S.top+1;//栈顶指针加1移向新的栈顶 
	S.data[S.top] = x;//x放入到数据域中，位置为栈顶指针指向的位置 
	return true;
}
1.3.删（出栈）：
bool Pop(SqStack &S,int &x){
	if(S.top == -1){
		return false;
	}
	x = S.data[S.top];//将栈顶元素给x 
	S.top = S.top-1;//指针回退 
	return true;
}
1.4.查（获取栈顶元素）：
bool GetTop(SqStack &S,int &x){
	if(S.top == -1){
		return false;
	}
	x = S.data[S.top];
	return true;
}
1.5.判空、判满：
//判栈空
bool StackEmpty(SqStack S){
	if(S.top == -1){
		return true;
	}else{
		return false;
	}
} 

//判栈满
bool Stack(SqStack S){
	if(S.top == MaxSize){
		return true;
	}else{
		return false;
	}
}

2.代码合集：

#include <stdio.h>
#include <stdlib.h>

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

//初始化顺序栈
void InitSqStack(SqStack &S){
	S.top = -1;//初始化栈顶指针 
	//问题：为什么初始化栈顶指针指向-1
	//答：数组下标从0开始，初始时没有元素，栈顶指针指向0不合理，故而指向-1 	
}

//判栈空
bool StackEmpty(SqStack S){
	if(S.top == -1){
		return true;
	}else{
		return false;
	}
} 

//判栈满
bool Stack(SqStack S){
	if(S.top == MaxSize){
		return true;
	}else{
		return false;
	}
} 

//新元素入栈
bool Push(SqStack &S,int x){
	if(S.top == MaxSize-1){
		return false;
	}
	S.top = S.top+1;//栈顶指针加1移向新的栈顶 
	S.data[S.top] = x;//x放入到数据域中，位置为栈顶指针指向的位置 
	return true;
} 

//出栈
bool Pop(SqStack &S,int &x){
	if(S.top == -1){
		return false;
	}
	x = S.data[S.top];//将栈顶元素给x 
	S.top = S.top-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;
}

2.共享栈：

两个栈共享同一片空间

#include <stdio.h>
#include <stdlib.h>

//定义一个共享栈：有两个栈，0号栈和1号栈 
#define MaxSize 10
typedef struct{
	int data[MaxSize];
	int top0; 
	int top1;
}ShStack; 

//初始化共享栈
void InitShStack(ShStack &S){
	S.top0 = -1;//从下向上 
	S.top1 = MaxSize;//从上向下
	 
} 

//判断栈满
bool Stack(ShStack S){
	if(S.top0+1 == S.top1){
		return true;
	}else{
		return false;
	}
}

（五）链栈的实现：

和单链表相似

二、队列（Queue）

（一）定义：

只允许在==一端插入（入队）、另一端删除（出队）==的线性表（先进先出FIFO）
在这里插入图片描述

（二）基本操作：

在这里插入图片描述

（三）顺序存储实现队列：

1.定义：

//定义一个队列
#define MaxSize 10
typedef struct{
	int data[MaxSize];
	int front;//对头指针 
	int rear;//对尾指针 
}SqQueue;

2.创：

//初始化
void InitSeQueue(SqQueue &Q){
	//队列初始化，没有元素，对头和队尾指向同一个位置
	Q.front = Q.rear = 0; 
}

3.销：

4.增：

//入队（插入元素） 
bool EnQueue(SqQueue &Q,int x){
	if((Q.rear+1)%MaxSize==Q.front){//判断队列已满 
		return false;
	} 
	Q.data[Q.rear] = x;//只能从队尾插入 
	Q.rear ++;
	//因为队列是对头删除，对尾插入
	//则有这种可能：队尾指针已到最大，而对头元素有删除，上句代码不适用，怎么办？ 
	//用Q.rear = (Q.rear+1) % MaxSize; 替换上句代码，从而形成逻辑上的环状 
	return true;
}

在这里插入图片描述

5.删：

//出队（删除元素） 
bool DeleteQueue(SqQueue &Q,int &e){
	if(Q.front == Q.rear){//判断队列空 
		return false;
	}
	e = Q.data[Q.front];
	Q.front = (Q.front+1)%MaxSize;
	return true;
}

6.查：

//获取对头元素的只，并用x返回
bool GetHead(SqQueue &Q,int x){
	if(Q.rear == Q.front){
		return false;
	}
	x = Q.data[Q.front];
	return true;
}

7.判空：

//队列判空
bool SeQueue(SqQueue Q){
	if(Q.front == Q.rear){
		return true;
	}else{
		return false;
	}
}

8.判队满：

(Q.rear+1)%MaxSize==Q.front;//循环队列判对满

9.代码合集：

#include <stdio.h>
#include <stdlib.h>

//定义一个队列
#define MaxSize 10
typedef struct{
	int data[MaxSize];
	int front;//对头指针 
	int rear;//对尾指针 
}SqQueue; 

//初始化
void InitSeQueue(SqQueue &Q){
	//队列初始化，没有元素，对头和队尾指向同一个位置
	Q.front = Q.rear = 0; 
} 

//队列判空
bool SeQueue(SqQueue Q){
	if(Q.front == Q.rear){
		return true;
	}else{
		return false;
	}
} 

//入队（插入元素） 
bool EnQueue(SqQueue &Q,int x){
	if((Q.rear+1)%MaxSize==Q.front){//判断队列已满 
		return false;
	} 
	Q.data[Q.rear] = x;//只能从队尾插入 
	Q.rear ++;
	//因为队列是对头删除，对尾插入
	//则有这种可能：队尾指针已到最大，而对头元素有删除，上句代码不适用，怎么办？ 
	//用Q.rear = (Q.rear+1) % MaxSize; 替换上句代码，从而形成逻辑上的环状 
	return true;
}

//出队（删除元素） 
bool DeleteQueue(SqQueue &Q,int &e){
	if(Q.front == Q.rear){//判断队列空 
		return false;
	}
	e = Q.data[Q.front];
	Q.front = (Q.front+1)%MaxSize; 
	return true;
} 

//获取对头元素的只，并用x返回
bool GetHead(SqQueue &Q,int x){
	if(Q.rear == Q.front){
		return false;
	}
	x = Q.data[Q.front];
	return true;
} 
 int main(){
 	SqQueue Q;
 	return 0;
 }

（四）链式存储实现队列：

#include <stdio.h>
#include <stdlib.h>

//定义链式队列
typedef struct LinkNode{//链式队列结点 
   int data;
   struct LinkNode* next;
}LinkNode; 
typedef struct{
   LinkNode* front;//对头 
   LinkNode* rear;//队尾 
}LinkQueue; 

// 初始化（带头节点） 
void InitQueue0(LinkQueue &Q){
   Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
   Q.front->next = NULL; 
}
//判空
bool IsEmpty0(LinkQueue Q){
   if(Q.front == Q.rear){
   	return true;
   } else{
   	return false;
   }
} 

//初始化（不带头节点） 
void InitQueue1(LinkQueue &Q){
   Q.front = NULL;
   Q.rear = NULL;
}
//判空
bool IsEmpty1(LinkQueue Q){
   if(Q.front == NULL){
   	return true;
   }else{
   	return false;
   }
} 

//入队（带头节点） 
void EnQueue0(LinkQueue &Q,int x){
   LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode)); 
   s->data = x;
   s->next = NULL;
   Q.rear->next = s;//s插入到rear后 
   Q.rear = s;//s作为队尾 
}

//入队（不带头节点） 
void EnQueue1(LinkQueue &Q,int 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;
   }
}

//出队（带头节点） 
bool DeQueue0(LinkQueue &Q,int &x){
   if(Q.front == Q.rear){
   	return false;
   }
   LinkNode* p = Q.front->next;//用p指向需要删除的结点 ，因为队列是对头依次删，则是头节点的下一结点 
   x = p->data;
   Q.front->next = p->next;
   if(Q.rear = p){
   	Q.rear = Q.front;
   }
   free(p);
   return true;
    
}
//出队（不带头节点） 
bool DeQueue1(LinkQueue &Q,int &x){
   if(Q.front == NULL){
   	return false;
   }
   LinkNode* p = Q.front;//p指向需要删除的结点
   x = p->data;
   Q.front = p->next;
   if(Q.rear == p){
   	Q.front = NULL;
   	Q.rear = NULL;
   } 
   free(p);
   return true;
}

int main(){
	return 0;
}

（五）双端队列：

1.定义：

在这里插入图片描述只允许在两端插入、删除的线性表，若将双端队列只从一端插入删除，则变成了栈

2.分类：

2.1.输入受限：

在这里插入图片描述

2.2.输出受限：

在这里插入图片描述

（六）判断输出序列的合法性：

1.栈：

在这里插入图片描述

2.输入受限的双端队列：

在这里插入图片描述

2.输出受限：

在这里插入图片描述

三、栈的应用：

（一）括号匹配：

1.基本思路：

在这里插入图片描述遇到做括号则压入栈中，当遇到右括号时，弹出栈顶元素与之相匹配，相同则true

在这里插入图片描述

2.C语言实现：

#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 Push(SqStack &S,int x){
	if(S.top == MaxSize-1){
		return false;
	}
	S.top = S.top + 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;
	return true;
} 

//判栈空
bool IsEmpty(SqStack S){
	if(S.top == -1){
		return true;
	}else{
		return false;
	}
} 

//括号匹配 
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(topElem == ')' && str[i] != '('){
				return false;
			}
			if(topElem == ']' && str[i] != '['){
				return false;
			}
			if(topElem == '}' && str[i] != '{'){
				return false;
			}
		}
		return IsEmpty(S);
	} 
	
}

int main(){
	return 0;
}

（二）表达式求值：

1.中缀表达式：

运算符在两个操作数中间：a + b ；a + b - c ; a + b - c * d

2.前缀表达式（波兰表达式）：

运算符在两个操作数前面：+ a b ; - + a b c ; - + a b * c d

3.后缀表达式（逆波兰表达式）：

运算符在两个操作数后面：a b + ; a b + c - ; a b + c d * -

4.转换方法：

4.1.中缀转后缀：

在这里插入图片描述

在这里插入图片描述从左向右看，碰到符号则将符号放在左边最近的两个操作数之间
在这里插入图片描述

在这里插入图片描述

4.2.中缀转前缀：

在这里插入图片描述
在这里插入图片描述对比：
在这里插入图片描述

（三）栈的递归调用：

1.求阶乘：

//求n个数的阶乘 
int factorial (int n){
	if(n == 0 || n == 1){
		return 1;
	}else{
		return n*factorial(n-1);
	}
}

int main(){
	int input;
	printf("请输入需求的阶乘数：");
	scanf("%d",&input);
	int output = factorial(input);
	printf("%d的阶乘为：%d\n",input,output);
	return 0;
}

2.求斐波那楔数列：

0 1 1 2 3 5 8 13 … 数列从第三项开始，每一项都是前两项数之和

int Fib(int n){
	if(n == 0){
		return 0;
	}else if(n == 1){
		return 1;
	}else{
		return Fib(n-1) + Fib(n-2);
	}
}

int main(){
	int a = Fib(4);
	printf("%d\n",a);
	return 0;
}

四、队列的应用：

例如：进程的先来先服务原则，打印机缓冲区先来后到原则等。

五、矩阵的压缩存储：

（一）数组的存储结构：

1.一维数组：

各数组元素大小相同，物理上连续存放，数组下标从0开始。

2.二维数组：

各数组元素大小相同，物理上连续存放，数组下标从0开始，分为行优先（先存行后存列）和列优先（先存列后存行），视为一维存储。

（二）特殊矩阵：

1.对称矩阵：

aij = aji,即：关于主对角线对称，主对角线 i = j，因为主对角线上下对称，则可以只存储主对角线和下三角区域（或上三角区域）的内容

2.三角矩阵：

分为上三角和下三角，上三角：除了主对角线和下三角区，其他元素均相同，下三角：除了主对角线和上三角区，其他元素均相同

3.三对角矩阵：

带状矩阵：|i - j| > 1时，有aij = 0

4.稀疏矩阵：

非零元素远远小于矩阵元素的个数

INKAFI
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言栈与队列疑难点解析
木有
08-17 1290
C语言栈与队列疑难点解析     栈    只允许数据自有序列表的一个固定端（前端）做输入，输出动作，即LIFO。可用数组结构和链表结构建立栈。   数组仿真    1.声明：     char stack[MaxSize];     int top=-1;     MaxSize：栈中元素的最大个数，栈索引最大到MaxSize-1；top初始化为-1，可理解为数组的下标。
关于栈顶指针初值为-1和0的区别
weixin_46475770的博客
02-25 1万+
关于栈顶指针初值为-1或者0 的区别(c语言) 栈顶指针：S.top 栈顶元素：S.data[S.top] 当栈顶指针的初始值设置 S.top=-1时 ps: 当栈为空时，栈顶指针指向data[-1],但栈底是data[0] top data{4} data{3} data{2} data{1} data{0} data{-1} … 进栈操作：栈不满时，栈顶指针先+1，在送值到栈顶元素 （通俗来讲：先给客人指路，客人才知道自己的座位在哪） S.top=S.
C语言对于栈和队列的一些理解
初学者探索之路，认真当条汪
03-02 419
栈 最简单的理解最极致的享受 1.先看栈，我是这样理解的，把他看成是一个瓶子（只是在脑子想象的瓶子）而且数据进出都只有唯一的一个口子，如下图看的出来，从口子进去那么a第一个进去但是被压在最后一个位置，所以你要把他拿出来的时候只能最后一个拿出来因此就可以明白栈的操作了。 这时候我们发现有一个top，你可以理解为一个标示符号，当你设置栈位空的时候他是为-1的 （因为数组的第一个下标为0），因为我把栈看...
【M3内核篇】关于“堆栈指针的最低两位永远是0，这意味着堆栈总是4字节对齐的”的理解
u014036889的博客
05-23 1423
“堆栈指针的最低两位永远是0，这意味着堆栈总是4字节对齐的”理解 在看到《Cortex-M3权威指南》堆栈指针的这句话刚开始一直摸不着头脑，通过百度看到大神的解释就明白了： : 单片机地址每次通过4字节对齐进行偏移，那么下一个偏移的起始起止转换成二进制后的最低两位都为0，例如：从0x00000000地址偏移4个字节，那么下一个起始地址就为0x00000004，依次类推，下一个为0x00000008，将这些地址转化二进制发现最低两位都为0； ...
数据结构与算法--栈
T
02-24 403
数据结构与算法之顺序栈 简介: 栈也是一种受限制的线性表，与队列刚好相反，队列的特性是先进先出，而栈的特性是先进后出；只可在其一端(栈顶)进行(进出)操作。 操作数据的一端我们通常称为栈顶(top)，另外一段称为栈底(base)。栈的存储结构大致如下： 我们可以把栈结构大致看成一个装书的箱子，我们只能在箱子的顶部进行放书和拿书，先放进去的(高数)书会在箱子的最底部，后放的(英语)书会压在先放的高...
实验三栈和队列.cpp
11-30
实验三栈和队列.cpp
实验三 栈和队列的应用.docx
11-10
【栈和队列的基础知识】 栈和队列是两种常用的数据结构，在计算机科学和编程中具有广泛的应用。栈（Stack）被称为后进先出（LIFO, Last In First Out）结构，而队列（Queue）则遵循先进先出（FIFO, First In First ...
数据结构实验三栈和队列的应用.docx
11-12
【标题】: 数据结构实验三栈和队列的应用 【描述】: 该文档是关于数据结构中栈和队列应用的一个实验指导，旨在帮助学习者深入理解这两种基础数据结构的特性和操作。 【标签】: 互联网 【知识点】: 1. **栈**: -...
实验三 栈和队列的应用.pdf
11-10
【栈和队列的基本概念】 栈（Stack）是一种后进先出（Last In First Out, LIFO）的数据结构，常用于处理临时存储和快速访问的需求。它的主要操作包括入栈（Push）、出栈（Pop）、查看栈顶元素（Get Top）和判断栈...
C++内存分配
03-10 141
分配方式详解 栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。里面的变量通常是局部变量、函数参数等。在一个进程中，位于用户虚拟地址空间顶部的是用户栈，编译器用它来实现函数的调用。 堆，就是那些由 new 分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个 new 就要对应一个 delete。如果程序员没有释放掉，那么在程序结束后，操作系统
C语言版数据结构(从0开始)3.栈
qq_44970368的博客
01-30 684
栈（stack）又名堆栈，它是一种运算受限的线性表。栈(stack)是限制在表的一端进行插入和删除运算的线性表，通常称插入、删除的这一端为栈顶(top)，另一端为栈底(bottom)。当表中没有元素时称为空栈。
怎么理解堆栈指针（Stack Pointer）
热门推荐
进击的小怪兽
03-07 1万+
如果的堆栈的实现是往上长的（就是说往顶的方向长，其实质是栈底是定死的不能动，入栈的东西只能不断往上叠，这就像在书桌上放书一样，桌底是定死的，所以书只能一本一本地往上堆，往上长），计算机内部的堆栈的实现采取的就是这种模式，所以就得“先修改指针，然后插入数 据，出栈时刚好相反”，因为堆栈指针指向的总是栈顶元素，栈底不能动，所以数据入栈前要先修改指针使它指向新的空余空间然后再把数据存进去，出栈的时候 自
typedef struct 用法详解
mallven.com
01-30 1217
　typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。当typedef与结构结合使用时，会有一些比较复杂的情况，而且在C语言和C++里面有略有差别，本文将详细讲解typedef struct的用法。 第一篇：typedef struct与struct的区别 1. 基本解释 typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数...
动态栈 栈结构的链式实现
尜尜君的小世界
08-13 488
用链表形式实现栈结构的实现，栈链式实现可以不受空间的限制，
栈与队列基础知识总结
qq_43256290的博客
12-27 418
堆栈和队列都是特殊的线性表,其数据元素以及数据元素之间的逻辑关系完全相同,区别在于:线性表的插入和删除操作不受限制,堆栈只能在栈顶插入和删除,队列只能在队尾插入,在队头删除. 对于堆栈,作为参数的时候一般统一都对它其地址,尽管并不需要对它进行修改,加个const就好了(听老师说这样比较统一好看??) 堆栈的操作集合: 1.初始化 因为之前我是在网上找的博客,发现有很多人在初始化的时候都是将栈顶...
基本的几种数据结构
www.yiye.tech
11-01 6042
1、单链表2、3、4、5、6、7、
数据结构（初阶3.单链表）
最新发布
2401_83968713的博客
07-14 653
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
数据结构【顺序表】
qq_67578580的博客
07-12 1418
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1824
栈超超超详解
栈和队列基础与实现
"本资源是关于课堂练习，主要涉及栈和队列这两种数据结构，特别是循环队列的入队和出队算法。同时，提供了链式队列的定义以及栈的详细描述，包括栈的抽象数据类型、顺序栈的结构和操作实现。" 在计算机科学中，栈和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值