首页 > 其他分享 >数据结构基础—栈和队列

数据结构基础—栈和队列

时间:2022-10-09 23:11:06浏览次数:52  
标签:运算符 队列 基础 char int MaxSize base 数据结构

数据结构基础—栈和队列

一、栈和队列的基本概念和性质

image

栈和队列都是特殊的线性表

对他们的操作有着规定和限制:在插入和删除时只能对某一端操作

  1. 栈:只能在一端进行(先进后出)
  2. 队列:只能在表尾插入,在表头删除(先进先出)

二、栈

表头为栈底,表尾为栈顶

1.栈的基本操作和规则

a.进栈和出栈

  • 进栈:栈顶则成为进栈的数据(插入)。如果是顺序表,则一定要进行判满
  • 出栈:将当前栈顶移出(删除),不管什么存储类型,一定要判空

b.进栈、出栈前后的次序

一个数的出栈可以在另一个数进栈前出,但不可以在另一个数进栈后,在这个数(另一个进栈的数)前出。

当一个数进栈后,若它前面有数,则在出栈时它前面的所有数的排列都是入栈的逆序


举个栗子:若进栈顺序为1 2 3,则,出栈时,不可能是那种排列?

答案:不可能是 3 1 2,为什么呢?

咱们一个一个分析,之前说过,一个数的出栈可以在另一个数入栈之前

  • 1进,2进前1出,2进,3进前2出,3进3出 : 1 2 3
  • 1进,2进前1出,2进,3进,3出2出 :1 3 2
  • 1进,2进,3进前2出,1出 ,3进3出 :2 1 3
  • 1进,2进,3进前2出,3进,3出1出 :2 3 1
  • 1进,2进,3进,3出2出1出 :3 2 1

所以不可能出现 3 1 2 的排列的,,若3前面有数,则出栈后3后的顺序一定是1 2 的逆序(和上面对应)

C.栈的类型

根据存储结构的不同分为顺序栈(顺序存储)和链栈(链式存储),在这里主要是研究顺序栈(链栈和链表差不多...)

d.顺序栈的一些基本操作

//是否为空
S.base == S.top;
//是否已满
S.top - S.base =>len;
//栈不存在
S.base = NULL;

/*类型自己转换吧*/
//栈的基本结构
typedef struct Stack{
	char *base;
	char *top;
	int Size;
}SqStack;

//创建空栈
void InitStack(SqStack &S){
	S.base = (char *)malloc(MaxSize*sizeof(char));//开辟空间 
	if(!S.base) cout << "创建失败\n";
	S.top = S.base; //栈空的条件 
	S.Size = MaxSize;
	cout << "空栈创建成功\n";
} 

//进栈
void Push(SqStack &S,char e){
	if((S.top-S.base) >=MaxSize){ //判满
		S.base = (char *)malloc(S.base,(MaxSize+ADD)*sizeof(char));
	    if(!S.base) cout << "创建失败\n";
	    S.top = S.base+MaxSize; 
	    S.Size = S.Size+ADD;
	}else{
		*S.top++ = e;			
	}
}

//出栈,获取出栈元素
char Pop(SqStack &S){
	char e;
	if(S.top == S.base) cout << "栈空";
	e = *--S.top;
	return e;
} 

//输出栈的元素
void Get(SqStack &S){
	for(int i = 0;S.base != S.top-i;i++){
		cout << *(S.base+i);
	}	
} 

2.栈在计算机的多种实现形式

image

3.栈的案例分析

表达式的求值(表达式最后添加一个"#")

相关知识:

  • 前缀式:+ * ab * - c / def
  • 中缀式:a * b+ (c - d / e) * f
  • 后缀式:ab * cde / - f * +
  • 后缀式

