（2）栈

栈是限定仅在表头进行插入和删除操作的线性表。栈作为一种数据结构，按照先进后出的原则存储数据，先进的数据被压在栈底，最后的数据放在栈顶，栈数据的插入称为入栈，栈数据的的删除称为出栈。
栈分为顺序栈和链式栈。
下面编写一个顺序栈，用数组实现。

public class Stack {

    private Object[] data;
    private int maxSize;    //栈容量
    private int top;        //栈顶指针，-1表示栈为空，因为0为第一个元素

    public Stack(int max){      //初始化栈
        this.maxSize = max;
        this.data = new Object[maxSize];
        this.top = -1;
    }

    public void push(Object value){ //入栈
        if(top == maxSize-1){   //判断栈是否满了
            System.out.println("栈已满");
            return;
        }
        data[++top] = value;
    }

    public Object pop(){    //删除栈顶元素
        if(top == -1){  //判断栈是否为空
            System.out.println("栈为空");
            return 0;
        }
        return data[top--]; 
    }

    public Object peek(){   //查看栈顶元素
        if(top == -1){
            System.out.println("栈为空");
            return 0;
        }
        //System.out.println(data[top]);
        return data[top];
    }

    public int search(Object o){    //查看对象在栈中的位置，以1为基数，返回0代表不存在
        int i = top;    //暂时存储栈顶指针
        while(top != -1){   //循环匹配元素
            if(peek() != o){
                top --;
            }
            else{   //匹配成功，跳出循环
                break;
            }
        }

        int result = top +1;    //top从0开始，位置+1
        top = i;    //复原指针
        return result;
    }

    public void printStack(){ //输出栈元素
        for(int i=top; i>=0; i--){
            System.out.print(data[i]+" ");
        }
    }   
}

链式栈：

public class LinkStack<T>{
    private class Node{
        private T data; //  保存节点数据
        private Node next;      //引用关系,指向下一节点的引用
        public Node(){}
        public Node(T data,Node next){//初始化节点
            this.data = data;
            this.next = next;
        }
    }

    private Node top;   //保存该链栈的栈顶元素
    private int size = 0;       //保存该链栈中已包含的节点数,即栈的长度

    public LinkStack(){
        top = null;
    }

    public LinkStack(T t){
        top = new Node(t,null);
        size++;
    }

    public int length(){    //当前栈长度
        return this.size;
    }

    public void push(T t){  //入栈
        top = new Node(t,top);
        size ++;
    }

    public T peek(){        //访问栈顶元素
        if(size == 0){
            throw new RuntimeException("空栈异常！");
        }
        else{
            return top.data;
        }
    }

    public T pop(){     //出栈
        Node oldTop = top;
        top = top.next;
        oldTop.next = null;
        size--;
        return oldTop.data;
    }

    public void printStack(){   //输出栈元素
        for(Node i = top; i!=null; i=i.next){
            System.out.print(i.data.toString()+" ");
        }
    }
}