栈和队列

二、栈和队列

栈的应用：
数制转换、括号匹配、行编辑程序、迷宫求解、表达式求值、八皇后问题、函数调用、递归调用的实现

队列的应用：
1、脱机打印输出

2、多用户系统用户排队分时循环使用CPU和主存

3、按用户优先级排队，每个优先级一个队列

4、实时控制系统，信号按接受顺序依次处理

5、网络电文传输，按到达的时间先后顺序依次进行

2.1 栈

1.定义及特点

限定只能在表的一端进行插入和删除运算的线性表（只能在栈顶操作），后进先出(Last In First Out)，简称LIFO

表尾叫栈顶 Top
表头叫栈底 Base 或 Bottom

存储结构：顺序栈或链栈，以顺序栈更为常见

栈通常用 S 表示（stack）
插入元素到栈顶，称为入栈或压栈 PUSH(x)
从栈顶删除最后一个元素，称为出栈或弹栈 POP(x)

2.1.1 顺序栈的表示与操作实现

首先设top指针指向栈顶元素之上的下标地址

另设base指针，指向栈底元素的位置

另外可以用stacksize表示栈可以使用的最大容量

顺序栈的操作：
base == top是栈空的表现

栈满了top - base == stacksize

栈满还加元素的处理方法：
1.报错，返回操作系统（√）
2.分配更大空间（麻烦）

上溢（overflow）：栈满还要加元素
下溢（underflow）：栈空了还要弹出元素

注：上溢是一种错误，使问题的处理无法进行，但是下溢一般认为是一种结束条件，即问题处理结束

#define MAXSIZE 100
#define OVERFLOW -2
#define OK 1
#define ERROR 0
typedef struct {
    SElemType *base;//栈底指针
    SElemType *top; //栈顶指针
    int stacksize;  //栈可用的最大容量
} SqStack;

算法1：顺序栈的初始化
Status InitStack(SqStack &S) {	//构造空栈 
    S.base = new SElemType[MAXSIZE];//栈底指针指向一片连续的空间
    //或S.base = (SElemType*)malloc(MAXSIZE*sizeof(SElemType));
    if (!S.base) exit (OVERFLOW);//空间分配失败
    //注：exit函数的头文件在#include <stdlib.h>中
    S.top = S.base;//栈顶指针等于栈底指针（指向栈底）
    S.stacksize = MAXSIZE;//stacksize是栈的最大容量
    return OK;
}

算法2：判断顺序栈是否为空
Status StackEmpty(SqStack S) {
    //若栈为空,返回TRUE;否则返回 FALSE 
	if (S.top == S.base) return TRUE;//top指针和base重合
	else return FALSE;
} 
 
算法3：求栈的长度
int StackLength(SqStack S) {
    return S.top - S.base;
}
 
算法4：清空顺序栈
Status ClearStack(SqStack &S) {//不一定要把内存置为空，只要把它当成空就行
    if (S.base) //前提是栈要存在
    S.top = S.base;//逻辑清空
    return OK;
}
 
算法5：销毁顺序栈
Status DestroyStack( SqStack &S) {
    if (S.base) {
        delete S.base; 
//delete释放了内存空间，但是没有销毁指针，base指针成了野指针，所以还需要指向空
		S.stacksize = 0; 
		S.base = S.top = NULL;
    }
	return OK. 
}

算法6：顺序栈的入栈
Status Push(SqStack &S, SElemType e) {
    if (S.top - S.base == S.stacksize) return ERROR;//栈满了加不了了
    *S.top = e;
    ++S.top; 
    return OK;
}

算法7：顺序栈的出栈
Status Pop(SqStack &S, SElemType &e) {
    //若栈非空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
    if (S.top == S.base) return ERROR;//等价于if (StackEmpty(S))
    --S.top;
    e = *S.top;
    return OK;
}

2.1.2 链栈的表示与操作实现

链栈是单链表，只能在链表头部操作

1、链表的头指针即是栈顶
2、不需要头结点
3、基本不存在栈满情况，内存不受限
4、空栈相当于头指针指向空
5、插入和删除仅在栈顶处执行

链栈的结构体类型：
typedef struct StackNode {
    SElemType data;
    struct StackNode *next;
} StackNode, *LinkStack;
LinkStack S;//初始化头指针
 
算法1：链栈的初始化
Status InitStack(LinkStack &S) {
    S = NULL; //构造一个空栈，栈顶指针置为空
    return OK;
}
 
