数据结构之队列

1、队列Queue，队列也是一种线性结构，相比数组，队列对应的操作是数组的子集，只能从一端（队尾）添加元素，只能从另一端（队首）取出元素。队列是一种先进先出的数据结构（或者称为先到先得），First In First Out（简称FIFO）。

2、封装的数组的代码，可以实现增加，修改，删除，查询，动态扩容，缩容，判断是否为空等等方法。

package com.company;


/**
 *
 */
public class Array<E> {

    private E[] data;//定义数组
    private int size;//数组实际的长度

    /**
     * 构造函数，传入数组的容量capacity构造Array
     *
     * @param capacity 初始化数据的容量长度
     */
    public Array(int capacity) {
        // 使用泛型，可以创建任意类型的数组类型
        data = (E[]) new Object[capacity];
        // 初始化数组的实际内容的长度为0
        size = 0;
    }

    /**
     * 无参数的构造函数，默认数组的容量capacity=10
     */
    public Array() {
        // 无参构造函数，指定初始化数组容量长度为0
        this(10);
    }

    /**
     * 获取数组中的元素个数
     *
     * @return
     */
    public int getSize() {
        // 获取到数组中的元素个数
        return size;
    }

    /**
     * 获取数组的容量
     *
     * @return
     */
    public int getCapacity() {
        // 获取到数组的容量
        return data.length;
    }

    /**
     * 返回数组是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        // 判断数组的长度是否为空
        return size == 0;
    }


    /**
     * 向所有元素后添加一个新元素
     *
     * @param e
     */
    public void addLast(E e) {
//        if (size == data.length) {
//            throw new IllegalArgumentException("AddLast failed,Array is full......");
//        } else {
//            在数组的末尾添加一个元素
//            data[size] = e;
//            添加元素以后数组长度加一
//            size++;
//        }

        // 调用公共的方法，其实就是在数组的实际长度后面添加指定的元素的。

        // 调用添加数组的方法，参数一，传入数组实际的长度，参数二，添加的元素
        add(size, e);
    }

    /**
     * 在第一个位置添加元素，在所有元素前添加一个新元素
     *
     * @param e
     */
    public void addFirst(E e) {
        // 在数组的第一个位置添加元素
        add(0, e);
    }


    /**
     * 在第index个位置插入一个新元素e
     *
     * @param index 在第index个位置
     * @param e     添加的元素内容
     */
    public void add(int index, E e) {
        // 判断位置index是否小于0或者索引index是否大于数组的实际长度size
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("add failed,Require index >= 0 and index <= size.......");
        }

        // 判断实际长度size是否等于数组的长度
        if (size == data.length) {
            // 可以直接抛出异常
            // throw new IllegalArgumentException("add failed,Array is full......");
            // 调用数组扩容的方法，扩容的长度为元数组长度的2倍
            resize(2 * data.length);
        }

        // 添加元素，就是在最后一个位置，将元素添加进去，即size的位置
        // 从后向前移动，从后面的元素向后移动
        // 如果传入的index是size，则初始化的位置是size-1，那么i的值大于等于传入的index(即size的值)，i递减

