05-数据结构与算法（队列学习资料整理）

1.简介

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。

在队列这种数据结构中，最先插入的元素将是最先被删除的元素；反之最后插入的元素将是最后被删除的元素，因此队列又称为"先进先出"（FIFO—first in first out）的线性表。

对于顺序队列：

队列空的条件：front=rear

队列满的条件： rear - front = MAXSIZE

对于循环队列：

队列空的条件：front = rear

队列满的条件：front = ( rear+ 1) % MAXSIZE

2.队列的数组实现

队列可以用数组Q[1…m]来存储，数组的上界m即是队列所容许的最大容量。在队列的运算中需设两个指针：head，队头指针，指向实际队头元素的前一个位置；tail，队尾指针，指向实际队尾元素所在的位置。一般情况下，两个指针的初值设为0，这时队列为空，没有元素。数组定义Q[1…10]。Q(i) i=3,4,5,6,7,8头指针head=2，尾指针tail=8。队列中拥有的元素个数为:L=tail-head现要让排头的元素出队，则需将头指针加1。即head=head+1这时头指针向上移动一个位置，指向Q(3)，表示Q(3)已出队。如果想让一个新元素入队，则需尾指针向上移动一个位置。即tail=tail+1这时Q(9)入队。当队尾已经处理在最上面时，即tail=10，如果还要执行入队操作，则要发生"上溢"，但实际上队列中还有三个空位置，所以这种溢出称为"假溢出"。

克服假溢出的方法有两种。一种是将队列中的所有元素均向低地址区移动，显然这种方法是很浪费时间的；另一种方法是将数组存储区看成是一个首尾相接的环形区域。当存放到n地址后，下一个地址就"翻转"为1。在结构上采用这种技巧来存储的队列称为循环队列。

队列和栈一样只允许在断点处插入和删除元素。

循环队的入队算法如下：

1、tail=tail+1；

2、若tail=n+1，则tail=1；

3、若head=tail尾指针与头指针重合了，表示元素已装满队列，则作上溢出错处理；

4、否则，Q(tail)=X，结束（X为新入出元素）。

队列和栈一样，有着非常广泛的应用。

注意：（1）有时候队列中还会设置表头结点，就是在对头的前面还有一个结点，这个结点的数据域为空，但是指针域指向对头元素。

（2）另外，上面的计算还可以利用下面给出的公式cq.rear=(cq.front+1)/max;

当有表头结点时，公式变为cq.rear=(cq.front+1)/（max+1）。

3.队列的链表实现

在队列的形成过程中，可以利用线性链表的原理，来生成一个队列。

基于链表的队列，要动态创建和删除节点，效率较低，但是可以动态增长。

队列采用的FIFO(first in first out)，新元素（等待进入队列的元素）总是被插入到链表的尾部，而读取的时候总是从链表的头部开始读取。每次读取一个元素，释放一个元素。所谓的动态创建，动态释放。因而也不存在溢出等问题。由于链表由结构体间接而成，遍历也方便。

4.队列的基本运算

（1）初始化队列 Qini (Q)

（2）入队 QADD(Q,X)（3）出队 QDel(Q,X)

（4）判断队列是否为空 qempty(Q)

（5）判断队列是否为满qfull(Q)

5.c#的自定义队列

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

 

namespace ConsoleApplication7

{

class MyQueue

{

//存放元素的数组

private object[] _array;

//增长因子

private int _growFactor;

 

//对头

private int _head;

//队尾

private int _tail;

private int _size;

 

private const int _MinGrow = 4;

//初始容量

private const int _ShrikThreadhold = 0x20;

 

public MyQueue()

: this(_ShrikThreadhold, 2f)

{

}

 

public MyQueue(int capacity,float growFactor)

{

if (capacity<0)

{

throw new ArgumentOutOfRangeException("capacity", "初始容量不能为负！");

}

if ((growFactor<1.0)||(growFactor>10))

{

throw new ArgumentOutOfRangeException("growFactor", "增长因子应介于1和10之间!");

}

this._array = new object[capacity];

this._head = 0;

this._size = 0;

this._tail = 0;

this._growFactor= (int)( growFactor*100f);

}

 

//入队

public virtual void Enqueue(object obj)

{

 

if (this._size==this._array.Length)

{//队列已满

int capacity=(int )((this._array.Length*this._growFactor)/100L);

if (capacity<(this._array.Length+_MinGrow))

{

capacity = this._array.Length + _MinGrow;

}

SetCapacity(capacity);

}

this._array[this._tail] = obj;

this._tail = (this._tail + 1) % this._array.Length;

this._size++;

}

 

//内存设置

private void SetCapacity(int capacity)

{

object[] dest=new object[capacity];

if (this._head < this._tail)//尾指针在头指针后

{

Array.Copy(this._array,this._head,dest,0,this._size);

}

else//头指针在尾指针后

{

Array.Copy(this._array, this._head, dest, 0, this._array.Length - this._head);

Array.Copy(this._array, 0, dest, this._array.Length - this._head, this._tail);

}

 

this._array = dest;

this._head = 0;

this._tail = (this._size == capacity) ? 0 : this._size;

}

 

 

//出队

public virtual object Dequeue()

{

if (this._size==0)

{

throw new InvalidOperationException("队列为空");

 

}

object obj = this._array[this._head];//出队

this._array[this._head] = null;

this._head=(this._head+1)%this._array.Length;

this._size--;

return obj;

}

public virtual int Count

{

get { return this._size;}

}

}

}