算法2：判断链栈是否为空
Status StackEmpty(LinkStack S) {
    if (S == NULL) return TRUE;
	else return FALSE;
}
 
算法3：链栈的入栈
Status Push(LinkStack &S, SElemType e) {
    p = new StackNode;//生成新结点p 
	p->data = e;//将新结点数据域置为e 
	p->next = S;//将新结点插入栈顶 
	S = p;//修改栈顶指针 
	return OK;
}
 
//链栈的出栈
Status Pop(LinkStack &S, SElemType &e) {
    if (S == NULL) return ERROR;//空栈，无法再出栈 
	e = S->data; 
    LinkStack p = S;
	S = S->next; 
	delete p;//不需要将p置为空来避免野指针，因为p是局部变量，推出该函数时就销毁
	return OK;
} 
 
//取栈顶元素
SElemType GetTop(LinkStack S){
    if (S != NULL) return S->data;
    else return ERROR;
}

2.2 队列

1.定义及特点

只能在表尾进行插入（队尾），在表头进行删除运算（队头）的线性表，先进先出（First In First Out），简称FIFO.
只能在队头和队尾运算（头删尾插）。

队列通常用Q表示（queue）
存储结构：顺序队或链队，以循环顺序队列更常见

2.2.1 顺序队

//队列顺序表结构类型(循环队列)
#define MAXSIZE 100	//最大队列长度
typedef struct {
    QElemType *base;//初始化的动态分配存储空间,数组基地址
    int front;	//头指针（队头的下标，并非真正的指针）
    int rear;	//尾指针（队尾的下标，~）
} SqQueue;
 
//由于每一次出队都会使头指针后移，但是内存中的数据不会像我们排队一样前面空了自动填空，就会出现假溢出的现象，一种解决方法就是当rear指向maxqsize的时候，又可以从表头使用空着的空间，当front为maxqsize也是如此，这里充分利用mol运算，就可以让越界的指针回到前面，好像把maxqsize位置接在0处，和0位置重合
 
front == rear既表示队空又表示队满，解决方法有两种：
1.另外设一个标志，用来分别标记队空和队满
2.另设一个变量标记元素个数
3.少用一个元素空间(最常用)	(rear+1) % MAXQSIZE == front 队满
 
1、队列初始化
Status InitQueue(SqQueue &Q) {
    Q.base = new QElemType[MAXQSIZE];//分配数组空间
    if (!Q.base) exit(OVERFLOW);	//存储分配失败
    Q.front = Q.rear = 0;	//头指针尾指针置为0，队列为空
    return OK;
}
 
2、求队列长度
int QueueLength(SqQueue Q) {
    return (MAXQSIZE + Q.rear - Q.front) % MAXQSIZE;	
    //相当于把rear接到MAXQSIZE位置后面继续计算，这时候把环拆开了
    //用于“少用一个元素空间”的情况
}
 
3、循环队列入队
Status EnQueue(SqQueue &Q, QElemType e) {
    if ((Q.rear+1) % MAXQSIZE == Q.front) return ERROR;//队满 
	Q.base[Q.rear] = e; //新元素加入队尾
	Q.rear = (Q.rear+1) % MAXQSIZE; //队尾指针+1 
	return OK;
}
 
4、循环队列出队
Status DeQueue(SqQueue &Q, QElemType &e) {
    if (Q.front == Q.rear) return ERROR;//队空 
	e = Q.base[Q.front]; //保存队头元素 
	Q.front = (Q.front+1) % MAXQSIZE;//队头指针+1 
	return OK; 
}
 
5、取队头指针
SElemType GetHead(SqQueue Q) {
    if (Q.front != Q.rear)//队列不为空 
		return Q.base[Q.front];//返回队头指针元素的值,队头指针不变 
   		else return ERROR;
} 

补充：利用方法1（另外设一个标志，用来分别标记队空和队满）来实现入队/出队的算法：

typedef struct {
	Elemtype *base;
	int front,rear,tag;
}SqQueue;

//构造一个空队列 
Status InitQueue(SqQueue &Q){
	Q.base = new QElemtype[M];
	if (!Q.base) exit (OVERFLOW);//存储分配失败 
	Q.front = Q.rear = 0;//头尾指针置为0，队列为空 
	Q.tag = 0;//标志初始化为0，队列为空 
	return OK;
}

//入队
Status EnQueue(SqQueue &Q, QElemtype e){
	if ((Q.tag == 1) && (Q.front == Q.rear)) return ERROR; 
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % M;
	Q.tag = 1;//标志改1，表示队列非空 
	return OK;
} 

