数据结构--Java实现队列和循环队列（先进先出）

Java实现队列和循环队列

队列接口(Interface)

public interface MyQueueInterface<E> {
    
    
    /**
     * 入队
     */
    public void enqueue(E element);
    /**
     * 出队/删除
     */
    public E dequeue();
    /**
     * 获取队首元素
     */
    public E getFront();
    /**
     * 获取对内元素个数
     */
    public int getSize();
    /**
     * 半段队列是否为空
     */
    public boolean isEmpty();
}

队列实现类,容器使用自定义动态数组link

public class MyQueue<E> implements MyQueueInterface<E> {
    
    
    /*
    * 声明一个容器
    */
    MyArray<E> array;

    /**
     * 无参构造器
     */
    public MyQueue(){
    
    
        this(10);
    }

    /**
     * 有参构造器
     * @param capacity 声明容器容量
     */
    public MyQueue(int capacity){
    
    
        array = new MyArray<>(capacity);
    }

    /**
     * 入队,添加元素
     * @param element
     */
    @Override
    public void enqueue(E element) {
    
    
        array.addLast(element);
    }

    /**
     * 出队/删除元素
     * @return 被删除的元素,先进先出,只能从第一个开始删除
     */
    @Override
    public E dequeue() {
    
    
        return array.deleteFirstElement();
    }

    /**
     * 获取队首元素
     * @return 返回队首元素
     */
    @Override
    public E getFront() {
    
    
        return array.getElementByIndex(0);
    }

    /**
     * 获取队列内的元素个数
     * @return 返回队列内的元素个数
     */
    @Override
    public int getSize() {
    
    
        return array.size;
    }

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

    @Override
    public String toString() {
    
    
        StringBuffer str = new StringBuffer();
        str.append(String.format("队列容量为:%d,队列内的元素个数有:%d",array.getCapacity(),getSize()));
        str.append("[");
        for (int i = 0; i < getSize(); i++) {
    
    
            if (i != getSize()-1){
    
    
                str.append(array.getElementByIndex(i)+",");
            }else{
    
    
                str.append(array.getElementByIndex(i));
            }
        }
        str.append("]");
        return str.toString();
    }
}

队列实现类：循环队列，容器使用数组

public class MyLoopQueue<E> implements MyQueueInterface<E> {
    
    
    //声明一个容器
    private E[] data;
    //声明一个记录队列内元素个数的值
    private int size;
    //声明一个队首指针
    private int front;
    //声明一个指向下一个元素位置的队尾指针
    private int tail;

    /**
     * 无参构造器
     */
    public MyLoopQueue(){
    
    
        this(10);
    }

    /**
     * 有参构造器
     * @param capacity 容器的容量
     */
    public MyLoopQueue(int capacity){
    
    
        data = (E[])new Object[capacity];
        size = 0;
        front = 0;
        tail = 0;
    }

    /**
     * 入队/添加元素
     * @param element 需要入队/添加的元素
     */
    @Override
    public void enqueue(E element) {
    
    
        try {
    
    
            /*
            * 判断队列是否已经满了
            * 使用尾指针对数组长度进行取余运算确定数组是否已满,舍弃一个空间的大小*/
            if ((tail + 1) % data.length == front) {
    
    
                //扩容
                reSize(data.length << 1);
            } else {
    
    
                data[tail] = element;
                tail = (tail + 1) % data.length;
                size++;
            }
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

    /**
     * 对容器进行扩容
     * @param newCapacity 新容器的容量
     */
    private void reSize(int newCapacity){
    
    
        E[] newData = (E[])new Object[newCapacity];
        for (int i = 0; i < getSize(); i++) {
    
    
            newData[i] = data[(front+i) % data.length];
        }
        front = 0;
        tail = getSize();
        data = newData;
    }

    /**
     * 出队/删除元素
     * @return 返回被删除的元素
     */
    @Override
    public E dequeue() {
    
    
        E result = null;
        result = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        size--;
        if (size == data.length/2 && (data.length >> 1) >= 10){
    
    
            //对数组进行缩容
            reSize(data.length >> 1);
        }
        return result;
    }

    /**
     * 获取队列首位元素
     * @return 返回队列首位元素
     */
    @Override
    public E getFront() {
    
    
        return data[front];
    }

    /**
     * 获取队列内元素个数
     * @return 返回队列内元素个数
     */
    @Override
    public int getSize() {
    
    
        return size;
    }

    /**
     * 判断队列是否为空
     * @return 为空(true) or 不为空(false)
     */
    @Override
    public boolean isEmpty() {
    
    
        return front == tail;
    }

    @Override
    public String toString() {
    
    
        StringBuffer str = new StringBuffer();
        str.append(String.format("循环队列的容量为:%d,有效元素数量为:%d",data.length,getSize()));
        str.append("[队首:");
        for (int i = 0; i < data.length; i++) {
    
    
            if (i != data.length-1){
    
    
                str.append(data[(front + i) % data.length] + ",");
            }else{
    
    
                str.append(data[(front + i) % data.length]);
            }
        }
        str.append("]");
        return str.toString();
    }
}