文章目录

一、栈

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
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、共享栈

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

数据结构--栈和队列_循环队列_02


两个栈的栈顶指针都指向栈顶元素，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
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 == NUL​​​L且​​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、双端队列

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

数据结构--栈和队列_循环队列_03

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

数据结构--栈和队列_双端队列_04

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

数据结构--栈和队列_双端队列_05