zcy
/
csdn_spider
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
csdn_spider/blog/ds19991999/原创-- 第三章 栈和队列.md

451 lines
8.0 KiB
Markdown
Raw Normal View History

:bug::hammer::new:
2021-02-27 15:01:45 +00:00
# 原创
： 第三章 栈和队列
# 第三章 栈和队列
# 一、基本概念
栈：先进先出，顺序栈和链式栈，本质上是线性表 <br/> 队列：先进后出，一种操作受限的线性表
# 二、结构体定义
```
//1.顺序栈定义
typedef struct
{
int date[maxSize];
int top;
}SqStack;
//2.链栈结点定义
typedef struct LNode
{
int date;
struct LNode *next;
}LNode;
//3.顺序队列定义
typedef struct
{
int date[maxSize];
int front;
int rear;
}SqQueue;
//4.链队定义
//队结点类型定义
typedef struct QNode
{
int date;
struct QNode *next;
}QNode;
//链队类型定义
typedef struct
{
QNode *front;
QNode *rear;
}LiNode;
```
# 三、顺序栈
```
//1.顺序栈要素
st.top==-1; //栈空
st.top==maxSize-1; //栈满
//还有一种就是上溢和下溢
//2.两个操作
st.date[++(st.top)]=x; //进栈
x=st.date[(st.top)--]; //出栈
//3.初始化栈
void initStack(SqStack &amp;st)
{
st.top=-1;
}
//4.判断栈空
int isEmpty(SqStack st)
{
if(st.top==-1)return -1;
else return 0;
}
//5.进栈
int push(SqStack &amp;st, int x)
{
if(st.top==maxSize-1)return 0;
st.date[++(st.top)]=x;
return 1;
}
//6.出栈
int pop(SqStack &amp;st, int &amp;x)
{
if(st.top==-1)return 0;
x=st.date[st.top--];
return 1;
}
//比较实用的写法
int stack[maxSize];int top=-1;
stack[++top]=x;
x=stack[top--];
```
# 四、链栈
```
//1.要素
//两个状态
lst-&gt;next==NULL; //栈空
//栈满，除非内存耗尽
//两个操作
p-&gt;next=lst-&gt;next;lst-&gt;next=p; //进栈
p=lst-&gt;next;x=p-&gt;date;lst-&gt;next=p-&gt;next;free(p);//出栈
//2.链栈的初始化代码
void initStack(LNode *&amp;lst)\
{
lst=(LNode*)malloc(sizeof(LNode));
lst-&gt;next=NULL;
}
//3.判断栈空代码
int isEmpty(LNode *lst)
{
if(lst-&gt;next==NULL)return 1;
else return 0;
}
//4.进栈
void push(LNode *lst, int x)
{
LNode *p;
p=(LNode)malloc(sizeof(LNode));
p-&gt;next=NULL;
p-&gt;date=x;
p-&gt;next=lst-&gt;next;
lst-&gt;next=p;
}
//5.出栈
void pop(LNode *lst, int *&amp;x)
{
LNode *p;
if(lst-&gt;next==NULL)return 0;
p=lst-&gt;next;
x=p-&gt;date;
lst-&gt;next=lst-&gt;next-&gt;next;
free(p);
return 1;
}
```
# 五、栈的应用
```
//1.算法：判断一个表达式的括号是否配对
int match(char exp[], int n)
{
char stack[maxSize];int top=-1; //顺序栈的定义和初始化
int i;
for(i=0;i&lt;n;++i)
{
if(exp[i]=='(')stack[++top]='(';
if(exp[i]==')')
{
if(top==-1)return 0;
else top--;
}
}
if(top==-1) return 1;
else return 0;
}
//2.算法：求后缀式表达式数值
//中缀式：（a+b+c*d）/e;
//前缀式：/++ab*cde;
//后缀式：abcd*++e/
int op(int a, char Op, int b)
{
if(Op=='+')return a+b;
if(Op=='-')return a-b;
if(Op=='*')return a*b;
if(Op=='/')
{
if(b==0)
{
cout&lt;&lt;"ERROR";
return 0;
}
else return a/b;
}
}
int com(char exp[])
{
int i,a,b,c; //其中a,b为操作数，c保存结果
int stack[maxSize];int top=-1;
char Op;
for(i=0;exp[i]!='\0';++i)
{
//注意字符型和整型的转换
if(exp[i]&gt;='0'&amp;&amp;exp[i]&lt;='9')stack[++top]=exp[i]-'0';
else
{
Op=exp[i];
b=stack[top--];//先取第二个操作数
a=stack[top--];
c=op(a,Op,b);
stack[++top]=c;
}
}
return stack[top];
}
//3.不带头结点的单链表存储链栈
void initStack(LNode *&amp;lst)
{
lst==NULL;
}
int isEmpltyl(LNode *lst)
{
if(lst==NUll)return 1;
else return 0;
}
void push(LNode *&amp;lst, int x)
{
LNodde *p;
p=(LNode*)malloc(sizeof(LNode));
p-&gt;next=NULL;
p-&gt;date=x;
//lst不带头结点
p-&gt;next=lst-&gt;next;
lst=p;
}
int pop(LNode *&amp;lst, int &amp;x)
{
LNode *p;
if(lst==NULL)return 0;
p=lst;
x=p-&gt;date;
lst=p-&gt;next;
free(p);
return 1;
}
```
# 六、顺序队
```
//1.四个要素
qu.rear==qu.front; //队空
(qu.rear+1)%maxSize==qu.front; //队满
qu.rear=(qu.rear+1)%maxSize;qu.date[qu.rear]=x; //进队，移动队尾指针
qu.front=(qu.rear+1)%maxSize;x=qu.date[qu.front]; //出队，移动队首指针
//2.初始化队列
void initStack(SqQueue qu)
{
qu.front=qu.rear=0
}
//3.判断队空
int isQueueEmpty(SqQueue qu)
{
if(qu.rear==qu.front)return 1;
else return 0;
}
//4.进队
int enQueue(SqQueue &amp;qu, int x)
{
//队满不能进队
if((qu.rear+1)%maxSize==qu.front)return 0;
qu.rear=(qu.rear+1)%maxSize;
qu.date=x;
return 1;
}
//5.出队
int deQueue(SqQueue &amp;qu, int &amp;x)
{
if(qu.front==qu.rear)return 0;
qu.front=(qu.front+1)%maxSize;
x=qu.date[qu.front];
return 1;
}
```
# 七、链队
```
//1.要素
lqu-&gt;rear==NULL||lqu-&gt;front==NULL; //队空
//不存在队满
lqu-&gt;rear-&gt;next=p;lqu-&gt;rear=p; //进队
p=lqu-&gt;front;lqu-&gt;front=p-&gt;next;x=p-&gt;date;free(p); //出队
//2.初始化链队
void initQueue(LiQueue *&amp;lqu)
{
lqu=(LiQueue*)malloc(sizeof(LiQueue));
lqu-&gt;front=lqu-&gt;rear=NULL;
}
//3.判断队空
init isQueueEmpty(LiQueue *lqu)
{
if(lqu-&gt;rear==NULL||lqu-&gt;front==NULL)return 1;
else return 0;
}
//4.入队
void enQueue(LiQueue *lqu, int x)
{
QNode *p;
p=(QNode*)malloc(sizeof(QNode));
p-&gt;date=x;
p-&gt;next=NULL;
if(lqu-&gt;rear==NULL)lqu-&gt;front=lqu-&gt;rear=p;
else
{
lqu-&gt;rear-&gt;next=p;
lqu-&gt;rear=p;
}
}
//5.出队
int deQueue(LiQueue *lqu, int &amp;x)
{
QNode *p;
if(lqu-&gt;rear==NULL)return 0;
else p=lqu-&gt;front;
if(lqu-&gt;front==lqu-&gt;rear)lqu-&gt;front=lqu-&gt;rear=NULL;
else lqu-&gt;front=lqu-&gt;front-&gt;next;
x=p-&gt;date;
free(p);
return 1;
}
```
# 八、实例
```
//1.共享栈s0、s1的相关操作，共享elem[0,1,...,maxSize-1]
//结构体定义
typedef struct
{
int elem[maxSize];
int top[2];
}SqStack;
//入栈
int push(SqStack &amp;st, int stNo, int x)
{
if(st.top[0]+1&lt;st.top[1])
{
if(stNo==0)
{
++(st.top[0]);
st.elem[st.top[0]]=x;
return 1;
}
else if(stNo==1)
{
--(st.top[1]);
st.elem[st.top[1]]=x;
return 1;
}
else return -1;
}
else return 0;
}
//出栈
int pop(SqStack &amp;st, int dtNo, int &amp;x)
{
if(stNo==0)
{
if(st.top[0]!=-1)
{
x=st.elem[st.top[0]];
--(st.top[0]);
return 1;
}
else return 0;
}
else if(stNo==1)
{
if(st.top[1]!=maxSize)
{
x=st.elem[st.top];
++(st.top[1]);
return 1;
}
else return 0;
}
else return -1;
}
//2.用两个栈s1和s2模拟一个队列
//入栈
int enQueue(SqStack &amp;s1,SqStack &amp;s2,int x)
{
int y;
if(s1.top==maxSize-1)
{
if(!isEmpty(s2))return 0;
else if(isEmpty(s2))
{
while(!siEmpty(s1))
{
//s1中元素出栈，进入s2中
pop(s1,y);
push(s2,y);
}
push(s1,x);
return 1;
}
}
else
{
push(s1,x);
return 1;
}
}
//s2退栈，实现出队
int deQueue(SqStack &amp;s2, SqStack &amp;s1, int &amp;x)
{
int y;
if(!isEmpty(s2))
{
pop(s2,x);
return 1;
}
else
{
if(isEmpty(s1))return 0;
else
{
while(!isEmpty(s1))
{
pop(s1,y);
push(s2,y);
}
pop(s2,x);
return 1;
}
}
}
//判断栈s1和s2模拟的队列是否为空
int isQueueEmpty(SqStack s1,SqStack s2)
{
if(isEmpty(s1)&amp;&amp;isEmpty(s2))return 1;
else return 0;
}
```