        // int i = size - 1是数组的实际长度的，即最后一个位置的元素
        // i >= index，是在指定索引位置添加索引
        // i--是为了将前面的元素向后面移动的。
        for (int i = size - 1; i >= index; i--) {
            // 后一个索引位置赋予前一个索引位置的值
            data[i + 1] = data[i];
        }
        // 将元素的内容插入到数组的index索引位置
        data[index] = e;
        // 数组的size递增
        size++;
    }

    /**
     * 私用扩容，扩容数组的长度
     *
     * @param newCapacity
     */
    private void resize(int newCapacity) {
        // 使用泛型创建对象，使用new Object的方法创建泛型的对象
        E[] newData = (E[]) new Object[newCapacity];
        // 循环，将原数组里面的内容放入到新数组里面，新数组的长度为元素组的2倍
        for (int i = 0; i < size; i++) {
            // 将原数组的值赋值给新数组的值
            newData[i] = data[i];
        }
        // 将原数组的值指向新数组，此操作，不影响原数组的正常使用
        data = newData;
    }

    /**
     * 获取Index索引位置的元素
     *
     * @param index
     * @return
     */
    public E get(int index) {
        // 如果索引index小于0或者索引的长度大于等于实际长度size，则抛出异常
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("add failed,Index is illegal......");
        }
        // 返回指定索引位置的数组元素
        return data[index];
    }

    /**
     * 获取到动态数组的第一个元素
     *
     * @return
     */
    public E getFirst() {
        return get(0);
    }

    /**
     * 获取到数组的最后一个元素
     *
     * @return
     */
    public E getLast() {
        // 调用获取元素的方法
        // 避免使用return data[size - 1]，可能会出现size=0的情况
        return get(size - 1);
    }

    /**
     * 修改index索引位置的元素e
     *
     * @param index
     */
    public void set(int index, E e) {
        // 如果索引index小于0或者索引的长度大于等于实际长度size，则抛出异常
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("add failed,Index is illegal......");
        }
        // 则将元素放入到数组的索引index位置
        data[index] = e;
    }


    /**
     * @return
     */
    @Override
    public String toString() {
        // 封装数组遍历的内容
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("Array : size = %d,capacity = %d\n", size, data.length));
        sb.append('[');
        for (int i = 0; i < size; i++) {
            sb.append(data[i]);
            if (i != size - 1) {
                sb.append(", ");
            }
        }
        sb.append(']');
        return sb.toString();
    }

    /**
     * 查找数据中是否包含元素e
     *
     * @param e
     * @return
     */
    public boolean contains(E e) {
        // 查看是否包含元素，进行遍历
        for (int i = 0; i < size; i++) {
            // 如果数组元素等于传入的元素e
            if (data[i].equals(e)) {
                // 返回true
                return true;
            }
        }
        return false;
    }

    /**
     * 查找数组中元素e所在的索引，如果不存在元素e，则返回-1
     *
     * @param e
     * @return
     */
    public int find(E e) {
        // 查看是否包含元素，进行遍历
        for (int i = 0; i < size; i++) {
            // 如果数组元素等于传入的元素e
            if (data[i].equals(e)) {
                // 返回该索引位置的索引
                return i;
            }
        }
        return -1;
    }

    /**
     * 从数组中删除index位置的元素，返回删除的元素
     *
     * @param index 此参数是索引参数
     * @return
     */
    public E remove(int index) {
        // 如果索引位置小于等于0或者索引位置大于等于数组的实际长度size
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove failed,Index is illegal......");
        }

        // 返回删除的元素，先获取到要删除的元素
        E result = data[index];
        // System.out.println(result);

        // 初始化值是要删除索引的位置加1，且i的值小于实际size的大小，i递减

        // int i = index + 1，传入进去的删除索引位置的元素
        // i < size，i小于数组的实际长度
        // i++，i递增
        for (int i = index + 1; i < size; i++) {
            // 将数组元素的值赋值被删除元素的位置上面
            // 即将数组元素向前移动，即第i位置的索引的数据移动到第i-1位置索引的数据
            data[i - 1] = data[i];
        }
        // 删除元素以后，数组长度size递减1
        size--;
        // 将不可访问的位置置空
        data[size] = null;

        // 避免出现复杂度震荡
        // 删除数组长度，缩小容量
        // data.length / 2 != 0，避免出现创建数组长度为0的数组
        if (size == data.length / 4 && data.length / 2 != 0) {
            // 缩容数组的长度
            resize(data.length / 2);
        }
        return result;
    }

    /**
     * 删除数组的第一个元素的值
     * <p>
     * 从删除中删除第一个元素，返回删除的元素
     *
     * @return
     */
    public E removeFirst() {
        // 删除数组的第一个位置的元素
        return remove(0);
    }

    /**
     * 从数组中删除最后一个元素，返回删除的元素。
     *
     * @return
     */
    public E removeLast() {
        // 删除数组最后一个位置的元素
        return remove(size - 1);
    }

    /**
     * 从数组中删除元素e
     *
     * @param e
     */
    public void removeElement(E e) {
        // 查看数组里面是否有该元素
        int index = find(e);
        // 如果查找到存在该元素
        if (index != -1) {
            // 调用删除数组元素的方法
            remove(index);
        }
    }

    public static void main(String[] args) {
        // 数组添加元素
        Array<Integer> array = new Array<>(20);
        for (int i = 0; i < 10; i++) {
            array.addLast(i);
        }

        System.out.println(array.toString());

        // 在指定位置添加元素
        array.add(1, 110);
        System.out.println(array.toString());

        // 在第一个位置添加元素
        array.addFirst(-1);
        System.out.println(array.toString());

        // 修改index索引位置的元素e
        array.set(1, 120);
        System.out.println(array.toString());

        // 是否包含某个元素
        boolean contains = array.contains(9);
        System.out.println(contains);

        // 删除指定索引位置的元素
        array.remove(2);
        System.out.println(array);

        // 删除第一个索引位置的元素
        array.removeFirst();
        System.out.println(array);

        // 删除最后一个位置的元素
        array.removeLast();
        System.out.println(array);

        // 从数组中删除元素e
        array.removeElement(110);
        System.out.println(array);
    }

}

