动态数组-----循环队列的实现

队列优化

ArrayLoopQueue类

package shixianClass;

import shujujiegou_interface.Queue;

import java.util.Arrays;
import java.util.Iterator;

public class ArrayLoopQueue<E> implements Queue<E> {

    //存储元素的容器
    private E[] data;
    //队首指针front
    private int front;       //front==rear 表示队列空            //(rear+1)%data.length==front 表示队列满
    //队尾指针rear
    private int rear;
    //统计有效元素个数
    private int size;
    private static int DEFAULT_SIZE=10;
    //构造函数
    public ArrayLoopQueue(){
        this(DEFAULT_SIZE);
    }
    //capacity容量 存储元素的最大容量，为了条件统一，预留一个null空间；10+1  ---10个空间可用
    public ArrayLoopQueue(int capacity){
       data=(E[])new Object[capacity+1];
       front=0;
       rear=0;
       size=0;
    }

    //获取循环队列的有效元素的个数
    @Override
    public int size() {
        return size;
    }

    //判断循环队列是否为空
    @Override
    public boolean isEmpty() {
        return size==0&&front==rear;
    }

    //向循环队列中入队一个元素
    @Override
    public void offer(E element) {
      //判断是否需要扩容
        if((rear+1)%data.length==front){
            resize(data.length*2-1);
        }
        data[rear]=element;
        rear=(rear+1)%data.length;
        size++;
    }

    //循环队列出队一个元素
    @Override
    public E poll() {
        if(isEmpty()){
            throw new NullPointerException("queue is null");
        }
        E ret=data[front];
        front=(front+1)%data.length;
        size--;

        //判断是否需要缩容
        if(size==(data.length-1)/4&&data.length-1>DEFAULT_SIZE){
            resize(data.length/2+1);
        }
        return ret;
    }

    //扩容缩容操作
    private void resize(int newLength) {
        E[] newData=(E[])new Object[newLength];
        int index=0;
        for(int i=front;i!=rear;i=(i+1)%data.length){
            newData[index++]=data[i];
        }
        front=0;
        rear=index;
        data=newData;
    }

    //获取队首元素
    @Override
    public E element() {
        if(isEmpty()){
            throw new NullPointerException("queue is null");
        }
        return data[front];
    }

    //清空元素
    @Override
    public void clear() {
        data=(E[])new Object[DEFAULT_SIZE];
        front=0;
        rear=0;
        size=0;
    }

    @Override
    public String toString() {
        StringBuilder sb=new StringBuilder(String.format("ArrayLoopQueue:%d/%d[",size,data.length-1));
        if (isEmpty()){
            sb.append(']');
        }else {
            for (int i=front;i!=rear;i=(i+1)%data.length){
                sb.append(data[i]);
                if((i+1)%data.length==rear){
                    sb.append(']');
                }else {
                    sb.append(',');
                }
            }
        }
        return sb.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return new ArrayLoopQueueIterator();
    }
    class ArrayLoopQueueIterator implements Iterator<E>{
        private int cur=front;
        @Override
        public boolean hasNext() {
            return cur!=rear;
        }

        @Override
        public E next() {
            E ret=data[cur];
            cur=(cur+1)%data.length;
            return ret;
        }
    }
}

测试类TestArrayLoopQueue

package ceshi;

import shixianClass.ArrayLoopQueue;

import java.lang.reflect.Array;

public class TestArrayLoopQueue {
    public static void main(String[] args) {
        ArrayLoopQueue<Integer> queue=new ArrayLoopQueue<>();
        for(int i=1;i<=12;i++){
            queue.offer(i);
        }
        System.out.println(queue);
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue);
        for(int num:queue){
            System.out.print(num+" ");
        }

    }
}

执行结果

ArrayLoopQueue:12/20[1,2,3,4,5,6,7,8,9,10,11,12]
1
2
3
ArrayLoopQueue:9/20[4,5,6,7,8,9,10,11,12]
4 5 6 7 8 9 10 11 12