数据结构--栈和队列

一、栈

1.1、栈的基本概念

1、栈的定义

栈（Stack），是只允许在一端进行插入或者删除的线形表。首先，栈是一种线形表，但限定这种线形表只能在某一端进行插入和删除操作，如下图示：

栈顶（Top）：线形表允许插入和删除的那一端。
栈低（Bottom）：固定的，不允许进行插入和删除的另一端。
空栈：不含任何元素的空表。
特点：先进后出

2、栈的基本操作

操作	功能
InitStack(&S)	初始化一个空栈S
StackEmpty(S)	判断一个栈是否为空，若空返回true，反之返回false
Push(&S,x)	进栈，若未满，则将x加入使之成为新的栈顶
Pop(&S,x)	出栈，若非空，则弹出栈顶元素，并用x返回
GetTop(S,&x)	读栈顶元素，若栈非空，则用x返回栈顶元素
DestroyStack(&S)	销毁栈，并释放栈S占用的存储空间

1.2、栈的实现

1、顺序栈的实现

采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元存放自栈低到栈顶的数据元素，同时附设一个指针（top）指示当前栈顶的位置。
栈的顺序存储类型可描述为：

#define MaxSize 50
typedef struct
{
	Elemtype 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。

2、顺序栈的基本运算

（1）初始化

void InitStack(SqStack &S)
{
	S.top = -1;
}

（2）判栈空

bool StackEmpty(SqStack S)
{
	if(S.top == -1)
		return true;
	else
		return false;
}

（3）进栈

bool Push(SqStack &S, ElemType x)
{
	if(S.top == MaxSize-1)
		return false;
	S.data[++S.top] = x;
	return true;
}

（4）出栈

bool Pop(SqStack &S, ElemType &x)
{
	if(S.top == -1)
		return false;
	x=S.data[S.top--];
	return true;
}

（5）读栈顶元素

bool GetTop(SqStack S, ElemType &x)
{
	if(S.top == -1)
		return false;
	x=S.data[S.top];
	return true;
}

3、共享栈

利用栈底位置相对不变的特性，可以让两个顺序栈共享一个一维数据空间，将两个栈的栈低分别设置为共享空间的两端，两个栈顶向共享空间的中间延伸，如下图示：

两个栈的栈顶指针都指向栈顶元素，top0 = -1时0号栈为空，top1 = MaxSize时1号栈为空；
仅当两个栈顶指针相邻（top1-top0 = 1）时，判断为栈满；
当0号栈进栈时，top0先加1再赋值；当1号栈进栈时，top1先减1再赋值；出栈则刚好相反。

4、栈的链式存储

采用链式存储的栈称为链栈，链栈的优点时便于多个栈共享存储空间和提高其效率，且不存在栈满上溢的情况。通常采用单链表实现，并规定所有操作都在单链表的表头进行。

---

二、队列

2.1、队列的基本概念

1、队列的定义

队列（Queue），是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队；删除元素为出队。
队头（Front）：允许删除的一端，又称为队首；
队尾（Rear）：允许插入的一端；
空队列：不含任何元素的空表。
特点：先入先出

2、队列常见的基本操作

操作	功能
InitQueue(&Q)	初始化队列，构造一个空队列Q
QueueEmpty(Q)	判队列空，若队列Q为空着返回true，否则返回false
EnQueue(&Q,x)	入队，若队列Q未满，将x加入，使之成为新的队尾
DeQueue(&Q,&x)	出队，若队列Q非空，删除队头元素，并用x返回
GetHead(Q,&x)	读队头元素，若队列Q非空，则将队头元素赋值给x

2.2、队列的实现

1、队列的顺序存储、

队列的顺序实现是指分配一块连续的存储单元春芳队列中的元素，并附设两个指针front和rear分别指示队头元素和队尾元素的位置。设队头指针指向队头元素，队尾指针指向队尾元素的下一个位置（或者设队头指针指向队头元素的前一个位置，队尾指针指向队尾元素）。

队列的顺序存储类型可描述为：

#define MaxSize 50
typedef struct
{
	ElemType data[MaxSize];
	int front,rear;
}SqQueue;

初始状态（队空条件）：Q.front == Q.rear == 0
进队操作：队不满时，先送值到队尾元素，再将队尾指针加1
出队操作：队不空时，先取队头元素值，再将队头指针加1

2、循环队列

顺序队列可能存在“假溢出”现象，所以引出循环队列的概念。将顺序队列臆造为一个环形的空间，即把存储队列元素的表从逻辑上视为一个环，称为循环队列。当队首指针Q.front=MaxSize-1后，再前进一个位置就自动到0，这可以利用触发取余运算（%）来实现。

初始时：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。

注意：出队入队指针都按顺时针方向进1

循环队列队空和队满的判断条件，显然队空的条件是Q.front= Q.rear；若入队元素的速度快于出队元素的速度，则队尾指针很快就会赶上队首指针，此时可以看出队满时也有Q.front==Q.rear。为了区分队空还是队满的情况，有三种处理方式：

1）牺牲一个单元来区分队空和队满，入队时少用一个队列单元，这个一种较为普遍的做法，约定以“队头指针在队尾指针的下一位置作为队满的标志”，

队满条件：（Q.rear+1）% MaxSize == Q.front
队空条件：Q.front = Q.rear
队列中元素的个数：（Q.rear-Q.front+MaxSize）% MaxSize

2）类型中增设表示元素个数的数据成员。这样，队空的条件为Q.size == 0；队满的条件为Q.size == MaxSize，这两种情况都有Q.front==Q.rear。

3）类型中增设tag数据成员，以区分队满还是队空。tag等于0时，若因删除导致Q.front==Q.rear，则队空；tag等于1时，若因插入导致Q.front==Q.rear，则队满。

3、循环队列的操作

（1）初始化

void InitQueue(SqQueue &Q)
{
	Q.rear=Q.front=0;
}

（2）判队空

bool isEmpty(SqQueue Q)
{
	if(Q.rear==Q.front)
		return true;
	else
		return false;
}

（3）入队

bool EnQueue(SqQueue &Q,ElemType x)
{
	if((Q.rear+1)%MaxSize==Q.front)
		return false;
	Q.data[Q.rear]=x;
	Q.rear=(Q..rear+1)%MaxSize;
	return true;
}

（4）出队

bool DeQueue(SqQueue &Q,ElemType &x)
{
	if(Q.rear == Q.front)
		return false;
	x=Q.data[Q.front];
	Q.front=(Q.front+1)%MaxSize;
	return true;
}

4、队列的链式存储

队列的链式表示称为链队列，它实际上 是一个同时带有队头指针和队尾指针的单链表。头指针指向队头结点，尾指针指向队尾结点。

队列的链式存储类型可描述为：

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

当Q.front == NULL且Q.rear == NULL时，链式队列为空。

5、链式队列的基本操作

（1）初始化

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

（2）判队空

bool IsEmpty(LinkQueue Q)
{
	if(Q.front==Q.rear)
		return true;
	else
		return false;
}

（3）入队

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

（4）出队

bool DeQueue(LinkQueue &Q，ElemType &x)
{
	if(Q.front==Q.rear)
		return false;
	LinkNode *p=Q.front->next;
	x=p->data;
	Q.front->next=p->next;
	if(Q.rear==p)
		Q.rear=Q.front;
	free(p);
	return true;
	
}

6、双端队列

双端队列是指允许两端都可以进行入队和出队操作的队列，其元素的逻辑结构仍是线性结构。将队列的两端分别称为前端和后端，两端都可以入队和出队。

输出受限的双端队列：允许在一端进行插入和删除，但在另一端只允许插入的双端队列称为输出受限的双端队列。

输入受限的双端队列：允许在一旦进行插入和删除，但在另一端只允许删除的双端队列称为输入受限的双端队列。