栈与队列

简介 

堆栈和队列都属于线性结构，是两种在运算上受到某些限制的特殊线性表，他们比一般线性表更简单，被广泛应用于类型的程序设计中，可以用来存放许多中间信息，在系统软件设计以及递归问题处理方面都离不开堆栈和队列。

栈 

栈的操作原则是：先进后出，后进先出

二、栈的特点

根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。 也就是说，栈是一种后进先出(Last In First Out)的线性表，简称为LIFO表。

 

三、栈的运算 

1.初始化栈：INISTACK(&S)

将栈S置为一个空栈(不含任何元素)。

 

2.进栈：PUSH(&S,X)

将元素X插入到栈S中，也称为 “入栈”、 “插入”、 “压入”。

 

3.出栈： POP(&S) 

删除栈S中的栈顶元素，也称为”退栈”、 “删除”、 “弹出”。

 

4.取栈顶元素： GETTOP(S)

取栈S中栈顶元素。

 

5.判栈空： EMPTY(S)

判断栈S是否为空，若为空，返回值为1，否则返回值为0。

 

栈总是处于栈空、栈满或不空不满三种状态之一，它们是通过栈顶指针top的值体现出来的。 规定：top的值为下一个进栈元素在数组中的下标值。 栈空时（初始状态），top=0; 栈满时，top=MAXN.

 

三、栈的五种运算 （一） 进栈 1） 进栈算法 （1） 检查栈是否已满，若栈满，进行“溢出”处理。 （2） 将新元素赋给栈顶指针所指的单元。 （3） 将栈顶指针上移一个位置（即加1）。 

 

（二） 出栈 1） 出栈算法 （1） 检查栈是否为空，若栈空，进行“下溢”处理。 （2）将栈顶指针下移一个位置（即减1） 。 （3）取栈顶元素的值，以便返回给调用者。 

四．栈的共享存储单元 有时，一个程序设计中，需要使用多个同一类型的栈,这时候，可能会产生一个栈空间过小，容量发生溢出，而另一个栈空间过大，造成大量存储单元浪费的现象。 为了充分利用各个栈的存储空间，这时可以采用多个栈共享存储单元，即给多个栈分配一个足够大的存储空间，让多个栈实现存储空间优势互补。

 

4、两个栈共享同一存储空间     　当程序中同时使用两个栈时，可以将两个栈的栈底设在向量空间的两端，让两个栈各自向中间延伸。当一个栈里的元素较多，超过向量空间的一半时，只要另一个栈的元素不多，那么前者就可以占用后者的部分存储空间。     只有当整个向量空间被两个栈占满（即两个栈顶相遇）时，才会发生上溢。因此，两个栈共享一个长度为m的向量空间和两个栈分别占用两个长度为 └ m/2┘和┌m/2┐的向量空间比较，前者发生上溢的概率比后者要小得多。

 

 队列 

 

 1、定义     　队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表

 

（1）允许删除的一端称为队头（Front）。 　　（2）允许插入的一端称为队尾（Rear）。 　　（3）当队列中没有元素时称为空队列。 　　（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。     　队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾（即不允许"加塞"），每次离开的成员总是队列头上的（不允许中途离队），即当前"最老的"成员离队。

 

队列的存储结构：

 

顺序队列 队列的顺序存储结构称为顺序队列，顺序队列实际上是运算受限的顺序表，和顺序表一样，顺序队列也是必须用一个数组来存放当前队列中的元素。由于队列的队头和队尾的位置是变化的，因而要设两个指针和分别指示队头和队尾元素在队列中的位置。 

 

（3） 顺序队列的基本操作 队列也有队空、队满或不空不满三种情况。 1.第一种表示方法 规定：head指向队首元素的位置，tail指向队尾元素的位置。队列初始状态设为head=0,tail=-1. 当队列非空时，tail>=head; 当队列空时， head>tail; 当队列满时， tail=maxsize-1. 2.第二种表示方法 规定：head指向队首元素的前一个位置，tail指向队尾元素的位置。队列初始状态设为head=tail=-1. 1)当队列非空时，tail>head; 2)当队列空时， head=tail; 3)当队列满时， tail=maxsize-1. 　　①入队时：将新元素插入rear所指的位置，然后将rear加1。 　　②出队时：删去front所指的元素，然后将front加1并返回被删元素。

 

