数据结构之队列

1.队列的定义

队列(Queue)：也是一种运算受限的特殊线性表。其插入和删除操作分别在线性表的两端进行（只允许在表的一端进行插入，而在另一端进行删除）。允许删除的一端称为队头(front)，允许插入的一端称为队尾(rear)

2.队列的操作

1. 一般情况下，入队(enqueue)操作又称为队列的插入。
2. 出队(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对象
    }
}