//出队
Status DeQueue(SqQueue &Q, QElemtype &e){
	if ((Q.tag == 0) && (Q.front == Q.rear)) return ERROR;
	e = Q.base[Q.front];
	Q.front = (Q.front + 1) % M;
	Q.tag = 0;//标志改0，表示队列非满 
	return OK;
} 

2.2.1 链队

//队列结点类型
typedef struct Qnode {	
    QElemType data;
    struct Qnode *next;
} QNode, *QueuePtr;
 
//链队列类型，里面包含了头尾指针
typedef struct { 
    QueuePtr front; //队头指针
    QueuePtr rear;  //队尾指针
} LinkQueue;
 
1、链队列的初始化（构造一个空队列）
Status InitQueue(LinkQueue &Q) {
    Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode)); 
	if (!Q.front) exit(OVERFLOW); 
	Q.front->next = NULL; 
	return OK;
}
 
2、链队列的销毁
Status DestroyQueue(LinkQueue &Q) {
    while(Q.front) {//表头非空表示还有元素
        //p=Q.front->next; free(Q.front); Q.front=p;
        Q.rear = Q.front->next; 
        free (Q.front); 
        Q.front = Q.rear;
    } //用p保存下一结点地址，然后销毁表头结点，表头结点指向p
    //反正rear指针没用用rear代替p刚刚好
	return OK;
} 
 
3、入队
Status EnQueue(LinkQueue &Q, QElemType e) {
	QueuePtr p=(QueuePtr)malloc(sizeof(QNode)); 
	if(!p) exit(OVERFLOW); 
	p->data = e; p->next = NULL; 
	Q.rear->next = p; //入队
	Q.rear = p; //队尾元素更改，尾指针修改为指向队尾元素
	return OK;     
} 
 
4、出队
Status DeQueue(LinkQueue &Q, QElemType &e) {
    if (Q.front == Q.rear) return ERROR;//队列为空，无法再出队 
	QueuePtr p = Q.front->next; 
	e = p->data; 
	Q.front->next = p->next; 
	if(Q.rear == p) Q.rear = Q.front;
    //如果尾指针指向的就是头结点的下一节点，就是说所有元素删完了，要把头尾指针都指向头指针（此时p->next为NULL）
	delete p;
	return OK; 
}
 
5、求链队列中的队头元素
Status GetHead(LinkQueue Q, QElemType &e) {
    if (Q.front == Q.rear) return ERROR;//若队空，则无队头元素
	e = Q.front->next->data;
    return OK;
}

案例引入

1、进制转换
把十进制159转换为八进制，倒序取余数可以用栈来进行

2、括号匹配
假设有两种括号（）[]

它们的嵌套顺序任意，即是：

1.() 或者[([][])] 是正确格式；

2.[(]) 为错错误格式;

3.([()) 或 (()]) 是错误格式。

利用栈的特点将左括号和右括号进行匹配，左括号入栈，右括号进行匹配，匹配则出栈，不匹配break，一下是几种不匹配的情况：

当遇到某一个右括号时，栈已空，说明目前为止，右括号多于左括号

从栈弹出的左括号与当前检验的右括号类型不同，说明出现了括号交叉

算术表达式输入完毕，但栈中还没有匹配的左括号，说明左括号多于右括号

3、表达式求值
表达式的组成：

操作数(operand)：常数、变量

运算符(operator)：算术运算符、关系运算符和逻辑运算符

界限符(delimiter)：左右括号和表达式结束符，如‘#’

例如：#3*(7-2)#

为了求解这样一个表达式就要两个栈一个是算符栈OPTR，一个是操作数栈OPND。前者存放运算符，另一个存运算结果。

从左到右扫描表达式，如果遇到运算数就放入OPND，如果是运算符，如果该运算符比OPTR的栈顶优先级高，则入栈OPTR，继续向后处理；否则从OPND中弹出两个运算数，从OPTR中弹出栈顶运算符进行运算，将结果压入OPND。如此向后处理，直到碰到结束符。

4、舞伴问题
假设在舞会上,男士和女士各自排成一队。舞会开始时, 依次从男队和女队的队头各出一人配成伴如果两队 初始人数不相同,则较长的那一队中未配对者等待下一 轮舞曲。现要求写一算法模拟上述舞伴配对问题。

这题显然用队列解，分别构造男女两个队列来解决问题