双端队列是能在头尾两端添加,删除的队列(Deque)
代码实现:
/**
* 双端队列的实现
*/
public class Deque<E> {
private List<E> list = new LinkedList<>();
public int size(){
return list.size();
}
public boolean isEmpty(){
return list.isEmpty();
}
/**
* 从尾部入队
* @param element
*/
public void enQueueRear(E element){
list.add(element);
}
/**
* 从头部入队
* @param element
*/
public void enQueueFront(E element){
list.add(0,element);
}
/**
* 从尾部出队
* @return
*/
public E deQueueRear(){
return list.remove(list.size()-1);
}
/**
* 从头部出队
* @return
*/
public E deQueueFront(){
return list.remove(0);
}
/**
* 获取头部元素
* @return
*/
public E front(){
return list.get(0);
}
/**
* 获取尾部元素
* @return
*/
public E rear(){
return list.get(list.size()-1);
}
循环队列:底层用数组实现,循环的添加和删除元素
public class CircleQueue<E> {
private int front;
private int size;
private E[] elements;
private static final int DEFAULT_CAPACITY = 10;
public CircleQueue() {
elements = (E[]) new Object[DEFAULT_CAPACITY];
}
public int size(){
return size;
}
public boolean isEmpty(){
return size==0;
}
public void enQueue(E element){
ensureCapcity(size+1);
elements[(size+front)%elements.length] = element;
size++;
}
private void ensureCapcity(int capacity) {
int oldCapacity = elements.length;
if (oldCapacity>capacity) return;
//新容量为旧容量的1.5倍
int newCapacity = oldCapacity+(oldCapacity>>1);
E[] newElements = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[(i+front)%elements.length];
}
elements = newElements;
front = 0;
}
public E deQueue(){
E frontElement = elements[front];
elements[front] =null;
front = (front+1)%elements.length;
size--;
return frontElement;
}
public E front(){
return elements[front];
}
}