1.队列的定义
队列(Queue):也是一种运算受限的特殊线性表。其插入和删除操作分别在线性表的两端进行(只允许在表的一端进行插入,而在另一端进行删除)。允许删除的一端称为队头(front),允许插入的一端称为队尾(rear)
2.队列的操作
- 一般情况下,入队(enqueue)操作又称为队列的插入。
- 出队(dequeue)操作又称为队列的删除。
3.队列的运算
队列的基本运算通常和栈的基本运算类似,有以下6种:
① 置空队; //构造一个空队列
② 判队空; //队空返回真,否则返回假。
③ 判队满; //队满返回真,否则返回假,仅限于顺序存储结构。
④ 入队; //队列非满时,从队尾插入元素。
⑤ 出队; //队列非空时,从队首删除元素。
⑥ 取队首元素; //返回队首元素,不修改队首指针。
4.队列的溢出
队列的溢出:队列在顺序存储时,经常出现“假溢出”现象,解决“假溢出”现象的方法有很多种,但通常采用循环队列方式存储。
5.队列抽象数据类型ADT,队列接口
//队列接口,描述队列抽象数据类型,T表示元素类型
public interface Queue<T>
{
public abstract boolean isEmpty(); //判空
public abstract boolean add(T x); //x入队
public abstract T peek(); //返回队头,没有删除
public abstract T poll(); //出队,返回队头
}
6.队列的分类
队列的存储具有顺序和链式存储两种,因此队列可分为顺序队列和链式队列
7.队列的表示和实现
8 顺序队列
定义:队列的顺序存储结构称为顺序队列
假溢出:是指在入队和出队操作中,头尾指针不断增加而不减小或只减小而不增加,致使被删除元素的空间无法重新利用,最后造成队列中有空闲空间,但是不能够插入元素,也不能够删除元素的现象、
9 顺序循环队列(解决假溢出)
定义:将顺序队列设计成在逻辑上首尾相接的循环结构,则可循环使用顺序队列的连续存储单元。
9.1 循环队列的操作
• 入队时:rear=(rear+1)% maxsize
• 出队时:front=(front+1)% mixsize
9.2 顺序循环队列的实现
接口类:
//顺序循环队列类,最终类,实现队列接口,T元素类型
public final class SeqQueue<T> implements Queue<T>
{
private Object element[]; //数组
private int front, rear; //队列头尾下标
public SeqQueue(int capacity)//构造空队列
public SeqQueue() //构造空队列
public boolean isEmpty(); //判空
public boolean add(T x); //x入队
public T peek(); //返回队头,没有删除
public T poll(); //出队,返回队头
}
接口实现类:
public class SeqQueue<T> {
private Object element[]; //存储队列数据元素的数组
private int front, rear; //front、rear分别为队列头尾下标
public SeqQueue(int length) //构造容量为length的空队列
{
if (length < 64)
length = 64; //设置队列数组容量最小值
this.element = new Object[length];
this.front = this.rear = 0; //设置空队列
}
public SeqQueue() //构造默认容量的空队列
{
this(64);
}
public boolean isEmpty()
//判断队列是否空,若空返回true
{
return this.front == this.rear;
}
public boolean add(T x) //元素x入队,空对象不能入队
{
if (x == null)
return false;
// throw new NullPointerException("x==null"); //抛出空对象异常
if (this.front == (this.rear + 1) % this.element.length) //若队列满,则扩充数组
{
Object[] temp = this.element;
this.element = new Object[temp.length * 2]; //重新申请一个容量更大的数组
int j = 0;
for (int i = this.front; i != this.rear; i = (i + 1) % temp.length)
//按照队列元素次序复制数组元素
this.element[j++] = temp[i];
this.front = 0;
this.rear = j;
}
this.element[this.rear] = x;
this.rear = (this.rear + 1) % this.element.length;
return true;
}
public T peek()
//返回队头元素,没有删除。若队列空,则返回null
{
return this.isEmpty() ? null : (T) this.element[this.front];
}
public T poll() //出队,返回队头元素,若队列空返回null
{
if (this.isEmpty())
return null;
T temp = (T) this.element[this.front];
this.front = (this.front + 1) % this.element.length;
return temp;
}
public String toString()
//返回队列所有元素的描述字符串,形式为“(,)”,按照队列元素次序
{
StringBuffer strbuf = new StringBuffer(this.getClass().getName() + "(");
for (int i = this.front; i != this.rear; i = (i + 1) % this.element.length)
strbuf.append(this.element[i].toString() + ",");
//按照队列元素次序复制数组元素
strbuf.setCharAt(strbuf.length() - 1, ')');
//将串最后多余的一个字符','改为')'
return new String(strbuf); //由StringBuffer对象构造String对象
}
}
10 链队列
定义:采用链式存储结构的队列,它是一种特殊的线性表,只能对头部和尾部进行操作
10.1 接口实现类
public final class LinkedQueue<T> implements Queue<T>
{
private Node<T> front, rear; //队头和队尾结点
public LinkedQueue() //构造空队列
public boolean isEmpty(); //判空
public boolean add(T x); //x入队
public T peek(); //返回队头,没有删除
public T poll(); //出队,返回队头
}
10.2 接口具体实现类
public class LinkedQueue<T> implements Queue<T> {
private Node<T> front, rear;
//front和rear分别指向队头和队尾结点
public LinkedQueue()
//构造空队列
{
this.front = this.rear = null;
}
public boolean isEmpty()
//判断队列是否空,若空返回true
{
return this.front == null && this.rear == null;
}
public boolean add(T x) //元素x入队,空对象不能入队
{
if (x == null)
return false;
// throw new NullPointerException("x==null"); //抛出空对象异常
Node<T> q = new Node<T>(x, null);
if (this.front == null)
this.front = q; //空队插入
else
this.rear.next = q; //队列尾插入
this.rear = q;
return true;
}
public T peek()
//返回队头元素,没有删除。若队列空,则返回null
{
return this.isEmpty() ? null : this.front.data;
}
public T poll() //出队,返回队头元素,若队列空返回null
{
if (isEmpty())
return null;
T x = this.front.data; //取得队头元素
this.front = this.front.next; //删除队头结点
if (this.front == null)
this.rear = null;
return x;
}
public String toString()
//返回队列所有元素的描述字符串,形式为“(,)”
{ //算法同不带头结点的单链表
StringBuffer strbuf = new StringBuffer(this.getClass().getName() + "(");
for (Node<T> p = this.front; p != null; p = p.next)
strbuf.append(p.data.toString() + ",");
//按照队列元素次序复制数组元素
strbuf.setCharAt(strbuf.length() - 1, ')');
//将串最后多余的一个字符','改为')'
return new String(strbuf); //由StringBuffer对象构造String对象
}
}