我们在我们自己实现的动态数组中实现栈和队列
栈 （Stack）
一.定义
栈 （Stack）：是一种线性结构，相比数组，栈对应的操作是数组的子集
性质：只能从一端添加元素，也只能从一端取出元素（栈是一种后进先出的数据结构 Last In Frist Out（LIFO））
栈的应用：我们使用的undo操作，程序调用的系统栈
二.栈的实现
从用户的角度来看有，支持下面这些操作，具体底层实现用户并不关心，实际的底层有多种实现方式。因此我们将Stack定义为一个接口，使用我们自己封装的动态数组去实现。
三.数组栈的时间复杂度分析（由于使用的动态数组进行实现，涉及到resize操作，对pop和Push使用均摊复杂度）
队列（Queue）
一.定义
队列（Queue）：也是一种线性结构，相比数组，队列对应的操作是数组的子集
性质：只能从一端（队尾）添加元素，也只能从另一端（队首）取出元素（队列是一种先进先出的数据结构 Frist In Last Out（FIFO））
二.队列的实现（跟栈一样不需要知道底层实现，所以也实现一个接口）
三.数组队列的时间复杂度分析
四.数组队列的问题
我们可以看到出队操作：每次将队首的元素出队之后，我们都会将后面的元素往前移动，此时的时间复杂度为O（n）。
下面是删除队首元素的过程：
解决办法：当删除队首元素时我们把数据不向前移动，我们将队首使用front记录队首的状态。入队的时候使用tail记录尾部的状态
删除队首元素
五.循环队列（由于我们删除队首元素，front不断往后移，当入队的时候我们的tail也不断往后移，当tail到达capacity--1的位置时，此时就不能继续添加元素了，我们要做的就是让tail往回绕，这是循环队列的由来）
a.初始时
b.入队维护tail
c.出队维护front
当经过一系列的入队和出队操作以后，此时我们将tail最后一个不能放入了
因为我们需要将front = tail 为空，为了区分队空和队满，我们将capacity中，浪费一个空间
用front == tail 表示队列为空 tail+1==front 表示队列为满
tail+1 =front 队列为满其实是不准确的，准确的来说：是 (tail+1)%C = front 队列满，因为我们的tail会跑到我们数组的前端，靠的就是(tail+1)%C = front 来实现的看下一个tail的值是否等于front等于就是满的 C为整个容器的大小。
六.动态数组实现的循环队列的时间复杂度分析
栈的实现代码：
// 栈的接口
public interface Stack<E> {
int getSize();
boolean isEmpty();
void push(E e);
E pop();
E peak();
}
// 使用数组实现一个栈
public class ArrayStack<E> implements Stack<E>{
Array<E> array;
public ArrayStack(int capacity){
array = new Array<>(capacity);
}
public ArrayStack(){
array = new Array<>();
}
@Override
public int getSize() {
return array.getSize();
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
@Override
public void push(E e) {
array.addLast(e);
}
@Override
public E pop() {
return array.removeLast();
}
@Override
public E peak() {
return array.getLast();
}
@Override
public String toString(){
StringBuffer res = new StringBuffer();
res.append("stack: [");
for(int i=0; i<array.getSize(); i++){
res.append(array.get(i));
if(i != array.getSize()-1)
res.append(",");
}
res.append("] top");
return res.toString();
}
}
循环队列的实现代码：
//队列的接口：
public interface Queue<E> {
int getSize();
boolean isEmpty();
void enqueue(E e);
E dequeue();
E getFront();
}
// 使用数组实现一个队列
public class LoopQueue<E> implements Queue<E> {
private E[] data;
private int front,tail;
private int size; // 这里为了简单我们直接将size定义出来进行维护，其实可以使用front和tail进行维护，但是这里有resize操作可能没这么简单
public LoopQueue(int capacity){
data = (E[])new Object[capacity+1]; // 在实现循环队列的时候我们需要浪费掉一个空间
front = 0;
tail = 0;
size = 0;
}
public LoopQueue(){
data = (E[])new Object[10+1];
}
public int getCapacity(){
return data.length-1;
}
@Override
public int getSize() {
return size;
}
@Override
public boolean isEmpty() {
return front == tail;
}
@Override
public void enqueue(E e) {
if((tail+1)%data.length == front)
resize(getCapacity()*2);
data[tail] = e;
tail = (tail+1) % data.length;
size++;
}
private void resize(int newCapacity){
E[] newData = (E[])new Object[newCapacity+1];
for(int i=0; i<size; i++){
//有可能data 中的第一个元素就不是第一个元素了，由于是循环队列，数组可能会越界
newData[i] = data[(i+front) % data.length];
}
data = newData;
front = 0;
tail = size;
}
@Override
public E dequeue() {
if(isEmpty())
throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
E ret = data[front];
front = (front+1) % data.length;
size--;
if(size == getCapacity()/4 && getCapacity()/2 !=0)
resize(getCapacity()/2);
return ret;
}
@Override
public E getFront() {
if(isEmpty())
throw new IllegalArgumentException("queue is empty");
return data[front];
}
@Override // 其实这里栈中间的元素是不能看到的，只是我们这里为了方便查看
public String toString(){
StringBuffer res = new StringBuffer();
res.append(String.format("loopQueue: size =%d, capacity=%d\n", size,getCapacity()));
res.append("loopQueue: ");
res.append("front [");
for(int i=front; i != tail; i= (i+1)%data.length){
res.append(data[i]);
if((i+1) % data.length != tail)
res.append(",");
}
res.append("] tail");
return res.toString();
}
}