【第三章：栈和队列】

知识框架

No.1栈

• 栈和队列均是线性结构；
• 特殊的线性表：因为栈和队列的操作是线性表操作的子集：头部和尾部：操作受限；

一、栈的基本概念

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

栈顶（Top）：线性表允许进行插入删除的那一端。
栈底（Bottom）：固定的，不允许进行插入和删除的另一端。表头端
空栈：不含任何元素的空表。
栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构
出栈：删除栈顶元素的操作；与取栈顶元素不同。
入栈：插入元素的操作叫做入栈；
（倒竖立）

1.栈的定义

2.栈的常见基本操作

• InitStack(&S)：初始化一个空栈S。
• StackEmpty(S)：判断一个栈是否为空，若栈为空则返回true，否则返回false。
• Push(&S, x)：进栈（栈的插入操作），若栈S未满，则将x加入使之成为新栈顶。
• Pop(&S, &x)：出栈（栈的删除操作），若栈S非空，则弹出栈顶元素，并用x返回。
• GetTop(S, &x)：读栈顶元素，若栈S非空，则用x返回栈顶元素。
• DestroyStack(&S)：栈销毁，并释放S占用的存储空间（“&”表示引用调用）。

二、栈的顺序存储结构

1、栈的顺序存储

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

设置指针 top 指示栈顶元素在 顺序栈中的位置；（top = 0 表示空栈）
开始时先为栈分配一个基本容量：STACK_INIT_SIZE;
应用过程中，当栈的空间不够使用时再扩大：STACKINCREMENT；

栈的顺序存储结构可描述为：

typedef struct {
    SElemType	*base;  //数组首地址
    SElemType   *top;   //栈顶指针
    int 	stacksize; //栈容量
}SqStack；

1. stacksize指示栈的当前可使用的最大容量
2. 首先按照初始分配量进行第一次存储分配；
3. base指针称为栈底指针，指向栈底的位置，如果base==NULL，则表明栈结构不存在；
4. top指针，初始值指向栈底，即top==base 作为栈空的标记；
5. 当插入新的元素时候，top+1，
6. 删除栈顶元素时候，top-1；
7. 即非空栈的时候，top指向的是一个待填入的空格位置。

2、顺序栈的基本算法

（1）初始化

typedef struct {
    SElemType	*base;  //数组首地址
    SElemType   *top;   //栈顶指针
    int 	stacksize; //栈容量
}SqStack；

int Init_Stack_Int(SqStack &S){
    S.base=(int*)malloc(sizeof(int)*MAXSIZE);
    if(S.base) exit (OVERFLOW);
    S.top=S.base;
    S.stacksize=MAXSIZE;
    return OK;
}

（2）判栈空

（3）进栈

Status Push(SqStack &S, SElemType e){
   //插入元素e为新的栈顶元素
   if(S.top-S.base>=S.stacksize) {//栈满，追加空间
      S.base=(SElemType*)realloc(S.base,
		  (S.stacksize+STACKINCREMENT)*sizeof(SElemType));
		if(!S.base) exit(OVERFLOW);
	  S.top=S.base+S.stacksize;
      S.stacksize+=STACKINCREMENT;
   }
  *(S.top++)=e;
  return OK;
}//Push

（4）出栈

status Pop(SqStack &S, SElemType &e){
   //若栈不空，则删除栈顶元素，用e返回其值，并返回OK；
	//否则返回ERROR
   if(S.top==S.base) return ERROR;  //栈空
   e=*（--S.top）;
   return OK;
}//Pop

（5）读栈顶元素

Status GetTop(SqStack S, SElemType &e){
		//若栈不空，则用e返回S的栈顶元素，并返OK，
		//否则返回ERROR
		if(S.top==S.base) return ERROR; //栈空
		e=*(S.top-1);
		return OK;
}//GetTop

3、共享栈（两栈共享空间）

（1）共享栈概念

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

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

（2）共享栈的空间结构

/*两栈共享空间结构*/
#define MAXSIZE 50  //定义栈中元素的最大个数
typedef int ElemType;   //ElemType的类型根据实际情况而定，这里假定为int
/*两栈共享空间结构*/
typedef struct{
	ElemType data[MAXSIZE];
	int top0;	//栈0栈顶指针
	int top1;	//栈1栈顶指针
}SqDoubleStack;

（3）共享栈进栈

对于两栈共享空间的push方法，我们除了要插入元素值参数外，还需要有一个判断是栈0还是栈1的栈号参数stackNumber。
共享栈进栈的代码如下：

