数据结构-----3.栈：

1.特点：遵循 “先进后出”的规则，栈主要包含两个操作，“入栈” 和 “出栈”，栈这种数据结构有两种实现方式：1.数组实现，2.链表实现。例如：浏览器的前进和后退功能就可以使用两个栈来实现，程序中函数的调用也是通过栈来实现。

基于数组实现的叫做“顺序栈”，基于链表实现的叫做“链式栈”。

空间复杂度的概念：除了必须存储数据的空间外，还需要在程序运行时，需要额外的空间。在栈的入栈和出栈过程中，所需要的空间复杂度为O(1)。

/*
* 使用数组来实现一个空间大小固定的栈*/
public class ArrayStack<E> {
    /*定义一个数组*/
    private Object[] elementData;

    /*该栈空间的大小*/
    private int size;

    /*当前栈中存储元素的个数*/
    private int count;

    public ArrayStack(int size) {
        this.elementData = new Object[size];
        this.size = size;
        this.count = 0;
    }

    /*
    * 入栈操作*/
    public boolean push(Object element) {
        /*栈中的数组空间如果不够了，那么直接返回false.
        * 因为count是从0开始的，size是从1开始的，所以当count == size时，不能再向栈中插入数据*/
        if(count == size) return false;
        /*如果数组可以存放数据，那么放在count的位置*/
        elementData[count] = element;
        count++;
        return true;
    }

    /*
    * 出栈操作*/
    public E pop() {
        /*首先判断栈中元素的个数是否为空*/
        if(count == 0) return null;
        E element = (E)elementData[count-1];
        count--;
        return element;
    }

    public static void main(String[] args) {
        //泛型针对的是”引用“而言，对于后面在堆中存储的对象，不起约束作用
        ArrayStack stack = new ArrayStack<String>(5);
        for(int i=0;i<=5;i++) {
            System.out.println(stack.push(i)+"  ,"+i);
        }
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
    }
}

/**
 *使用链表实现一个链式栈
 */
public class LinkedListStack<T> {

    /*定义一个栈顶指针*/
    private StackNode top = null;

    /*入栈操作*/
    public void push(Object value) {
        StackNode newNode = new StackNode(value,null);
        if(top == null) {
            top = newNode;
        }else {
            /*首先设定新节点的后继节点为top,然后移动top指针，将top指向新节点*/
            newNode.setNext(top);
            top = newNode;
        }
    }

    /*出栈操作*/
    public T pop() {
        if(top == null) return null;
         /*将value类型强转为泛型类型*/
         T value = (T)top.getValue();
        top = top.getNext();
        return value;
    }

    /*打印栈中的所有元素*/
    public void printAllElements() {
        if(top == null) return;
        while (top != null) {
            System.out.println(top.getValue());
            top = top.getNext();
        }
    }

    private class StackNode<T> {
        /*节点值*/
        private T value;
        /*指向的下一个节点*/
        private StackNode next;

        public StackNode(T value,StackNode next) {
            this.value = value;
            this.next = next;
        }

        public T getValue() {
            return value;
        }

        public void setValue(T value) {
            this.value = value;
        }

        public StackNode getNext() {
            return next;
        }

        public void setNext(StackNode next) {
            this.next = next;
        }
    }

    public static void main(String[] args) {
        LinkedListStack<Integer> stack = new LinkedListStack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.pop();
        stack.printAllElements();
    }
}