我用Java学数据结构之队列底层实现 ^-^

队列同样是数据结构中最重要的之一啦，像树的层序遍历啥的，这里的接口同样与java内置队列的接口相同

public interface Queue<E> {
    int getSize();

    void enqueue(E e);

    E dequeue();

    boolean isEmpty();

    E getFront();
}

这里仍然采用动态数组做为底层实现，可以轻松的写出enqueue与dequeue方法，因为动态数组中包含addLast与removeFirst方法

import DynamicArray.Array;

/**
 * 数组队列，采用数组作为底层实现
 * @param <E>
 */
public class ArrayQueue<E> implements Queue<E> {
    private Array<E> array;

    public ArrayQueue(int capacity) {
        array = new Array<E>(capacity);
    }

    public ArrayQueue() {
        array = new Array<E>();
    }


    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public void enqueue(E e) {
        array.addLast(e);
    }

    @Override
    public E dequeue() {
        return array.removeFirst();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public E getFront() {
        return array.getFirst();
    }

    public int getCapacity() {
        return array.getCapacity();
    }

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

最后当然还是得测试性能的啦

同样是在十万个元素的入队与出队的操作上统计时间，进行对比

最后发现性能比较好的还是循环队列，与链表实现的队列

所以学习数据结构，掌握不同工具类的性能，才能更好的应用于实际中

后续也将继续实现循环队列与链队

import java.util.Random;

public class test {

    //测试使用q运行opCount个enqueue和dequeue操作所需要的时间
    private static double testQueue(Queue<Integer> q, int opCount) {
        Long startTime = System.nanoTime();

        Random random = new Random();
        for (int i = 0; i < opCount; i++) {
            q.enqueue(random.nextInt(Integer.MAX_VALUE));
        }

        for (int i = 0; i < opCount; i++) {
            q.dequeue();
        }
        Long endTime = System.nanoTime();

        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int opCount = 100000;
        ArrayQueue<Integer> arrayQueue = new ArrayQueue<Integer>();
        double time1 = testQueue(arrayQueue, opCount);
        System.out.println("ArrayQueue time:" + time1 + "s");

        LoopQueue<Integer> loopQueue = new LoopQueue<Integer>();
        double time2 = testQueue(loopQueue, opCount);
        System.out.println("LoopQueue time:" + time2 + "s");

        LinkedListQueue<Integer> linkedListQueue = new LinkedListQueue<Integer>();
        double time3 = testQueue(linkedListQueue, opCount);
        System.out.println("LinkedListQueue time:" + time3 + "s");
    }
}