/*插入元素e为新的栈顶元素*/
Status Push(SqDoubleStack *S, Elemtype e, int stackNumber){
    if(S->top0+1 == S->top1){   //栈满
        return ERROR;
    }
    if(stackNumber == 0){   //栈0有元素进栈
        S->data[++S->top0] = e; //若栈0则先top0+1后给数组元素赋值
    }else if(satckNumber == 1){ //栈1有元素进栈
        S->data[--S->top1] = e; //若栈1则先top1-1后给数组元素赋值
    }
    return OK;
}

（4）共享栈出栈

/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
Status Pop(SqDoubleStack *S, ElemType *e, int stackNumber){
    if(stackNumber == 0){
        if(S->top0 == -1){
            return ERROR;   //说明栈0已经是空栈，溢出
        }
        *e = S->data[S->top0--]; //将栈0的栈顶元素出栈，随后栈顶指针减1
    }else if(stackNumber == 1){
        if(S->top1 == MAXSIZE){
            return ERROR;   //说明栈1是空栈，溢出
        }
        *e = S->data[S->top1++];    //将栈1的栈顶元素出栈，随后栈顶指针加1
    }
    return OK;
}

三、栈的链式存储结构

1、链栈

采用链式存储的栈称为链栈，链栈的优点是便于多个栈共享存储空间和提高其效率，且不存在栈满上溢的情况。通常采用单链表实现，并规定所有操作都是在单链表的表头进行的。这里规定链栈没有头节点，Lhead指向栈顶元素，如下图所示。

对于空栈来说，链表原定义是头指针指向空，那么链栈的空其实就是top=NULL的时候。
链栈的结构代码如下：

/*栈的链式存储结构*/
/*构造节点*/
typedef struct StackNode{
    ElemType data;
    struct StackNode *next;
}StackNode, *LinkStackPrt;
/*构造链栈*/
typedef struct LinkStack{
    LinkStackPrt top;
    int count;
}LinkStack;

2、链栈的基本算法

（1）链栈的进栈

对于链栈的进栈push操作，假设元素值为e的新节点是s，top为栈顶指针，示意图如下：

/*插入元素e为新的栈顶元素*/
Status Push(LinkStack *S, ElemType e){
    LinkStackPrt p = (LinkStackPrt)malloc(sizeof(StackNode));
    p->data = e;
    p->next = S->top;    //把当前的栈顶元素赋值给新节点的直接后继
    S->top = p; //将新的结点S赋值给栈顶指针
    S->count++;
    return OK;
}

（2）链栈的出栈

链栈的出栈pop操作，也是很简单的三句操作。假设变量p用来存储要删除的栈顶结点，将栈顶指针下移以为，最后释放p即可，如下图所示：

/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
Status Pop(LinkStack *S, ElemType *e){
    LinkStackPtr p;
    if(StackEmpty(*S)){
        return ERROR;
    }
    *e = S->top->data;
    p = S->top; //将栈顶结点赋值给p
    S->top = S->top->next;  //使得栈顶指针下移一位，指向后一结点
    free(p);    //释放结点p
    S->count--;
    return OK;
}

3、性能分析

链栈的进栈push和出栈pop操作都很简单，时间复杂度均为O(1)。
对比一下顺序栈与链栈,它们在时间复杂度上是一样的,均为O(1)。对于空间性能,顺序栈需要事先确定一个固定的长度,可能会存在内存空间浪费的问题,但它的优势是存取时定位很方便,而链栈则要求每个元素都有指针域,这同时也增加了一些内存开销,但对于栈的长度无限制。所以它们的区别和线性表中讨论的一样**,如果栈的使用过程中元素变化不可预料,有时很小,有时非常大,那么最好是用链栈,反之,如果它的变化在可控范围内,建议使用顺序栈会更好一些。**

四、栈的应用——递归

利用的是栈的后进先出的特性；

1、递归的定义

递归是一种重要的程序设计方法。简单地说,若在一个函数、过程或数据结构的定义中又应用了它自身,则这个函数、过程或数据结构称为是递归定义的,简称递归。
它通常把一个大型的复杂问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的代码就可以描述岀解题过程所需要的多次重复计算,大大减少了程序的代码量但在通常情况下,它的效率并不是太高。

2、斐波那契数列