3、使用泛型，可以接受任何数据类型的。声明队列的接口。

package com.queue;

/**
 *
 */
public interface Queue<E> {

    /**
     * 向队列中添加一个元素，入队。对应栈的入栈。
     *
     * @param e
     */
    public void enqueue(E e);

    /**
     * 从队列中取出一个元素，出队。对应栈的出栈。
     *
     * @return
     */
    public E dequeue();

    /**
     * 获取到队列中队首的元素。对应栈的查看栈顶的元素。
     *
     * @return
     */
    public E getFront();

    /**
     * 获取到队列的大小
     *
     * @return
     */
    public int getSize();

    /**
     * 判断队列是否为空
     *
     * @return
     */
    public boolean isEmpty();

}

创建实现Queue自定义接口队列的类，QueueStack队列，结合创建的Array<E>动态数组来实现栈的入队，出队，查看队首元素，判断队列是否为空等等操作。

package com.queue;

import com.company.Array;

/**
 * 队列是一种先进先出的数据结构（或者称为先到先得），First In First Out（简称FIFO）。
 * <p>
 * <p>
 * 1、public void enqueue(E e)入队方法，时间复杂度0(1)，均摊时间复杂度。
 * 2、public E dequeue()出队方法，时间复杂度0(n)。因为队首元素拿出去以后，后面所有元素前移一位。
 * 如果数据量很大，这回造成执行很慢，使用循环队列可以使时间复杂度变成O(1)。
 * 3、public E getFront()获取队首方法，时间复杂度0(1)。
 * 4、public int getSize()获取队列大小，时间复杂度0(1)。
 * 5、public boolean isEmpty()获取队列是否为空，时间复杂度0(1)。
 *
 * @param <E>
 */
public class ArrayQueue<E> implements Queue<E> {

    // 声明一个Array对象
    private Array<E> array;


    // Fn + Alt + Insert快捷键弹出构造函数

    /**
     * @param capacity 动态数组的容量大小
     */
    public ArrayQueue(int capacity) {
        //
        array = new Array<>(capacity);
    }

    /**
     * 无参的栈构造函数，创建一个默认容量大小的动态数组
     */
    public ArrayQueue() {
        array = new Array<>();
    }

    /**
     * 入队
     *
     * @param e
     */
    @Override
    public void enqueue(E e) {
        // 即向数组的末尾添加元素，如果动态数组容量不够，会触发动态数组的扩容机制
        array.addLast(e);
    }

    /**
     * 出队
     *
     * @return
     */
    @Override
    public E dequeue() {
        // 队列，是先进先出的，所以出队，是将开始的元素进行删除即可
        E first = array.removeFirst();
        return first;
    }

    /**
     * 获取队首元素
     *
     * @return
     */
    @Override
    public E getFront() {
        // 获取到队首元素
        E first = array.getFirst();
        return first;
    }

    /**
     * 查看队列大小
     *
     * @return
     */
    @Override
    public int getSize() {
        // 返回队列的大小
        return array.getSize();
    }