思路:将我们常见的中缀式先转化成后缀式,在根据后缀式来进行计算

  1. 中缀式->后缀式(利用运算符的优先级)
    • 先建立一个后缀式栈(1栈)来放最后生成的后缀式,在建立一个运算符栈(2栈),栈底为"#"来判断各个运算符之间的关系
    • 遍历输入的表达式
    • 若判断 1栈为空直接入1栈,否则判断是否是操作数(a,b,c...),是,则也直接入1栈
    • 若当前为运算符,则与2栈的的栈顶的运算符比较优先级,若有先级高与栈底,则入2栈;若低于或等于,则将栈顶的运算符出2栈,进1栈,再将当前栈顶与之比较直到优先级最高为止
    • 若遇到"()","("直接如2栈,")"将"("前所有的运算符出2栈,进1栈。并将"("出2栈
    • 最后遍历到 "#"时,运算符依次出2栈,直到2栈栈顶为"#"
    • 转换完成
  2. 后缀式求值
    • 再建立一个操作栈(3栈),用来暂时存放计算过程和最终显示结果
    • 遍历1栈
    • 若遍历到的1栈元素为数字,则,入3栈
    • 若若遍历到的1栈元素为运算符,则,将3栈中的后两个元素出栈,与该运算符进行正常运算,结果再入3栈
    • 如此反复,直到"#"位置
  3. 输出3栈的栈顶(也就这一个元素)即可完成计算

具体的代码有点多了,大家想看就看看吧...

#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cstdio>
using namespace std;
#define MaxSize 100
#define ADD 10
#define M 20 
typedef struct Stack{
	char *base;
	char *top;
	int Size;
}SqStack;

typedef struct stack{
	int *base;
	int *top;
	int Size;
}intStack;


//创建一个空的栈1,2
void InitStack(SqStack &S){
	S.base = (char *)malloc(MaxSize*sizeof(char));//开辟空间 
	if(!S.base) cout << "创建失败\n";
	S.top = S.base; //栈空的条件 
	S.Size = MaxSize;
	cout << "空栈创建成功\n";
} 
//创建一个空的栈3
void Initstack(intStack &S){
	S.base = (int *)malloc(MaxSize*sizeof(int));//开辟空间 
	if(!S.base) cout << "创建失败\n";
	S.top = S.base; //栈空的条件 
	S.Size = MaxSize;
	cout << "空栈创建成功\n";
} 

//进栈 1,2
void Push(SqStack &S,char e){
	if((S.top-S.base) >=MaxSize){
		S.base = (char *)malloc((MaxSize+ADD)*sizeof(char));
	    if(!S.base) cout << "创建失败\n";
	    S.top = S.base+MaxSize; 
	    S.Size = S.Size+ADD;
	}else{
		*S.top++ = e;			
	}
}

//进栈 3
void push(intStack &S,int e){
	if((S.top-S.base) >=MaxSize){
		S.base = (int *)malloc((MaxSize+ADD)*sizeof(int));
	    if(!S.base) cout << "创建失败\n";
	    S.top = S.base+MaxSize; 
	    S.Size = S.Size+ADD;
	}else{
		*S.top++ = e;			
	}
}

//出栈1,2 
char Pop(SqStack &S){
	char e;
	if(S.top == S.base) cout << "栈空";
	e = *--S.top;
	return e;
} 

//出栈3
int pop(intStack &S){
	char e;
	if(S.top == S.base) cout << "栈空";
	e = *--S.top;
	return e;
} 

//判断优先级 
           //进栈  栈顶 
int judge(char a,char b){
	if(a == '*'||a == '/'){
		if(b == '*'||b == '/') return 1; 
		if(b == '+'||b == '-') return 2;     //>进 	
	}
	
	if(a == '+'||a == '-'){
		if(b == '*'||b == '/') return 3; 
		if(b == '+'||b == '-') return 1; 
	}
	
	if(a == '*'||a == '/'||a == '+'||a == '-'){
		if(b == '#') return 2;           //进 
		if(b == '(') return 2;           //进 
	} 
}


/*---------------------------------------------------------------------------------------------*/

