数据结构(栈)

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈只允许访问一个数据项：即最后插入的数据。移除这个数据项后才能访问倒数第二个插入的数据项。它是一种“后进先出”的数据结构。

栈最基本的操作是出栈、入栈，还有其他扩展操作，如查看栈顶元素，判断栈是否为空、是否已满，读取栈的大小等

先看一下栈(图解析)，在看代码

接下来看栈的代码

public class Stack<E> {

    private int length;

    private int top;

    private Object[] objArray;

    //构造方法
    public Stack(int lenth){
        if (lenth <= 0) throw new IllegalArgumentException("请不要传入0一下的数");
        objArray = new Object[lenth];
        this.top = -1;
        this.length = lenth;
    }

    //入栈 栈顶元素加一
    public void push(E e) throws Exception {
        if(isFull()){
            //各位同学，我就不自定异常了
            System.out.println("栈满了，别加了，先扩大容量");
            throw new Exception();
        }
        objArray[++top] = e;
    }

    //出栈 栈顶元素减一
    public Object pop() throws Exception {
        if(isEmpty()){
            System.out.println("栈空了，别减了，先加入元素");
            //各位同学，我就不自定异常了
            throw new Exception();
        }
        return objArray[top--];
    }

    //判断栈是否是空
    public Boolean isEmpty(){
        return top == -1 ? true : false;
    }

    //查看栈的顶部元素
    public Object view(){
        return objArray[top];
    }

    //判断是否栈满
    public Boolean isFull(){
        return top == length -1 ? true : false;
    }

    public static void main(String[] args) throws Exception {
        Stack<Integer> integerStack = new Stack<Integer>(5);
        integerStack.push(Integer.parseInt("1"));
        integerStack.push(Integer.parseInt("2"));
        integerStack.push(Integer.parseInt("3"));
        integerStack.push(Integer.parseInt("4"));
        Object view = integerStack.view();
        System.out.println(view);
        integerStack.pop();
        integerStack.pop();
        integerStack.pop();
        integerStack.pop();
        integerStack.pop();
        Object view1 = integerStack.view();
        System.out.println(view1);
    }
}

我们来写一个栈的实际应用

假设表达式中包含三种括号：圆括号、方括号和花括号，并且它们可以任意嵌套。例如{[()]()[{}]}或[{()}([])]等为正确格式，而{[}()]或[({)]为不正确的格式。那么怎么检测表达式是否正确呢？

这个问题可以用“期待的急迫程度”这个概念来描述。对表达式中的每一个左括号都期待一个相应的右括号与之匹配，表达式中越迟出现并且没有得到匹配的左括号期待匹配的程度越高。不是期待出现的右括号则是不正确的。它具有天然的后进先出的特点。

于是我们可以设计算法：算法需要一个栈，在读入字符的过程中，如果是左括号，则直接入栈，等待相匹配的同类右括号；如果是右括号，且与当前栈顶左括号匹配，则将栈顶左括号出栈，如果不匹配则属于不合法的情况。另外，如果碰到一个右括号，而堆栈为空，说明没有左括号与之匹配，则非法。那么，当字符读完的时候，如果是表达式合法，栈应该是空的，如果栈非空，那么则说明存在左括号没有相应的右括号与之匹配，也是非法的情况。
 

public class Match {

    private String input;

    public Match(String input){
        this.input = input;
    }

    //检查
    public void check() throws Exception{
        Stack<Character> stack = new Stack<>(input.length());
        for(int i=0;i<input.length();i++){
            char str = input.charAt(i);
            switch (str) {
                case '{':
                case '[':
                case '(':
                    stack.push(str);
                    break;
                case '}':
                case ']':
                case ')':
                    if(!stack.isEmpty()){
                        Character pop = (Character) stack.pop();
                        if((str == '(' && str != ')')|| (str == '[' && str != ']') || (str == '{' && str != '｝')){
                            System.out.println("匹配出错！字符："+str+",下标："+i);
                        }
                    }else{
                        System.out.println("匹配出错！字符："+str+",下标："+i);
                    }
                    default:break;
            }
        }
        if(!stack.isEmpty()){
            System.out.println("有括号没有关闭！");
        }
    }

    public static void main(String[] args)throws Exception{
        Match match = new Match("我是panda，我们一起学数据结构)");
        match.check();
    }

}

最后，我们看一下测试的结果