数据结构-3-队列

基础知识

队列是一种特殊的线性表，他的特殊性在于我们只能操作他头部和尾部的元素，中间的元素我们操作不了，我们只能在他的头部进行删除，尾部进行添加。就像大家排队到银行取钱一样，先来的肯定要排到前面，后来的只能排在队尾，所有元素都要遵守这个操作，没有VIP会员，所以走后门插队的现象是不可能存在的，他是一种先进先出的数据结构。我们来看一下队列的数据结构是什么样的

1，一般队列

他只能从左边进，右边出，队列实现方式一般有两种，一种是基于数组的，还一种是基于链表的，如果基于链表的倒还好说，因为链表的长度是随时都可以变的，这个实现起来比较简单。如果是基于数组的，就会稍微有点不同，因为数组的大小在初始化的时候就已经固定了，我们来看一下基于数组的实现，假如我们初始化一个长度是10的队列

front指向的是队列的头，tail指向的是队列尾的下一个存储空间，最初始的时候front=0，tail=0，每添加一个元素tail就加1，每移除一个元素front就加1，但是这样会有一个问题，如果一个元素不停的加入队列，然后再不停的从队列中移除，会导致tail和front越来越大，最后会导致队列无法再加入数据了，但实际上队列前面全部都是空的，这导致空间的极大浪费。我们自己来写一个简单的队列看一下

public class MyQueue<E> {
 
    private final Object[] data;
    private final int maxSize;
    private int size;
    private int front = 0;
    private int tail = 0;

    public MyQueue(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("队列容量必须大于0 : " + maxSize);
        }
        this.maxSize = maxSize;
        data = new Object[this.maxSize];
    }

    public void add(E e) {
        if (isFull()) {//这地方可以扩容也可以抛异常，为了方便这里我们就不在扩容了。
            throw new IllegalStateException("队列已经满了，无法再加入……");
        }
        data[tail++] = e;
        size++;
    }

    public E remove() {
        if (isEmpty()) {
            throw new IllegalStateException("队列是空的，无法移除……");
        }
        E t = (E) data[front];
        data[front++] = null;
        size--;
        return t;
    }

    //队列头和队列尾指向同一空间的时候，并且没到队尾，表示队列是空的
    public boolean isEmpty() {
        return front == tail && !isFull();
    }

    public boolean isFull() {//最后一个位置是不存储数据的
        return tail == maxSize - 1;
    }

    public int getSize() {
        return size;
    }
}

代码非常简单，当然队列的实现不一定是这一种方式，比如我们可以让tail指向队尾的元素，或者以链表的形式来实现都是可以的，不同的实现方式会导致上面的方法有所不同。我们来测试一下

public static void main(String[] args) {
    MyQueue myQueue = new MyQueue(10);
    System.out.println("isEmpty()=" + myQueue.isEmpty());
    System.out.println("isFull()=" + myQueue.isFull());
    System.out.println("getSize()=" + myQueue.getSize());
    for (int i = 0; i < 9; i++) {
        myQueue.add(i * 100);
        myQueue.remove();
    }
    System.out.println("----------------------------");
    System.out.println("isEmpty()=" + myQueue.isEmpty());
    System.out.println("isFull()=" + myQueue.isFull());
    System.out.println("getSize()=" + myQueue.getSize());
}

看一下打印的结果

    isEmpty()=true
    isFull()=false
    getSize()=0
    ----------------------------
    isEmpty()=false
    isFull()=true
    getSize()=0

我们添加了9次，然后又移除了9次，结果队列竟然满了，如果我们再添加一次的话肯定会抛异常，但实际上队列的size是0，还是空的，也就是说数组的每个位置只能使用一次，这样就造成了极大的浪费。那么前面使用过的空间还能不能再次利用了呢，实际上是可以的，我们可以把队列看成是环形的，当tail到达数组末尾的时候，如果数组的前面有空位子，我们可以让tail从头开始，这个时候一个新的队列就产生了，那就是双端队列。

 

2，双端队列

