手动实现双端队列【练习】

package circle;

/**
 * @author 长静有希
 * @description 双端队列
 * @date 2021-12-03 15:41
 */
public class CircleDeque<E> {

    // 用于存储对头元素下标
    private int front;

    private int size;

    // 用于存储数据
    private E[] elements;

    // 初始容量
    private static final int DEFAULT_CAPACITY = 10;

    public CircleDeque() {
        elements = (E[]) new Object[DEFAULT_CAPACITY];
    }

    /**
     * 从头部入队
     * @return: void
     **/
    public void enDequeFront(E element) {

        // 动态扩容判断
        ensureCapacity(size + 1);

        // 因为需要从头部前一个插入元素，所以计算出头部位置后需要覆盖原front的值
        front = index(-1);
        elements[front] = element;
        size++;
    }


    public boolean isEmpty() {
        return size == 0;
    }
    /**
     * 从尾部入队
     * @return: void
     **/
    public void enDequeRear(E element) {
        // 动态扩容判断
        ensureCapacity(size + 1);
        elements[index(size)] = element;
        size++;
    }

    /**
     * 从头部出队
     * @return: E
     **/
    public E deDequeFront() {
        // 需要出队，所有需要获取队头元素
        E frontElement = elements[front];

        // 出队完赋值为空
        elements[front] = null;

        // 队头指向下一个元素
        // 因为当数组队头指向后面，而队尾在前面的时候，直接front++ 会越界，
        // 所有需要对数组长度进行取模
        front = index(1);

        size--;
        return frontElement;
    }

    /**
     * 从尾部出队，相当于删除尾部元素
     * @return: E
     **/
    public E deDequeRear() {
        // 获取尾部元素的真实索引
        int rearIndex = index(size -1);
        // 获取出队元素
        E rear = elements[rearIndex];

        // 赋空
        elements[rearIndex] = null;
        size--;
        return rear;
    }

    /**
     * 获取对头元素
     * @return: E
     **/
    public E front() {
        return elements[front];
    }

    /**
     * 获取队尾元素
     * @return
     */
    public E rear() {
        return elements[index(size -1)];
    }



    /**
     * 获取front真实指向位置
     * @return: int
     **/
    private int index(int index) {

        index += front;

        // 当需要向头部添加元素时，而头部指向的下标为 0
        // 因为 -1 % elements.length 取余为负数，数组中没有负数
        // 所以需要对其进行特殊处理
        if(index < 0) {
            return index + elements.length;
        }
		// return index % elements.length;

        // 优化取模写法
        return index - (index >= elements.length ? elements.length : 0);
    }

    /**
     * 动态扩容
     * 需要保证要有capacity大小的容量
     * @return: void
     **/
    private void ensureCapacity(int capacity) {
        // 旧的容量
        int oldCapacity = elements.length;
        // 如果旧的容量大于或等于需要的容量，则不需要扩容
        if (oldCapacity >= capacity) return;

        // 新的容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 存储元素
        E[] newElements = (E[]) new Object[newCapacity];

        for (int i = 0; i < size; i++) {
            newElements[i] = elements[index(i)];
        }
        elements = newElements;

        // 创建了新数组，队头重新指向 0
        front = 0;
    }



    @Override
    public String toString() {

        StringBuilder string = new StringBuilder();

        string.append("capacity=").append(elements.length)
                .append(" size= ").append(size)
                .append(" front= ").append(front)
                .append(", [");

        for (int i  = 0; i < elements.length; i++) {
            if (i != 0) {
                string.append(", ");
            }
            string.append(elements[i]);
        }
        string.append("]");
        return string.toString();
    }
}