（4）顺序队列中的溢出现象 　　① "下溢"现象     　当队列为空时，做出队运算产生的溢出现象。“下溢”是正常现象，常用作程序控制转移的条件。 　　② "真上溢"现象     　当队列满时，做进栈运算产生空间溢出的现象。“真上溢”是一种出错状态，应设法避免。 　　③ "假上溢"现象 从顺序存储的队列可以看出，有可能出现这样情况，尾指针指向一维数组最后，但前面有很多元素已经出队，即空出很多位置，这时要插入元素，仍然会发生溢出。例如，在下图中，若队列的最大容量maxsize=4，此时，tail=3，再进队时将发生溢出。我们将这种溢出称为“假溢出”。 要克服“假溢出”，可以将整个队列中元素向前移动，直到头指针head为零，或者每次出队时，都将队列中元素前移一个位置。因此，顺序队列的队满判定条件为tail=maxsize-1。但是，在顺序队列中，这些克服假溢出的方法都会引起大量元素的移动，花费大量的时间，所以在实际应用中很少采用，一般采用下面的循环队列形式。

 

循环队列

一）定义 为了克服顺序队列中假溢出，通常将一维数组queue[0]到q[maxsize-1]看成是一个首尾相接的圆环，即queue[0]与queue[maxsize-1]相接在一起。将这种形式的顺序队列称为循环队列 。

若tail+1=maxsize,则令tail=0. 这样运算很不方便，可利用数学中的求模运算来实现。

入队：tail=(tail+1) mod maxsize;squeue[tail]=x. 出队：head=(head+1) mod maxsize.

二）循环队列的变化

在循环队列中，若head=tail,则称为队空， 若(tail+1) mod maxsize=head, 则称为队满，这时，循环队列中能装入的元素个数为maxsize-1,即浪费一个存储单元，但是这样可以给操作带来较大方便。 

三）循环队列上五种运算实现 

1.进队列

1）进队列算法

（1）检查队列是否已满，若队满，则进行溢出错误处理；

（2）将队尾指针后移一个位置（即加1），指向下一单元；

（3）将新元素赋给队尾指针所指单元。

2) 进队列实现程序

int head=0,tail=0;

int enqueue (elemtype queue[], elemtype x)

{ if ((tail+1)%maxsize = = head)   return(1);

else

{

tail=(tail+1)%maxsize;

queue[tail]=x;

return(0);

}

} 

2. 出队列

1)出队列算法

（1）检查队列是否为空，若队空，则进行下溢错误处理；

（2）将队首指针后移一个位置（即加1）；

（3）取队首元素的值。

 

2) 出队列实现程序

int head=0,tail=0;

int dlqueue(elemtype queue[ ],elemtype *p_x )

{

if (head= =tail) return(1);

else

{

head =(head+1) % maxsize;

*p_x=queue[head]];

return(0);

}

}

 

(3) 队列初始化 head=tail=0;

 

(4) 取队头元素（注意得到的应为头指针后面一个位置值）

elemtype gethead(elemtype queue[ ] )

{ if (head= =tail)   return(null);

else return (queue[(head+1)%maxsize]);

}

(5) 判队列空否

int empty(elemtype queue[ ] )

{

if (head= =tail) reurn (1);

else return (0);

} 

 

 

 

（1） 循环队列的基本操作    

　循环队列中进行出队、入队操作时，头尾指针仍要加1，朝前移动。

只不过当头尾指针指向向量上界（QueueSize-1）时，其加1操作的结果是指向向量的下界0。

这种循环意义下的加1操作可以描述为：

① 方法一：     if(i+1==QueueSize) //i表示front或rear        i=0;    

                      else         i++;

② 方法二--利用"模运算"    

i=(i+1)%QueueSize；

 

（2） 循环队列边界条件处理    　

循环队列中，由于入队时尾指针向前追赶头指针；出队时头指针向前追赶尾指针，造成队空和队满时头尾指针均相等。因此，无法通过条件front==rear来判别队列是"空"还是"满"。

【参见动画演示】    　 解决这个问题的方法至少有三种： 　

　① 另设一布尔变量以区别队列的空和满； 　