    /**
     * 判断队列是否为空
     *
     * @return
     */
    @Override
    public boolean isEmpty() {
        // 返回队列是否为空
        return array.isEmpty();
    }

    /**
     * 获取到队列的容量大小
     *
     * @return
     */
    public int getCapacity() {
        return array.getCapacity();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Queue: ");
        sb.append("front [");
        for (int i = 0; i < array.getSize(); i++) {
            sb.append(array.get(i));
            if (i != array.getSize() - 1) {
                sb.append(", ");
            }
        }
        sb.append("] tail");
        return sb.toString();
    }

    public static void main(String[] args) {
        ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
        // 入队操作
        for (int i = 0; i < 10; i++) {
            arrayQueue.enqueue(i);
            System.out.println(arrayQueue);
        }

        // 出队操作
        arrayQueue.dequeue();
        System.out.println("出队操作: " + arrayQueue);

        // 获取到队列的大小
        int size = arrayQueue.getSize();
        System.out.println("获取到队列的大小: " + size);

        // 获取到队首的元素
        Integer front = arrayQueue.getFront();
        System.out.println("获取到队首的元素: " + front);

        // 判断队列是否为空
        System.out.println("判断队列是否为空: " + arrayQueue.isEmpty());
    }

}

4、循环队列，初始的情况下，队列中无任何元素，front指向0位置，tail也指向0的位置。

　　1）、注意，front应该指向队列的第一个元素，tail指向的位置是指队列中最后一个元素的后一个位置。但是，当队列整体为空的时候，即队列中连第一个元素都没有的时候，此时，front和tail指向同一个位置，都是指向0的位置，即front和tail相等的时候，队列为空。
　　2）、如果队列不为空的时候，front和tail是不会相等的，如果此时，有一个元素入队了，此时，只要维护tail队尾就行了，tail指向下一次一个元素再入队时候的位置。如果是出队，只需要维护front即可，将front向下一个位置移动一个就行了。
　　3）、循环队列，如果出现出队操作，不再要求所有的元素都进行移动了，只需要front的指向改变即可，时间复杂度就变成了O(1)的操作。
　　4）、循环队列，如果队列的队尾tail移动到最后一个位置的时候，如果队列的队首front前面还有空闲的位置，那么队列的队尾tail可以指向队列的队首front的前面的位置。此时，队列可以看成是一个环形。
　　5）、front和tail相等的时候，队列为空。所以队列的队首front和队列的队尾tail之间会存在一个空闲的位置，是无法被填写元素的。队列的队满是tail + 1 == front，表示队列的队满，准确的说，是(tail + 1) % c == front表示队列队满了。
　　6）、tail指向的位置是指下一次有元素入队应该放入的位置，一旦有一个新的元素放入了，tail就应该加一。
　　7）、循环队列中，在capacity容量中，浪费一个空间。如果只剩下一个空间的时候，循环队列就已经满了，就可以进行扩容了。

4.1、循环队列的入队操作。

a、b、c、d、e元素入队，维护tail的位置，tail进行自增操作就行了。

4.2、循环队列的出队操作，此时，如果要进行循环队列出队操作，那么如何进行的呢。如果元素a出队，那么需要对front进行维护即可。

如果此时，b元素进行出队操作，如下所示：

4.3、循环队列的循环操作。

循环队列是如何进行循环操作的。准确的说是(tail + 1) % c == front表示循环队列满了。由于到了数组的末端，还可以返回到数组的前端，跑到数组前端的过程就是靠的求余操作。front == tail表示循环队列为空了。

package com.queue;

/**
 * 循环队列
 *
 * @param <E>
 */
public class LoopQueue<E> implements Queue<E> {

    private E[] data;//创建一个E类型的数组。
    private int front;//定义一个变量，表示队首指向的索引位置，指向队首所在的索引。
    private int tail;//定义一个变量，队列最后一个元素下一个位置，新元素入队存放的位置对应的索引。
    private int size;//队列里面有多少个元素。

