常见数据结构-队列

基础知识

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

1,一般队列

image.png

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

在这里插入图片描述

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

public class MyQueue {

    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 {

    //存储的元素
    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个
        data = a;
        //重新调整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;
    }
}

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

你可能感兴趣的:(常见数据结构-队列)