/*斐波那契数列的实现*/
int Fib(int n){
    if(n == 0){
        return 0;   //边界条件
    }else if(n == 1){
        return 1;	//边界条件
    }else{
        return Fib(n-1) + Fib(n-2); //递归表达式
    }
}

五、栈的应用——四则运算表达式求值

1、后缀表达式计算结果

表达式求值是程序设计语言编译中一个最基本的问题,它的实现是栈应用的一个典型范例。中缀表达式不仅依赖运算符的优先级,而且还要处理括号。后缀表达式的运算符在操作数后面，在后缀表达式中已考虑了运算符的优先级,没有括号,只有操作数和运算符。例如中缀表达式A + B ∗ ( C − D ) − E / F A+B*(C-D)-E/FA+B∗(C−D)−E/F所对应的后缀表达式为A B C D − ∗ + E F / − ABCD-*+EF/-ABCD−∗+EF/−。

后缀表达式计算规则：从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到是符号，就将处于栈顶两个数字出栈，进项运算，运算结果进栈，一直到最终获得结果。

后缀表达式A B C D − ∗ + E F / − ABCD-*+EF/-ABCD−∗+EF/−求值的过程需要12步，如下表所示：

读者也可将后缀表达式与原运算式对应的表达式树(用来表示算术表达式的二元树)的后序遍历进行比较,可以发现它们有异曲同工之妙。
如下图则是A + B ∗ ( C − D ) − E / F A+B*(C-D)-E/FA+B∗(C−D)−E/F对应的表达式，它的后序遍历即是表达式A B C D − ∗ + E F / − ABCD-*+EF/-ABCD−∗+EF/−。

2、中缀表达式转后缀表达式

我们把平时所用的标准四则运算表达式,即a + b − a ∗ ( ( c + d ) / e − f ) + g a+b-a*((c+d)/e-f)+ga+b−a∗((c+d)/e−f)+g叫做中缀
表达式。因为所有的运算符号都在两数字的中间,现在我们的问题就是中缀到后缀的转化。

规则:从左到右遍历中缀表达式的每个数字和符号,若是数字就输出,即成为后
缀表达式的一部分;若是符号,则判断其与栈顶符号的优先级,是右括号或优先级低于栈顶符号(乘除优先加减)则栈顶元素依次出栈并输出,并将当前符号进栈,一直到最终输出后缀表达式为止。

例：将中缀表达式a + b − a ∗ ( ( c + d ) / e − f ) + g a+b-a*((c+d)/e-f)+ga+b−a∗((c+d)/e−f)+g转化为相应的后缀表达式。

分析：需要根据操作符

的优先级来进行栈的变化,我们用icp来表示当前扫描到的运算符ch的优先级,该运算符进栈后的优先级为isp,则运算符的优先级如下表所示[isp是栈内优先( in stack priority)数,icp是栈外优先( in coming priority)数]。

我们在表达式后面加上符号‘#’,表示表达式结束。具体转换过程如下：
即相应的后缀表达式为a b + a c d + e / f − ∗ − g +

3、数制转换

原理：N=（N div d）*d+N mod d
就是不断除以 d 然后将余数 放入栈中，，然后再读出；正好倒序；

//数值转换 主要是 利用了栈的 特性；；
void  Convert（int N, int  d）{//将十进制N转换成d进制数输出
   InitStack（S）；
   cin>>N;
   while(N){
   Push(S,N%8);
   N=N/8;
   }
   while(!StackEmpty(S)){
     Pop(S,e);
     cout<<e<<endl;

  }

}//Convert

4、括号匹配的检验

https://zhuanlan.zhihu.com/p/134675879 知乎大佬讲解