    /**
     * 创建一个含参构造函数
     *
     * @param capacity 数据的容量大小，用户期望的循环队列的容量大小
     */
    public LoopQueue(int capacity) {
        // 创建一个E类型的数组data
        // 由于循环队列，需要浪费一个空间，所以容量大小是用户期望的容量大小加一。
        data = (E[]) new Object[capacity + 1];
        // 成员变量初始化大小
        front = 0;//指向队首所在的索引为0
        tail = 0;//队列最后一个元素下一个位置的索引为0
        size = 0;//循环队列的大小为0
    }

    /**
     * 创建一个无参的构造函数，初始化循环队列的容量为10
     */
    public LoopQueue() {
        // 初始化容量为10的循环队列
        this(10);
    }

    /**
     * 入队操作
     *
     * @param e
     */
    @Override
    public void enqueue(E e) {
        // 首先判断队列是否是满的。
        // 判断的标准就是队尾tail加一取余循环队列的长度即下一个tail的值等于队首front，就表示队列满了。
        // 取余操作，是让循环队列的整个索引循环起来，类比钟表循环。
        // 假如front是一点钟，tail是十二点钟，那么十二加一，取余十二就等于一，那么就表示该循环队列满了。
        // 因为循环队列要空出一个位置。
        if ((tail + 1) % data.length == front) {
            // 如果循环队列满了，进行循环队列扩容。扩容的大小是，此时循环队列的最多可以存放元素的个数乘以2
            // 此处，不使用data.length乘以二，因为data.length和循环队列最多可以盛放的元素个数之间有一个一的差距。
            resize(this.getCapacity() * 2);
        }

        // 此时，将要存放的元素存放到tail的位置上面。
        data[tail] = e;
        // 此时，因为是在循环队列里面，维护一下tail的位置。
        tail = (tail + 1) % data.length;
        // 维护size的大小
        size++;
    }

    /**
     * 循环队列进行扩容操作
     *
     * @param newCapacity
     * @return
     */
    private void resize(int newCapacity) {
        // 创建一个新的数组，将之前的元素放入到新的数组里面
        // 由于循环队列，需要浪费一个空间，所以容量大小是用户期望的容量大小加一。
        E[] newData = (E[]) new Object[newCapacity + 1];

        // 将之前的数组的所有元素，放入到新的数组里面
        for (int i = 0; i < size; i++) {
            // 将之前的数组的所有元素放入到新的数组的从零到size减一索引的位置上面。
            // 在之前的data数组里面，front队首元素有可能不是在零索引位置上面的，比如出队操作。
            // 此时，将data数组里面front队首元素放到新的数组里面的零索引的位置上面。
            // 此时newData[i]的位置不是对应data[i]的位置。
            // 因为newData[0]对应的就是data[front]，那么newData[1]对应的就是data[front + 1]，以此类推。
            // 所以说，newData[i]对应的是data[(i + front) % data.length]
            // data中的所有元素相对于newData中的所有元素索引值有一个(i + front)偏移的。
            // 由于整个队列是循环队列，所以队列要循环起来，(i + front)的值有可能会超过data的length长度，产生越界。
            // 所以可以进行取余数据长度操作。
            newData[i] = data[(i + front) % data.length];
        }

        // 将原来的数组data指向扩容以后的新数组newData
        data = newData;
        // 此时队首front变成了0
        front = 0;
        // 队尾tail变成了size，循环队列里面的元素个数不需要改变
        tail = size;
    }

    /**
     * 出队操作
     *
     * @return
     */
    @Override
    public E dequeue() {
        // 首先，判断队列是否为空，如果为空，直接抛出异常
        if (this.isEmpty()) {
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        }

        // 否则，如果此时队列不为空，就进行出队操作
        // 首先，对要出队的元素进行保存
        E result = data[front];
        // 将出队的元素的位置指向null。
        data[front] = null;

        // 维护front，因为是循环队列
        front = (front + 1) % data.length;

        // 维护size的大小，由于是出队，所以size的大小减一
        size--;

        // 出队，可以进行扩容操作，节约资源。如果size大小等于容量的四分之一的时候，就缩容到之前的二分之一
        // 并且缩容的值不等于0
        if (size == this.getCapacity() / 4 && this.getCapacity() / 2 != 0) {
            this.resize(this.getCapacity() / 2);
        }

        // 返回出队的元素内容
        return result;
    }