双端队列也是有两个指针，front指向队首，tail指向队尾的下一个存储单元，并且双端队列的队首和队尾都可以添加和删除元素，我们来看一下图

这样空间就可以循环利用了，不会造成浪费，我们来看下代码

public class MyQueue<E> {

    //存储的元素
    private Object[] data;

    //指向队列头，这个头并不是数组的第0个元素，如果这样
    // front就没有意义了，这个从下面的addFirst(E e)方
    // 法也可以看出，如果当front等于0的时候，在添加到
    // first，那么会添加到数组的末尾，并且front也指向
    // 数组的末尾
    private int front;

    //指向队列尾的下一个空间，可以这样理解，front指向
    // 的是第一个元素，tail指向的是最后一个元素的下一
    // 个，指的是空的。
    private int tail;


    public MyQueue(int numElements) {
        data = new Object[numElements];
    }

    //空间扩容，我们这里选择扩大一倍，当然也可以选择其
    // 他值，仅仅当满的时候才能触发扩容， 这时候front
    // 和tail都会指向同一个元素
    private void doubleCapacity() {
        int p = front;
        int n = data.length;//数组的长度
        //关键是r不好理解，举个例子，在数组中，front
        // 不一定是之前0位置的，他可以指向其他位置，
        // 比如原来空间大小为16，front为13，也就是第
        // 14个元素（数组是从0开始的），那么r就是16-13=3，
        // 也就是从front往后还有多少元素，待会copy的时候
        // 也是先从最后的r个元素开始
        int r = n - p;
        Object[] a = new Object[n << 1];//扩大一倍
        System.arraycopy(data, p, a, 0, r);//先copy后面的r个
        System.arraycopy(data, 0, a, r, p);//再copy前面的p个
        //重新调整front和tail的值
        front = 0;
        tail = n;
    }

    public void addFirst(E e) {
        //添加到front的前面，所以front-1
        front = (front - 1 + data.length) % data.length;
        data[front] = e;
        if (front == tail)//判断是否满了
            doubleCapacity();
    }

    public void addLast(E e) {
        //添加到最后一个，这个方法和addFirst有很明显的不同，
        // addFirst是添加的时候就要计算front的位置，而addLast
        // 方法是存值之后在计算tail的，/因为tail位置是没有
        // 存值的，他表示的末端元素的下一个，是空，所以存值之后
        //要计算tail的值
        data[tail] = e;
        tail = (tail + 1) % data.length;
        if (tail == front)//判断是否满
            doubleCapacity();
    }

    public E removeFirst() {//删除第一个
        if (isEmpty())
            throw new IllegalStateException("队列是空的，无法移除……");
        E result = (E) data[front];
        data[front] = null;
        // 删除第一个，这里的所有第一我们都认为是front所指的，
        // 不是数组的0位置，然后在计算front的值
        front = (front + 1) % data.length;
        return result;
    }

    public E removeLast() {//删除最后一个
        if (isEmpty())
            throw new IllegalStateException("队列是空的，无法移除……");
        tail = (tail - 1 + data.length) % data.length;
        E result = (E) data[tail];
        data[tail] = null;
        return result;
    }

    public E peekFirst() {
        if (isEmpty())
            throw new IllegalStateException("队列是空的，无法获取……");
        return (E) data[front];
    }

    public E peekLast() {
        if (isEmpty())
            throw new IllegalStateException("队列是空的，无法获取……");
        return (E) data[(tail - 1 + data.length) % data.length];
    }

    public int size() {//元素的size
        return (tail - front + data.length) % data.length;
    }

    //是否为空，在上面添加元素的时候也可能front==tail，当添加
    // 元素之后front==tail的时候就认为是满了，然后扩容，重新
    // 调整front和tail的值,所以扩容之后front就不可能等于tail。
    //如果没有触发上面添加元素的时候front等于tail我们就认为他是空的。
    public boolean isEmpty() {
        return front == tail;
    }
}

代码中都有详细的注释，就不在过多介绍。