1、首先将这个字符串转换成字符数组，并初始化一个空栈。
2、遍历到第0个元素，(，为左括号，入栈
3、后面以此类推，遍历完第3个元素[后，栈空间应该是这样的
4、遍历到第4个元素]时，发现为右括号，此时，从栈顶出栈一个左括号，即[，刚好[与]，匹配成一对
5、以此类推，直到第6个元素)，都是匹配的
6、此时，序列已经遍历完毕，但是栈不是空的，所以原序列匹配失败

#include<iostream>
#include<stack>
#include<cstring>
#include<cstdio>
using namespace std;
int matches(string a){
	stack<char> s;
	int l=a.length(),label=0;
    char t;
	for(int i=0;i<l;++i)
    {
        if(a[i]=='('||a[i]=='['||a[i]=='{')
        {
            s.push(a[i]);
        }
        if(a[i]==')'||a[i]==']'||a[i]=='}')
        {
		if(s.empty())return 3;
        else 
		{
		
        if(a[i]==')')
        {
        	t=s.top();
           if(t=='(')s.pop();
           else
           {
                label=1;
           		s.pop();
           		return 1;
	        }
			   
           
        }
        if(a[i]==']')
        {
           t=s.top();
           if(t=='[')s.pop();
           else
           {
           	    label=1;
           	    s.pop();
           		return 1;
			   
           }
        }
        if(a[i]=='}')
        {
           t=s.top();
           if(t=='{')s.pop();
           else
           {
		   
           		label=1;
           		s.pop();
           		return 1;   
           }
        }
		}
		}
    }
       if(!s.empty())return 2;
       if(s.empty()&&label!=1) return 0;
	
}
int main()
{
    string a;
    cin>>a;
    cout<<matches(a)<<endl;
    return 0;
}

5、迷宫求解

https://blog.csdn.net/Vit_rose/article/details/52781116 大佬代码

6、表达式求值

No.2队列

一、队列的基本概念

1、队列的定义

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。

队头（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。

二、队列的顺序存储结构

队列的顺序实现是指分配一块连续的存储单元存放队列中的元素，并附设两个指针：队头指针 front指向队头元素，队尾指针 rear 指向队尾元素的下一个位置。

1、顺序队列

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

#define MAXSIZE 50	//定义队列中元素的最大个数
typedef struct{
	ElemType data[MAXSIZE];	//存放队列元素
	int front,rear;
}SqQueue;

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

如图d，队列出现“上溢出”，然而却又不是真正的溢出，所以是一种“假溢出”。

2、循环队列

也就是说前面的那个顺序表示是有缺陷的；

队列的顺序存储结构中：用一组地址连续的存储单元一次存放从队列头到队列尾的元素
需要再设 front指针和rear指针分别指向队列头元素和尾元素；
约定：初始化建立空队列，令front==rear =0；
当插入新的元素入队时，尾指针+1；
当删除队列头元素，头指针+1；
即在非空队列：头指针指向队列头元素，尾指针指向队列尾元素的下一个位置

上面这样处理的话，当rear指向6的时候就不能够再次插入元素到队列；而且此时也不适合像顺序栈那样进行存储再分配扩大数组元素； 因此将顺序队列意向为 一个环状的空间；称为循环队列；

在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时，也有front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件是front=rear，而队列判满的条件是front=（rear+1)%MaxSize

假溢出的方法就是后面满了，就再从头开始，也就是头尾相接的循环。我们把队列的这种头尾相接的顺序存储结构称为循环队列。
当队首指针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 - Q->front + MAXSIZE) % MAXSIZE。

出队入队时，指针都按照顺时针方向前进1，如下图所示：

