六、Java数据结构-栈(Stack)

计算机中的栈

我们把生活中的栈的概念引入到计算机中，就是供数据休息的地方，它是一种数据结构，数据既可以进入到栈中，又可以从栈中出去。
数据结构FILO（先进后出）【叠罗汉，上面的先下来】不同于队列中的FIFO（先进先出）【水管流水，只能从一端输出，和固定的一端方向删除】
栈是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。我们称数据进入到栈的动作为压栈，数据从栈中出去的动作为弹栈。

代码实现（通过链表来实现）

类名	MyStack
成员方法	1.public void clear()：清空栈 2.public boolean isEmpty()：判断栈是否为空，是返回true，否返回false 3.public int size():获取栈中元素的个数 4.public T pop():弹出栈顶元素 5.public void push(T t)：向栈中压入元素t
成员变量	1.private Node head :记录首结点 2.private int N:记录栈的元素个数

public class MyStack implements Iterable{
    Node head ;
    int N;
    public MyStack(){
        this.head = new Node(null,null);
        this.N = 0;
    }


    class Node{
        T item;
        Node next;
        public Node(T item ,Node next){
            this.item = item;
            this.next =next;
        }
    }
    public void clear(){
        head.next = null;
        N = 0;
    }
    public boolean isEmpty(){
        return N==0;
    }

    public int size(){
        return this.N;
    }

    public T pop(){
        Node oldNext = this.head;
        if(oldNext == null){
            return null;
        }
        this.head.next = oldNext.next.next;
        this.N --;
        return oldNext.item;
    }

    public void push(T t){
        Node curr = this.head.next;
        Node newNode = new Node(t, curr);
        this.head.next = newNode;
    }
    @Override
    public Iterator iterator() {
        return new MyIterator();
    }
    private class MyIterator implements Iterator{
        Node node = head ;
        @Override
        public boolean hasNext() {
            return node.next!=null;
        }

        @Override
        public T next() {
            node = node.next;
            return node.item;
        }
    }
}

栈的使用案例（逆波兰表达式）

逆波兰表达式求值问题是我们计算机中经常遇到的一类问题，要研究明白这个问题，首先我们得搞清楚什么是逆波兰表达式？要搞清楚逆波兰表达式，我们得从中缀表达式说起。

中缀表达式：

• 中缀表达式就是我们平常生活中使用的表达式，例如：1+3*2,2-(1+3)等等，中缀表达式的特点是：二元运算符总是置于两个操作数中间；

• 中缀表达式是人们最喜欢的表达式方式，因为简单，易懂。但是对于计算机来说就不是这样了，因为中缀表达式的运算顺序不具有规律性。不同的运算符具有不同的优先级，如果计算机执行中缀表达式，需要解析表达式语义，做大量的优先级相关操作。

逆波兰表达式(后缀表达式)：逆波兰表达式是波兰逻辑学家J・卢卡西维兹(J・ Lukasewicz)于1929年首先提出的一种表达式的表示方法，后缀表达式的特点：运算符总是放在跟它相关的操作数之后。

中缀表达式与逆波兰表达式转换表：

中缀表达式	逆波兰表达式
a+b	ab+
a+(b-c)	abc-+
a+(b-c)*d	abc-d*+
a*(b-c)+	dabc-*d+

假设需求：

给定一个只包含加减乘除四种运算的逆波兰表达式的数组，求出该逆波兰表达式的结果。
中缀表达式：5*(21-3)+21/7
逆波兰表达式：5 21 3 - * 21 7 / +

1.创建一个栈对象expression存储操作数;
2.从左往右遍历逆波兰表达式，得到每一个字符串;
3.判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中;
4.如果是运算符，则从expression栈中弹出两个操作数o1,o2;
5.使用该运算符计算o1和o2，得到结果result;
6.把该结果压入expression栈中;
7.遍历结束后，拿出栈中最终的结果返回;

代码实现

class MyStackTest{
    public static void main(String[] args) {
        int i = 5 * (21 - 3) + 21 / 7;
        System.out.println("中缀表达式计算结果："+i);
        String[] str = {"5", "21", "3", "-", "*", "21", "7", "/", "+"};
        Integer calculation = calculation(str);
        System.out.println("逆波兰表达式计算结果："+calculation);


    }
    public static Integer calculation(String[] arr){
        MyStack expression = new MyStack<>();
        for (String s : arr) {
            Integer o1,o2,result;
            switch (s){
                case "+":
                    o1 = expression.pop();
                    o2 = expression.pop();
                    result = o2 + o1;
                    expression.push(result);
                    break;
                case "-":
                    o1 = expression.pop();
                    o2 = expression.pop();
                    result = o2 - o1;
                    expression.push(result);
                    break;
                case "*":
                    o1 = expression.pop();
                    o2 = expression.pop();
                    result = o2 * o1;
                    expression.push(result);
                    break;
                case "/":
                    o1 = expression.pop();
                    o2 = expression.pop();
                    result = o2 / o1;
                    expression.push(result);
                    break;
                default:
                    expression.push(Integer.parseInt(s));
            }
        }
        return expression.pop();
    }
}