//中缀转后缀的函数 
void zhuanhou(char *a,SqStack &S1,SqStack &S2){
	char b;
	int p = 0; 
	for(int i = 0;i < strlen(a);i++){//遍历 
		if(S1.base == S1.top){Push(S1,a[i]);} //S1空直接进 
		else{
			//()和操作数的操作 
			if(a[i] == '(') {Push(S2,a[i]); }  //(:直接进 
		    if(a[i]!= '*'&&a[i]!= '+'&&a[i]!= '-'&&a[i]!= '/'&&a[i]!= '('&&a[i]!= ')'&&a[i] != '#') {Push(S1,a[i]);} //操作数直接进 
			if(a[i] == ')'){           //):让(之前的运算符依次出2栈,进1栈 
				while(*(S2.top-1) !='('){
					b = Pop(S2);
					Push(S1,b);
				}
				Pop(S2); //2栈出(
			}
			
			//运算符的操作 
			if(a[i]== '*'||a[i]== '+'||a[i]== '-'||a[i]== '/'){  
				p = judge(a[i],*(S2.top-1));//判断操作数的关系 
				if(p == 2) {Push(S2,a[i]); } 
				else{
					while(p != 2){       //非进2栈的处理 
						b = Pop(S2);
						Push(S1,b);
						p = judge(a[i],*(S2.top-1));
					}
					Push(S2,a[i]);
				}
			} 
			//表达式遍历完成额操作 
			if(a[i] =='#'){          
				while((*(S2.top-1) != '#')){
					b = Pop(S2); 
					Push(S1,b);
			    } 	
			}
		
		}
		
//	cout << "S1:";                                 //判断流程 
//	cout << *(S1.top-1) << "\n";
//	cout << "S2:";
//	cout << *(S2.top-1) << "\n";
	}
}

/*---------------------------------------------------------------------------------------------*/
 
//计算后缀式
void jisuan(SqStack &S1,intStack &S3){
	char a;
	int b;
	int d;
	int  c;
	for(int i = 0;S1.base != S1.top-i;i++){//遍历1栈
		if(*(S1.base+i)!= '*'&&*(S1.base+i)!= '+'&&*(S1.base+i)!= '-'&&*(S1.base+i)!= '/') {
			a = *(S1.base+i);
		    push(S3,(int)a-48);
		}
		if(*(S1.base+i)== '*'||*(S1.base+i)== '+'||*(S1.base+i)== '-'||*(S1.base+i)== '/'){
			b = pop(S3);
			d = pop(S3);
			if(*(S1.base+i)== '*'){c = (d)*(b);}
			if(*(S1.base+i)== '+'){c = (d)+(b);}
			if(*(S1.base+i)== '-'){c = (d)-(b);}
			if(*(S1.base+i)== '/'){c = (d)/(b);}
			push(S3,c);
		}
	}
} 

//输出栈(栈底到栈顶)
void Get(SqStack &S){
	for(int i = 0;S.base != S.top-i;i++){
		cout << *(S.base+i);
	}	
} 

//输出栈3
void get(intStack &S){
	for(int i = 1;S.base != S.top-i+1;i++){
		cout << *(S.top-i);
	}	
} 

int main(){
	cout << "注:本程序只能计算最大位数为9的表达式,且,仅仅支持加减乘除以及小括号的的操作\n"; 
	cout << "\n"; 
	cout << "请输入要计算的表达式:";
	char a[M];
	gets(a);         //获取表达式 
	//建立3个栈 
	SqStack S1;
	cout <<"后缀式"; 
	InitStack(S1);

	SqStack S2;
	cout << "运算符";
	InitStack(S2);
	Push(S2,'#');
	 
	intStack S3;
	cout << "操作"; 
	Initstack(S3);
	cout << "\n";
	//转换、计算和输出 
	zhuanhou(a,S1,S2);
	cout << "后缀式为:";
	Get(S1);    //获得后缀式 
	cout << "\n";
	jisuan(S1,S3);
	cout << "您输入的表达式的结果为:";
	get(S3);  //输出结果 
	return 0;
} 

三、队列

1.队列的基本操作和规则

a.入队和出队

先进先出(和我们排队买票一样)

  • 入队:将要入队的元素添加到队尾,将其设置为新的队尾
  • 出队:将队头的元素移出,并将队头更新

b.队列的类型

  • 链队列:和之前的链表差不多,下面是出入链队的图解

