数据结构java（八）受限制的线性表 ①顺序结构实现（循环队列ArrayQueue）

1.创建Queue队列接口

/**
 * 先进先出
 * 队列接口
 * @author Administrator
 */
public interface Queue {
    /**
     * 返回队列大小
     * @return
     */
    int getSize();
 
    /**
     * 判断队列是否为空
     * @return
     */
    boolean isEmpty();
 
    /**
     * 数据元素e入队
     * @param e
     */
    void enqueue(Object e);
 
    /**
     * 队首元素出队
     * @return
     */
    Object dequeue();
    /**
     * 所有元素出队
     */
    void dequeueAll();
 
    /**
     * 取队首元素
     * @return
     */
    Object peek();
}

2.实现ArrayQueue循环队列

/**
 * 数组实现队列
 * @author Administrator
 */
public class ArrayQueue implements Queue {
    /**
     * 队列的计数器
     */
    private int count;
    /**
     * 队列的大小
     */
    private int size;
    /**
     * 底层是一个数组
     */
    private Object[] elementData;
 
    /**
     * @param initialCapacity 数组初始长度
     */
    public ArrayQueue(int initialCapacity){
        //给数组分配指定的空间
        elementData = new Object[initialCapacity];
        //指定顺序表元素个数
//        size = 0; int初始值是0
    }
 
    /**
     * 返回队列大小
     *
     * @return
     */
    @Override
    public int getSize() {
        return size;
    }
 
    /**
     * 判断队列是否为空
     *
     * @return
     */
    @Override
    public boolean isEmpty() {
        return size==0;
    }
 
    /**
     * 数据元素e入队
     *
     * @param e
     */
    @Override
    public void enqueue(Object e) {
        if (size>=elementData.length) {
            throw new MyArrayIndexOutOfBoundsException("栈满");
        }
        //队尾入队
        int last = count%elementData.length;
        elementData[last] = e;
        size++;
        count++;
    }
 
    /**
     * 队首元素出队
     *
     * @return
     */
    @Override
    public Object dequeue() {
        if (size==0){
            throw new MyArrayIndexOutOfBoundsException("空栈");
        }
        //队头出队
        int first = (count-size)%elementData.length;
        Object elementDatum = elementData[first];
        elementData[first]=null;
        size--;
        return elementDatum;
    }
 
    /**
     * 所有元素出队
     */
    @Override
    public void dequeueAll() {
        if (size==0){
            throw new MyArrayIndexOutOfBoundsException("空栈");
        }
        StringBuilder builder = new StringBuilder("[");
        for (int i = size;i>0;i--){
            if (i!=1){
                builder.append(dequeue()+",");
            }else {
                builder.append(dequeue());
            }
        }
        builder.append("]");
        System.out.println(builder);
 
 
    }
 
    /**
     * 取队首元素
     *
     * @return
     */
    @Override
    public Object peek() {
        if (size==0){
            throw new MyArrayIndexOutOfBoundsException("空栈");
        }
        //队头出队
        int first = (count-size)%elementData.length;
        return elementData[first];
    }
 
 
 
    @Override
    public String toString() {
        if (size == 0){
            return "[]";
        }
        StringBuilder builder = new StringBuilder("[");
        for (int i = 0;i<elementData.length;i++){
            if (i!=elementData.length-1){
                builder.append(elementData[i]+",");
            }else {
                builder.append(elementData[i]);
            }
        }
 
        builder.append("]");
        return builder.toString() ;
    }
}

3.测试

/**
 * 测试
 * @author Administrator
 */
public class ArrayQueueTest {
    Queue queue;
    @Before
    public void setUp() throws Exception {
        queue = new ArrayQueue(5);
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        System.out.println("操作前："+queue+"大小："+queue.getSize());
    }
 
    @After
    public void tearDown() throws Exception {
        System.out.println("操作后："+queue+"大小："+queue.getSize());
    }
 
    @Test
    public void enqueue() {
        queue.enqueue(4);
        queue.enqueue(5);
//        queue.enqueue(6);
    }
 
    @Test
    public void dequeue() {
        System.out.println(queue.dequeue());
        System.out.println("操作后："+queue+"大小："+queue.getSize());
        queue.enqueue(4);
        System.out.println("操作后："+queue+"大小："+queue.getSize());
        System.out.println(queue.dequeue());
        System.out.println("操作后："+queue+"大小："+queue.getSize());
        queue.enqueue(5);
        System.out.println("操作后："+queue+"大小："+queue.getSize());
        queue.enqueue(6);
        queue.enqueue(7);
        queue.dequeueAll();
//        queue.enqueue(8);
    }
 
    @Test
    public void dequeueAll() {
 
        queue.dequeueAll();
    }
 
    @Test
    public void peek() {
        System.out.println(queue.peek());
    }
}

下一篇：

 数据结构java（九）受限制的线性表 ②链式结构实现（双向链表队列LinkedQueue）