那么，循环队列队空和队满的判断条件是什么呢？
显然，队空的条件是 Q->front == Q->rear 。若入队元素的速度快于出队元素的速度，则队尾指针很快就会赶上队首指针，如图( d1 ）所示，此时可以看出队满时也有 Q ->front == Q -> rear 。
为了区分队空还是队满的情况，有三种处理方式：

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

• 队满条件： (Q->rear + 1)%Maxsize == Q->front
• 队空条件仍： Q->front == Q->rear
• 队列中元素的个数： (Q->rear - Q ->front + Maxsize)% Maxsize

（2）类型中增设表示元素个数的数据成员。这样，队空的条件为 Q->size == O ；队满的条件为 Q->size == Maxsize 。这两种情况都有 Q->front == Q->rear
（3）类型中增设tag 数据成员，以区分是队满还是队空。tag 等于0时，若因删除导致 Q->front == Q->rear ，则为队空；tag 等于 1 时，若因插入导致 Q ->front == Q->rear ，则为队满。

3、循环队列常见基本算法

（1）循环队列的顺序存储结构

#define  MAXQSIZE   100
typedef struct {
		QElemType   *base;  //数组首地址
		int   	front;  //front为队头元素的下标
		int 	rear;   //Rear为队尾元素的后一个单元的下标
}SqQueue；

（2）循环队列的初始化

Status  InitQueue_Sq（SqQueue  &Q）
{  //初始化队列Q
     Q.base = （ElemType*）malloc（MAXQSIZE*sizeof(ElemType)）；
     if（！Q.base）  exit（OVERFLOW）;
     Q.front = Q.rear =0;
     return  OK;
} // InitQueue_Sq

（3）循环队列判队空

/*判队空*/
bool isEmpty(SqQueue Q){
    if(Q.rear == Q.front){
        return true;
    }else{
        return false;
    }
}

（4）求循环队列长度

int QueueLength_Sq(SqQueue   Q)
{ //返回队列Q的长度
   return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
} //QueueLength_Sq

（5）循环队列入队

Status  EnQueue_Sq(SqQueue  &Q , ElemType  e)
{ //将数据元素e入循环队列Q中
     if((Q.rear+1)%MAXQSIZE = = Q.front)
			return  ERROR;
     Q.base[Q.rear] = e;
     Q.rear = (Q.rear+1)%MAXQSIZE;
     return  OK;
}// EnQueue_Sq

（6）循环队列出队

Status  DnQueue_Sq(SqQueue  &Q , ElemType  &e)
{ //循环队列Q出队，出队元素赋值给e中
  if(Q.rear = = Q.front)   return ERROR;
	e = Q.base[Q.front];
	Q.front = (Q.front+1)%MAXQSIZE;
  return  OK;
}// DeQueue_Sq

三、队列的链式存储结构

1、链队列

链式队列，简称"链队列"，即使用链表实现的队列存储结构。
一个链式队列需要 指向头和尾部的指针：头指针和尾指针；
和线性表的单链表一样+一个头结点；且头指针指向头结点；
空的链式队列条件判断：头指针和尾指针均指向头结点；

队列的链式存储结构表示为链队列，它实际上是一个同时带有队头指针和队尾指针的单链表，只不过它只能尾进头出而已。

空队列时，front和real都指向头结点。

2、链队列常见基本算法

注意在出队的时候；
//注意在删除队列头元素算法中的特殊情况：一般情况下，删除队列头元素时仅仅需要修改头结点中的指针，
//但是当队列中最后一个元素被删除的时候，队列尾指针也丢失了，因此需要对队尾指针重新赋值（指向头结点）

（1）链队列存储类型

当Q->front == NULL 并且 Q->rear == NULL 时，链队列为空。

typedef struct QNode{	
	 ElemType  data；
	 struct  Qnode  *next；
}QNode，*QueuePtr；
typdef  struct{
   QueuePtr   front，rear；//Q.front指向头结点 Q.rear 指向最后一个结点
}LinkQueue；

（2）链队列初始化

Status InitQueue(LinkQueue &Q){
	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
	if(!Q.front) exit(OVERFLOW);
	Q.front->next = NULL;
	return OK;
}

（3）链队列入队

Status EnQueue_L(SqQueue& Q,ElemType  e){ 
    //将数据元素e入链队列Q中
   p = (QueuePtr)malloc(sizeof(QNode));
	 if(!p)  exit(OVERFLOW);
	 p->data = e;	     p->next = NULL;
	 Q.rear ->next = p;	 Q.rear = p;
	 return OK;
}// EnQueue_L

（4）链队列出队

出队操作时，就是头结点的后继结点出队，将头结点的后继改为它后面的结点，若链表除头结点外只剩一个元素时，则需将rear指向头结点。

/*若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR*/
Status DnQueue_L(SqQueue& Q ,ElemType  &e)
{ //链队列Q出队，出队元素赋值给e中
  if（Q.front = = Q.rear） return ERROR;
	p = Q.front->next; e = p->data;
	Q.front ->next = p->next;
	if(Q.rear = = p)  Q.rear = Q.front; 
   //只有一个结点的情况
	free(p);  return OK;
}// DeQueue_L
//注意在删除队列头元素算法中的特殊情况：一般情况下，删除队列头元素时仅仅需要修改头结点中的指针，
//但是当队列中最后一个元素被删除的时候，队列尾指针也丢失了，因此需要对队尾指针重新赋值（指向头结点）

四、双端队列

1、定义

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

在双端队列进队时，前端进的元素排列在队列中后端进的元素的前面，后端进的元素排列在队列中前端进的元素的后面。在双端队列出队时，无论是前端还是后端出队，先出的元素排列在后出的元素的前面。

2、特殊的双端队列

在实际使用中，根据使用场景的不同，存在某些特殊的双端队列。

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

输入受限的双端队列：允许在一端进行插入和删除，但在另一端只允许删除的双端队列称为输入受限的双端队列，如下图所示。若限定双端队列从某个端点插入的元素只能从该端点删除，则该双端队列就蜕变为两个栈底相邻接的栈。

附录

上文链接

下文链接

专栏

参考资料