使用我们自己的动态数组实现栈和队列

我们在我们自己实现的动态数组中实现栈和队列

                                                                                           栈 （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();
    }
}