image

  • 顺序队列(一般循环):因为不循环的话可能会出现假满的情况,使用循环就不会出现,只需要浪费一个单元存放队尾指针即可判断队列满的条件

假满:如图,在队头更新时,会余下队头之前的单位,让队列还有位置,但是显示已满

image

c.循环队列的一些基本操作

//是否为满
(Q.rear+1)%MaxSize == Q.front //循环要出一圈的数取余的

/*类型自己转换吧*/
//栈的基本结构    
typedef struct{
	int *base;
	int front;
	int rear;
}SqQueue;

//创建一个空循环队列
void InitQueue(SqQueue &Q){
	Q.base = (int*)malloc(MaxSize*sizeof(int));
	if(!Q.base) cout << "创建失败";
	Q.front = Q.rear = 0;//类似于数组
	cout << "创建成功\n"; 
}

//插入队列(队尾插入)
void EnQueue(SqQueue &Q,int e){
	if((Q.rear+1)%MaxSize == Q.front%MaxSize) cout << "队列已满";
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear+1)%MaxSize;//要相对位置
}

//移出队列(队头移出)
int DeQueue(SqQueue &Q){
	int e;
	e = Q.base[Q.front];
	Q.front = (Q.front +1)%MaxSize;
	return e;
} 

//输出队列 
void Get(SqQueue &Q){
	for(int i = 0;Q.front+i < Q.rear;i++){
		cout << Q.base[Q.front+i];
	}
} 
    

2.队列的案例分析

打印杨辉三角(二项式系数)

思路:在每一行的首尾都虚出一个0用来计算和判断换行 ,从一行开始,每一行的值都是上一行该位值与其前一个值的相加

  1. 使用一个temp用来存放每行一开始的0和前一个值,使用front来存放已经出队的值和判读是否换行的0
  2. 现入队第一行 1 1 0
  3. 出队1次,与temp相加后再入队 101 ,让temp = front
  4. 判断front是否为0,为0换行,不为零输出front
  5. 出队一次,重复第3、4步 0 1 2 -> 1 2 1(第二行),此时的front = 0换行
  6. 再次重复第3 、4 、5补即可

代码

#include<iostream>
#include<cstdlib>
#define MaxSize 100
using namespace std;

typedef struct{
	int *base;
	int front;
	int rear;
}SqQueue;

//创建一个空循环队列
void InitQueue(SqQueue &Q){
	Q.base = (int*)malloc(MaxSize*sizeof(int));
	if(!Q.base) cout << "创建失败";
	Q.front = Q.rear = 0;
	cout << "创建成功\n"; 
}

//插入队列(队尾插入)
void EnQueue(SqQueue &Q,int e){
	if((Q.rear+1)%MaxSize == Q.front%MaxSize) cout << "队列已满";
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear+1)%MaxSize;
}

//移出队列(队头移出)
int DeQueue(SqQueue &Q){
	int e;
	e = Q.base[Q.front];
	Q.front = (Q.front +1)%MaxSize;
	return e;
} 

int main(){
	int line ; 
	cout << "请输入打印杨辉三角的行数:";
	cin >> line;
	int front;
	int temp = 0;
	int jieshou;
	
	SqQueue Q;
	InitQueue(Q);
	//先入队第一行
	EnQueue(Q,1);
	EnQueue(Q,1);
	EnQueue(Q,0);
	for(int i = 1;i <= line;){
		 //第一行出队并与前一相加入队 
		 front = DeQueue(Q);
		 EnQueue(Q,temp+front);
		 //判断输出和换行的
		 if(front != 0) {cout << front << " ";}
		 else{
		 	cout <<endl;
		 	EnQueue(Q,0);
		 	i++;//换行 
		 }
		 temp = front;//让temp始终是要出队数的前一个数 
		 //cout << endl;
	}
	return 0;
}

四、小结

四个结构的指针存放位置

顺序栈

image

链栈

image

链队列

image

循环队列

image

标签:运算符,队列,基础,char,int,MaxSize,base,数据结构
From: https://www.cnblogs.com/wht-de-bk/p/16774069.html

相关文章