数据结构 之 栈（基于数组实现、支持动态扩容的顺序栈）

1.栈

栈：一种特殊的线性表，其值允许在固定的一段进行插入和删除元素操作。

进行数据插入和删除操作的一段叫做栈顶，另一端叫做栈底。

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

出站：栈的删除元素叫做出栈。出数据也在栈顶。

eg：栈的实现
栈的接口声明：

public interface Stack<T> {
    /**
     * 入栈
     * @param t
     * @return
     */
    boolean push(T t);

    /**
     * 出栈
     * @return
     */
    T pop();

    /**
     * 返回栈顶元素
     * @return
     */
    T peek();

    /**
     * 当前栈的元素个数
     * @return
     */
    int getSize();

    /**
     * 栈是否为空
     * @return
     */
    boolean isEmpty();
}

实现动态扩容的顺序栈：

import java.util.Arrays;
public class ArrayStack<T> implements Stack<T>{

    //存放数据
    private Object[] elementData;
    //最多存放的元素个数
    private  int maxSize;
    //当前栈中的元素个数
    private int currentSize;

    public ArrayStack(int maxSize){
        this.maxSize = maxSize;
        elementData = new Object[maxSize];
    }
    @Override
    public boolean push(T t) {
        if(currentSize == maxSize){
            //扩容
            int oldSize = maxSize;
            int newSize = oldSize << 1;
            if(newSize +8 > Integer.MAX_VALUE){
                System.out.println("栈太大！");
                return false;
            }
            maxSize = newSize;
            elementData = Arrays.copyOf(elementData,maxSize);
        }
        elementData[currentSize++] = t;
        return false;
    }

    @Override
    public T pop() {
        if(isEmpty()){
            return null;
        }
        return (T) elementData[--currentSize];
    }



    @Override
    public T peek() {
        if (isEmpty()){
            return null;
        }
        return (T) elementData[currentSize - 1];
    }

    @Override
    public int getSize() {
        return currentSize;
    }

    @Override
    public boolean isEmpty() {
        return currentSize == 0;
    }

}

栈的时间复杂度为O（1），空间复杂度为O（1）。