    /**
     * 查看循环队列的队首元素
     *
     * @return
     */
    @Override
    public E getFront() {
        // 首先，判断队列是否为空，如果为空，直接抛出异常
        if (this.isEmpty()) {
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        }
        return data[front];
    }

    /**
     * 获取到循环队列的大小
     *
     * @return
     */
    @Override
    public int getSize() {
        // 由于size就是维护的循环队列的大小
        return size;
    }

    /**
     * 判断循环队列是否为空
     *
     * @return
     */
    @Override
    public boolean isEmpty() {
        // 循环队列的队首front等于循环队列的队尾指向的下一个位置的tail相等的时候，即循环队列为空
        return front == tail;
    }

    /**
     * 返回循环队列的容量大小，初始化的时候容量加一，此时获取到循环队列容量的时候，记得减一。
     *
     * @return
     */
    public int getCapacity() {
        // 扩容的时候，data发生变化，那么扩容以后的data.length的长度就发生了变化
        return data.length - 1;
    }

    @Override
    public String toString() {
        // 封装数组遍历的内容
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("LoopQueue : size = %d,capacity = %d\n", size, this.getCapacity()));
        sb.append("front [");
        // 切记，i的初始化值是front。
        // i的最大值是不可以取到tail的值的。
        // i递增是(i + 1) % data.length。因为是循环队列。
        for (int i = front; i != tail; i = (i + 1) % data.length) {
            sb.append(data[i]);
            // 如果当前的索引不是最后一个元素的时候
            if ((i + 1) % data.length != tail) {
                sb.append(", ");
            }
        }
        sb.append(" ] tail ");
        return sb.toString();
    }

    public static void main(String[] args) {
        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        // 入队操作
        for (int i = 0; i < 20; i++) {
            loopQueue.enqueue(i);
            System.out.println(loopQueue.toString());
        }

        System.out.println();
        // 出队操作
        loopQueue.dequeue();
        System.out.println("循环队列出队操作: " + loopQueue);

        // 获取到队列的大小
        int size = loopQueue.getSize();
        System.out.println("获取到循环队列的大小: " + size);

        // 获取到队首的元素
        Integer front = loopQueue.getFront();
        System.out.println("获取到循环队列队首的元素: " + front);

        // 判断队列是否为空
        System.out.println("判断循环队列是否为空: " + loopQueue.isEmpty());
    }

}

执行效果，如下所示：

5、数组队列和循环队列的比较，性能测试。

package com.queue;

import java.util.Random;

/**
 *
 */
public class Main {

    /**
     * 测试使用queue运行opCount个enqueue和dequeue操作所需要的时间，单位：秒
     *
     * @param queue
     * @param opCount
     * @return
     */
    public static double queuePerforms(Queue<Integer> queue, int opCount) {
        // 开始时间
        long startTime = System.nanoTime();

        Random random = new Random();
        // 入队操作
        for (int i = 0; i < opCount; i++) {
            queue.enqueue(random.nextInt(Integer.MAX_VALUE));
        }

        // 出队操作
        for (int i = 0; i < opCount; i++) {
            queue.dequeue();
        }

        // 结束时间
        long endTime = System.nanoTime();

        // 秒与纳秒之前差九位数
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int opCount = 1000000;// 一百万次

        // 数组队列的性能
        // 影响数组队列性能的是出队操作，因为每一个元素都要进行前移操作
        ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
        double time1 = queuePerforms(arrayQueue, opCount);
        System.out.println("ArrayQueue, time:  " + time1 + " s");


        // 循环队列的性能
        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        double time2 = queuePerforms(loopQueue, opCount);
        System.out.println("LoopQueue, time: " + time2 + " s");
    }

}

 

作者：别先生

博客园：https://www.cnblogs.com/biehongli/

如果您想及时得到个人撰写文章以及著作的消息推送，可以扫描上方二维码，关注个人公众号哦。