　② 少用一个元素的空间。约定入队前，测试尾指针在循环意义下加1后是否等于头指针，若相等则认为队满（注意：rear所指的单元始终为空）； 　　

③使用一个计数器记录队列中元素的总数（即队列长度）。

 

（3） 循环队列的类型定义

     #define Queur Size 100   //应根据具体情况定义该值     

typedef char Queue DataType;  //DataType的类型依赖于具体的应用     

typedef Sturet{               //头指针，队非空时指向队头元素         

   int front;              //尾指针，队非空时指向队尾元素的下一位置           

int rear;               //计数器，记录队中元素总数          

  DataType data[QueueSize]    

  }CirQueue;

 

（4） 循环队列的基本运算 　　用第三种方法，循环队列的六种基本运算： 　

　① 置队空     

  void InitQueue(CirQueue *Q)      

{          

     Q->front=Q->rear=0;       

        Q->count=0;     //计数器置0   

     }

　　

 

② 判队空      

  int QueueEmpty(CirQueue *Q)   

     {        

     return Q->count==0;  //队列无元素为空      

   } 　

 

　③ 判队满

int QueueFull(CirQueue *Q)     

    {         

    return Q->count==QueueSize;  //队中元素个数等于QueueSize时队满         

} 　

 

　④ 入队

void EnQueue(CirQueuq *Q,DataType x)      

    {          

   if(QueueFull((Q))                            

          Error("Queue overflow");     //队满上溢        

     Q->count ++;                        //队列元素个数加1       

      Q->data[Q->rear]=x;                 //新元素插入队尾         

    Q->rear=(Q->rear+1)%QueueSize;      //循环意义下将尾指针加1 　　

 

⑤ 出队

DataType DeQueue(CirQueue *Q)      

     {       

        DataType temp;  

             if(QueueEmpty((Q))                  

  Error("Queue underflow");     //队空下溢              

temp=Q->data[Q->front];             

  Q->count--;                        //队列元素个数减1        

       Q->front=(Q->front+1)&QueueSize;   //循环意义下的头指针加1         

      return temp;          

  }               　　

 

⑥取队头元素

DataType QueueFront(CirQueue *Q)         

    {               

  if(QueueEmpty(Q))      

               Error("Queue if empty.");      

           return Q->data[Q->front];         

    }

 

 

链队列

一、队列的链式存储结构 队列的链式存储是用一个线性链表来实现一个队列的方法，线性链表表示的队列称为链队列。

在链队列中，链表的第一个节点存放队列的队首结点，链表的最后一个节点存放队列的队尾首结点，队尾结点的链接指针为空。并设一头指针指向队首结点，设一尾指针指向队尾结点。 当队列为空时，有head=NULL.

二、链队列上的基本运算

1 .入队列

1）进队算法

（1） 为待进队元素申请一个新结点，给该结点赋值；

（2）将x结点链到队尾结点上；

（3）队尾指针改为指向x结点。

2）实现程序

NODE *head=NULL, *tail;

Void link_ins_queue(elemtype x)

{

NODE *p;

p=(NODE *)malloc(sizeof(NODE));

p->data=x;

p->link=null;

if (head==null)   head=p;

else tail->link=p;

tail=p;

}

 

2. 出队列

1）出队算法

（1） 检查队列是否为空，若为空进行下溢错误处理；

（2）取队首元素的值并将队首指针暂存；

（3）头指针后移，指向新队首结点，并删除原队首结点。

2） 实现程序

int del_queue(elemtype *p_x)

{ NODE *p;

if (head= =NULL)　

return(1);

*p_x=head->data;

p=head;

head=head->link;

free(p);

return(0);

}

 

 

 

   注意： 　    增加指向链表上的最后一个结点的尾指针，便于在表尾做插入操作。     　链队列示意图见上图，图中Q为LinkQueue型的指针。

 

 注意：     　①和链栈类似，无须考虑判队满的运算及上溢。     　②在出队算法中，一般只需修改队头指针。但当原队中只有一个结点时，该结点既是队头也是队尾，故删去此结点时亦需修改尾指针，且删去此结点后队列变空。     　③以上讨论的是无头结点链队列的基本运算。和单链表类似，为了简化边界条件的处理，在队头结点前也可附加一个头结点，增加头结点的链队列的基本运算。