栈和队列
栈(Stack):只允许在一端进行插入或者删除操作的线性表。首先栈是一种线性表,但是限定在这种线性表中只能在某一端进行插入和删除操作。
栈顶:线性表(栈)允许进行插入和删除操作的一端。
栈底:固定的,不允许进行插入和删除操作的另一端。
空栈:不含任何元素的空表。
栈的顺序储存结构
栈的顺序储存称为顺序栈,他是利用一组地址连续的储存单元存放自栈底到栈顶的数据元素,同时附设一个指针(top)指示当前栈顶的位置。
栈的顺序储存类型可以描述为:
#define MaxSize 50 //定义栈中元素的最大个数
typedef struct
{
int data[MaxSize];
int top;
}SqStack;
栈顶指针:S.top,初始设置为S.top=-1;栈顶元素:S.data[S.top]。
进栈操作:栈不满时,栈顶指针先加1,再送值到栈顶空间。
出栈操作:栈非空的时候,先取栈顶的元素,再将栈顶指针-1.
栈空条件:S.top=-1;栈满条件:S.top==MaxSize-1;栈长S.top+1。
初始化
void InitStack(SqStack &S)
{
S.top=-1;
}
栈是否为空?
bool StackEmpty(SqStack S)
{
if(S.top==-1)
return true;
else
return false;
}
压栈操作
bool Push(SqStack &S,int x)
{
if(S.top==MaxSize-1)
return false;
S.data[++S.top]=x;// 先加 然后在赋值
return true;
}
出栈操作
bool Pop(SqStack &S,int &x)
{
if(S.top==-1)
return false;
x=S.data[S.top--];//先取值,然后再减
return true;
}
得到栈顶元素
bool GetTop(SqStack S,int &x)
{
if(S.top==-1)
return false;
x=S.data[S.top];
return true;
}
注意:这里的栈顶指针指向的就是栈顶元素,所以进栈操作是\(S.data[++S.top]=x;\),出栈操作是\(x=S.data[S.top--];\)。如果栈顶指针指向栈顶元素的下一个位置,则入栈操作变为\(S.data[S.top++]=x;\),出栈操作变为\(x=S.data[--S.top]\)。相应的栈空,栈满条件也会发生变化。
共享栈
利用栈底位置相对不变的特性,可以让两个顺序栈共享一个一位数据空间,将两个栈的栈底分别设置在共享空间的两端,两个栈顶向共享空间的中间延伸,如图所示。
两个栈的站定指针都指向栈顶元素, \(top_0=-1\)时 \(0\)号栈为空, \(top_1=MaxSize\)时 \(1\)号栈为空;
当 \(top_1-top_0=1\)时,判断栈满。当0号栈进展时 \(top_0\)先 \(+1\)然后赋值, \(1\)好战进站时 \(top_1\)先 \(-1\)再赋值;出栈刚好相反。
共享栈是为了更有效的利用储存空间,两个栈的空间互相调节,只有在整体储存空间都被栈满的时候才会发生上溢。其存取数据的时间复杂度均为 \(O(1)\),所以对存取效率没有什么影响。
栈的链式储存结构
采用链式储存的栈通常称为链栈,链栈的优点是便于多个共享储存空间和提高其效率,且不存在栈满上溢的情况。通常采用单链表实现,并规定所有操作都是在单链表的表头进行的。这里规定链栈没有头结点,Lhead指向栈顶元素。
栈的链式存储类型可以描述为
typedef struct LinkNode
{
int data;
struct LinkNode *next;
}*LiStack;
采用链式存储,便于节点的插入和删除。链栈的操作和链表类似。
注意一下卡特兰数\(\frac {1}{n+1}\ast C_n^{2n}\)。n个元素一次进栈,能得到几中不同的出栈序列。
队列
队列(Queue):简称队,是一种操作受限的线性表只允许在表的一端进行插入,而在表的另一端进行删除操作。其操作特性为:FIFO。
队头(Front):允许删除的一端,又称为队首。 队尾(Rear):允许插入的一端。
空队列:不含任何元素的空表。
队列的顺序储存结构
队列的顺序储存
队列的顺序实现是指分配一块连续的储存单元存放队列中的元素,并且辐射两个指针front和rear分别指示队头元素和队尾元素的下一个位置,对于这种设置方式,参考下方图。
队列的顺序储存类型可描述为:
#define MaxSize 50
typedef struct
{
int data[MaxSize];
int front,rear;
}SqQueue;
- 初始状态(队空条件):\(Q.front==Q.rear==0\)。
- 进队操作:队不满的时候,先送值到队尾元素,再将队尾指针\(+1\)。
出队操作:队不空的时候,先取队头元素值,再将队头指针\(+1\)。
观察一下上面的图,可以发现很尴尬的一个事情是到了(d)出队三次的时候虽然还有空间,但是已经不能继续储存了。循环队列 - 初始时:\(Q.front=Q.rear=0\)
- 队首指针进1:\(Q.front=(Q.front+1) \% MaxSize\)
- 队尾指针进1:\(Q.rear=(Q.rear+1) \% MaxSize\)
队列长度:\((Q.rear+MaxSize-Q,front)\%MaxSize\)
初始化。
void InitQueue(SqQueue &Q)
{
Q.rear=Q.front=0;
}
判队空。
bool IsEmpty(SqQueue Q)
{
if(Q.rear==Q.front)
return true;
else
return false;
}
判队满。
bool IsFull(SqQueue Q)
{
if((Q.rear+1)%MaxSize==Q.front)
return true;
else
return false;
}
出队。
bool DeQueue(SqQueue &Q,int &x)
{
if(IsEmpty(Q))
return false;
x=Q.data[Q.front];
Q.front=(Q.front+1)%MaxSize;
return true;
}
入队。
bool InQueue(SqQueue &Q,int x)
{
if(IsFull(Q))
return false;
Q.data[Q.rear]=x;
Q.rear=(Q.rear+1)%MaxSize;
return true;
}
队列的链式存储结构
队列的链式存储:队列链式表示称为链队列,它实际上是一个同时带有队头指针和队尾指针的单链表,尾指针指向队尾节点,即单链表的最后一个结点(注意与顺序存储的不同)。
队列的链式存储可描述为
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else /* __cplusplus */
#define NULL ((void *)0)
#endif /* __cplusplus */
#endif /* NULL */
typedef struct LinkNode // 搞一个单链表
{
int data;
struct LinkNode *next;
};
typedef struct LinkQueue// 搞一个包含两个单链表类型的指针。
{
LinkNode *front,*rear;
};
初始化
void InitQueue(LinkQueue &Q)
{
Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
Q.front->next=NULL;
}
判断队空
bool IsEmpty(LinkQueue Q)
{
if(Q.front==Q.rear)
return true;
else
return false;
}
入队
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;
}
出队
int DeQueue(LinkQueue &Q,int &x)
{
if(Q.rear==Q.front->next) // 如果删除的是最后一个节点,也就是Q.rear指向的节点。
Q.rear=Q.front; // Q.rear 和 Q.front的值 应该相同。这样就空了。
else
if(Q.front==Q.rear)
return false;
x=Q.front->next->data;
Q.front->next=Q.front->next->next; // 删除该节点
return true;
}
链式队列:初始化的时候front和rear是指向同一个位置的也就是指向头结点,这个时候的状态就是队空,front永远指向头指针,rear指向最后一个元素的位置。
@[括号匹配]
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 50
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else /* __cplusplus */
#define NULL ((void *)0)
#endif /* __cplusplus */
#endif /* NULL */
#define MaxSize 50 //定义栈中元素的最大个数
typedef struct
{
char data[MaxSize];
int top;
}SqStack;
void InitStack(SqStack &S)
{
S.top=-1;
}
bool StackEmpty(SqStack S)
{
if(S.top==-1)
return true;
else
return false;
}
bool Push(SqStack &S,char x)
{
if(S.top==MaxSize-1)
return false;
S.data[++S.top]=x;// 先加 然后在赋值
return true;
}
bool Pop(SqStack &S,char &x)
{
if(S.top==-1)
return false;
x=S.data[S.top--];//先取值,然后再减
return true;
}
bool GetTop(SqStack S,char &x)
{
if(S.top==-1)
return false;
x=S.data[S.top];
return true;
}
int main()
{
char fu;
SqStack S;
InitStack(S);
while(scanf("%c",&fu)!=EOF)
{
if(fu=='\n')
break;
if(StackEmpty(S))
{
Push(S,fu);
continue;
}
else
{
char pi,temp;
GetTop(S,pi);
if(fu==')'||fu==']')
{
if(pi=='['&&fu==']')
Pop(S,temp);
if(pi=='('&&fu==')')
Pop(S,temp);
}
else
Push(S,fu);
}
}
if(StackEmpty(S))
printf("匹配成功\n");
else
printf("匹配失败\n");
return 0;
}