数据结构笔记(四)

队列

一、定义

队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出的线性表，简称 FIFO。允许插入的一端为队尾，允许删除的一端称为队头。

三、循环队列

3.1、定义

头尾相接的顺序存储结构称为循环队列。

3.1.1、代码实现

/**
 * 循环队列
 */
class LoopQueue {

    private static final int MAX_SIZE = 100;

    Object[] dataList;

    /**
     * 队首指针
     */
    int front;

    /**
     * 队尾指针
     */
    int tail;

    /**
     * 队列中元素的个数
     */
    int size;

    int catacity = 10;

    public LoopQueue(int catacity) {
        this.catacity = catacity;
        this.dataList = new Object[catacity];
    }

    public LoopQueue() {
        this(MAX_SIZE);
        this.catacity = MAX_SIZE;
    }

    @Override
    public LoopQueue initQueue() {
        return new LoopQueue();
    }

    @Override
    void destroyQueue() {

    }

    @Override
    void clearQueue() {

    }

    @Override
    java.lang.Object getHead() {
        return null;
    }

    @Override
    void enQueue(java.lang.Object data) {

    }

    @Override
    java.lang.Object deQueue() {
        return null;
    }

    @Override
    int queueLength() {
        return (this.tail - this.front + MAX_SIZE) % MAX_SIZE;
    }


}

3.3、入队

void enQueue(Object data) throws Exception {
    if (queueLength() == this.catacity) {
        throw new Exception("队列已满");
    }
    this.tail = queueLength();
    dataList[queueLength()] = data;
}

3.4、出队

Object deQueue() throws Exception {
    if (queueLength() == 0) {
        throw new Exception("队列已空");
    }
    Object result = dataList[this.front];
    this.front++;
    return result;
}

四、队列的链式存储结构及实现

4.1、定义

队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，将其简称为链队列。

4.2、抽象数据类型

/**
 * 链表队列
 *
 * @param <T>
 */
abstract class LinkQueue<T> {
    T[] dataList;
	
    Node front, tail;
    
    int size;

    /**
     * 初始化操作，建立一个空队列
     */
    LinkQueue<T> initQueue() {
        return this;
    }

    /**
     * 若队列存在，则销毁
     */
    abstract void destroyQueue();

    /**
     * 将队列清空
     */
    abstract void clearQueue();

    /**
     * 队列是否为空
     *
     * @return true/false
     */
    boolean isEmpty() {
        return size == 0;
    }

    /**
     * 若队列存在且非空，则返回队头元素
     */
    abstract T getHead();

    /**
     * 若队列存在，将新元素 data 插入到队列中，并将其作为队尾元素
     *
     * @param data 新元素
     */
    abstract void enQueue(T data);

    /**
     * 删除队首元素，并返回该对象
     *
     * @return 队首元素
     */
    abstract T deQueue();

    /**
     * 返回队列中的元素个数
     */
    int queueLength() {
        return size;
    }

}

4.3、入队

void enQueue(T data) {
	Node lastNode = new Node(data);
    this.tail = lastNode;
}

4.4、出队

Object deQueue() {
    Object frontData = front.getData();
    front = front.next();
    return frontData;
}