【数据结构】第三章 限定性线性表---栈与队列

1.栈

后进先出
栈顶：线性表允许进行插入、删除的一端
栈底：不允许插入、删除的一端（固定的）

1.1栈的顺序存储结构

类型描述：

#define MaxSize 50
typedef struct{
	ElemType data[MaxSize];
	int top;
}SqStack;

注：

1. 栈顶指针 $s.top$ 初始值为$s.top=-1$
2. 栈空条件：$s.top=-1$
3. 栈满条件：$s.top==MaxSize-1$
4. 栈长：$s.top+1$

1.1.1基本运算

1. 初始化：

void InitStack(SqStack *S){
	S->top=-1;
}

2. 判空：

int StackEmpty(SqStack *S){
	if(S->top == -1){return 1;}
	else {return 0;
}

3. 进栈：

int Push(SqStack *S, ElemType x){
	if(S->top==MaxSize-1) return 0;
	S->top++;
	S->data[S->top]=x;
	return 1;
}

注：

先判断是否栈满，指针先 +1 再入栈

4. 出栈

int Pop(SqStack *S, ElemType *x){
	if(S->top==-1) return 0;
	*x=S->data[S->top];
	S->top--;
	return 1;
}

注：

先判断是否栈空，先出栈，指针再 -1

5. 读栈顶元素：

int GetTop(SqStack *S, ElemType *x){
	if(S->top==-1) return 0;
	*x=S->elem[S->top];
	return 1;
}

1.1.2 共享栈

利用栈底位置相对不变的特性，可让两个顺序栈共享一个一维数据空间，将两个栈的栈底分别设置在共享空间的两端，两个栈顶向共享空间的中间延伸.
注：

1. 栈空：0号栈为空：$top0=-1$，1号栈为空：$top1=MaxSize$
2. 判断栈满：$top1-top0=1$
3. 进栈：0号栈先+1，再赋值。1号栈先-1，再赋值
4. 存取数据的时间复杂度$O(1)$

1.2栈的链式存储结构

操作都在单链表表头进行，链栈没有头节点
类型描述：

typedef struct Linknode{
	Elemtype data;
	struct Linknode *next;
}*LiStack;

注：

1. 对于$n$个不同元素进栈，出栈序列个数为：$\frac{1}{n+1}{C}_{2n}^n=\frac{1}{n+1}\ast \frac{(2n)!}{n!\ast n!}$
2. 采用非递归方式重写递归程序时必须使用栈
   错误（计算斐波拉契数列迭代实现只需要一个循环即可实现。）

2. 队列

先进先出，受限的线性表
不可以随便读取队列中的某个数据

2.1 队列的顺序存储结构

2.1.1 类型描述：

#define MaxSize 50
typedef struct{
	Elemtype data[MaxSize];
	int front;
	int reat;
}SqQueue;

注：

1. 队头指针指向队头元素，队尾指针指向队尾元素下一位置
2. 初始状态（队空条件）：$Q.front==Q.rear==0$
3. $Q.rear==MaxSize$不能作为队满条件（假溢出）

2.1.2 循环队列

1. 初始时：$Q.front=Q.rear=0$
2. 队首指针进1：$Q.front=(Q.front+1)\%MaxSize$
3. 队尾指针进1：$Q.rear=(Q.rear+1)\%MaxSize$
4. 队列长度：$(Q.rear+MaxSize-Q.front)\%MaxSize$

判断队满的3种方式：

1. 牺牲一个单元来区分队空队满：队头指针在队尾指针的下一位置作为队满的标志
   队满条件：$(Q.rear+1)\%MaxSize==Q.front$
   队空条件：$Q.front==Q.rear$
   队列中元素个数：$(Q.rear+MaxSize-Q.front)\%MaxSize$
2. 类型中增设表示元素个数的数据成员。
   队满条件：$Q.size==MaxSize$
   队空条件：$Q.size==0$
   两种情况都有：$Q.front==Q.rear$
3. 类型中增设$tag$ 数据成员，以区分是队满还是队空。$tag=0$时，若因删除导致$Q.front==Q.rear$则为队空；$tag=1$时，若因插入导致$Q.front==Q.rear$，则为队满。

2.1.3 实现：

1. 初始化：

void InitQueue(SqQueue *Q){
	Q->rear = Q->front = 0;
}

2. 判队空

int isEmpty(SqQueue Q){
	if(Q.rear == Q.front) return 1;
	else return 0;
}

3. 入队

int EnQueue(SqQueue *Q,Elemtype x){
	if((Q->rear+1)%MaxSize == Q.front) return 0;
	Q->data[Q->rear] = x;
	Q.rear = (Q->rear+1)%MaxSize;
	return 1;

4. 出队

int DeQueue(SqQueue *Q,Elemtype *x){
	if(Q->rear == Q->front) return 0;
	x = Q->data[Q->front];
	Q->front = (Q->front+1)%MaxSize;
	return 1;

2.2 队列的链式存储结构

同时带有队头指针和队尾指针的单链表

2.2.1 类型描述：

typedef struct{
	Elemtype data;
	struct LinkNode *next;
}LinkNode;
typedef struct{
	LinkNode *front;
	LinkNode *rear;
}LinkQueue;

注：

1. $Q.front==NULL$&&$Q.rear==NULL$时，链式队列为空
2. 链式队列为带头节点的单链表，插入删除操作统一
3. 适用于数据元素变动较大的情形

2.2.2 实现：

1. 初始化

void InitQueue(LinkQueue *Q){
	Q->rear = (LinkNode*)malloc(sizeof(LinkNode));
	Q->front = Q->rear;
	Q->front->next = NULL;
}

2. 判空：

int IsEmpty(LinkQueue Q){
	if(Q->front == Q->rear) return 0;
	else return -1;
}

3. 入队：

void EnQueue(LinkQueue *Q, Elemtype x){
	LinkNode s;
	s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;
	Q->rear->next = s;
	Q->rear = s;

4. 出队：

void DeQueue(LinkQueue *Q, Elemtype *x){
	if(Q->rear == Q->front) printf("error");
	LinkNode p;
	p = Q->front->next;
	x = p->data;
	Q->front->next = p->next;
	if(Q->rear == p){
		Q->rear = Q->front;
	}
	free(p);
}