数据结构（四）---栈

栈

手写数组模拟栈

（1）栈类
数组模拟栈的思路分析：
1-使用数组来模拟栈
2-定义一个top来表示栈顶，初始化为-1
3-入栈的操作，当有数据加入到栈时，top++; stack[top]=data;
4-出栈的操作，int value=stack[top]; top–, return value

//定义一个类，表示栈
class ArrayStack{
    private int maxSize;//栈的大小
    private int stack[];//数组，数组模拟栈，数据就放在数组里
    private int top=-1;//top表示栈顶，初始化为-1

    //构造器
    public ArrayStack(int maxSize){
        this.maxSize=maxSize;
        stack=new int[this.maxSize];
    }

    //栈满
    public boolean isFull(){
        return top==maxSize-1;
    }

    //栈空
    public boolean isEmpty(){
        return top==-1;
    }

    //入栈操作
    public void push(int value){
        //先判断栈是不是满了
        if (isFull()){
            System.out.println("栈已经满了");
            return;
        }
        //不为满的时候，top后移,把值插入到数组里去
        top++;
        stack[top]=value;
    }

    //出栈操作
    public int pop(){
        //先判断栈是不是空的
        if (isEmpty()){
            //抛出异常
            throw new RuntimeException("栈是空的");
        }
        int outValue = stack[top];
        top--;
        return outValue;
    }

    //遍历栈的值
    public void list(){
        //先判断栈是不是空的，如果是空的就抛出异常
        if (isEmpty()){
            System.out.println("栈为空");
            return;
        }
        //从栈顶开始往下逐个显示数据
        for (int i = top; i >= 0; i--) {
            int value=stack[i];
            System.out.printf("stack[%d] = %d\n",i,stack[i]);
        }

    }
}

（2）测试类

public class ArrayStackDemo {
    public static void main(String[] args) {
        ArrayStack stack=new ArrayStack(10);
        //测试添加
        stack.push(8);
        stack.push(3);
        stack.push(6);
        stack.push(1);
        stack.push(4);
        stack.push(6);
        stack.push(9);
        //测试删除
        stack.pop();
        //测试遍历
        stack.list();
    }
}

手写链表模拟栈

（1）创建节点类

class Node{
    private int value;//节点的值
    private Node next;//栈顶指针节点

    public int getValue() {
        return value;
    }

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

    public Node getNext() {
        return next;
    }

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

    // public Node(int value) {
    //     this.value = value;
    // }
}

（2）创建栈类

class ListStack{
    private Node base;
    private Node top;
    private Integer size;

    //栈的初始化
    public void InitStack(){
        top=base=new Node();
        size=0;
    }

    //获取栈的大小
    public int StackLenth(){
        return this.size;
    }

    //入栈
    public void Push(int value){
        Node newNode=new Node();
        newNode.setValue(value);
        top.setNext(newNode);
        top=newNode;
        size++;
    }

    //出栈
    public int Pop(){
        if (base==top){
            throw new RuntimeException("栈为空");
        }
        int value=top.getValue();
        size--;
        Node node=base;

        while (node.getNext().getNext()!=null){
            node=node.getNext();
        }
        node.setNext(null);
        top=node;
        return value;
    }

    //遍历栈
    public void list(){
        if (base==top){
            System.out.println("栈为空");
        }
        for (int i = size; i > 0; i--) {
            // System.out.printf("stack[%d]=%d",i,i);
        }
    }

}

栈实现综合计算器

（1）先用数组创建一个栈

//先创建一个栈
//定义一个类，用数组表示栈，需要扩展功能
class ArrayStack {
    private int maxSize;//栈的大小
    private int stack[];//数组，数组模拟栈，数据就放在数组里
    private int top = -1;//top表示栈顶，初始化为-1

    //构造器
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    //栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //入栈操作
    public void push(int value) {
        //先判断栈是不是满了
        if (isFull()) {
            System.out.println("栈已经满了");
            return;
        }
        //不为满的时候，top后移,把值插入到数组里去
        top++;
        stack[top] = value;
    }

    //出栈操作
    public int pop() {
        //先判断栈是不是空的
        if (isEmpty()) {
            //抛出异常
            throw new RuntimeException("栈是空的");
        }
        int outValue = stack[top];
        top--;
        return outValue;
    }

    //遍历栈的值
    public void list() {
        //先判断栈是不是空的，如果是空的就抛出异常
        if (isEmpty()) {
            System.out.println("栈为空");
            return;
        }
        //从栈顶开始往下逐个显示数据
        for (int i = top; i >= 0; i--) {
            int value = stack[i];
            System.out.printf("stack[%d] = %d\n", i, stack[i]);
        }

    }

    //返回运算符的优先级，优先级由程序员来确定，优先级使用数字表示
    //数组越大，优先级就越高
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;//假定目前的表达式只有这些
        }
    }

    //判断是不是一个运算符
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    //计算方法
    public int cal(int num1, int num2, int oper) {
        int res = 0;//用于存放计算的结果
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }

    //返回当前栈顶的值，但是不是真正的出栈pop
    public int peek() {
        return stack[top];
    }
}

（2）使用栈类实现计算器

/**
 * 使用栈来完成表达式的计算思路：
 * 中缀表达式计算器
 * <p>
 * 1）通过一个index值（索引），来遍历我们的表达式
 * 2）如果我们发现是一个数字，就直接入栈
 * 3）如果我们扫描到的是一个符号，就分一下情况
 * 3.1）如果发现当前的符号栈是空的，直接入栈
 * 3.2）如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符
 * 就需要从数栈里pop出两个数，再从符号栈里pop出一个符号，进行运算，把得到的结果再push入数栈，当前符号入符号栈
 * 如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
 * 4）当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并且运行
 * 5）最后，在数栈只有一个数字，就是表达式的结果
 *
 * @ClassName: Calculator
 * @Author: AllenSun
 * @Date: 2019/11/3 14:00
 */
public class Calculator {
    public static void main(String[] args) {
        //根据前面的思路，完成表达式的计算
        String expression = "7*2*2-5+1-5+3-4";
        //创建两个栈，一个是数栈，一个是符号栈
        ArrayStack numStack = new ArrayStack(10);
        ArrayStack operStack = new ArrayStack(10);
        //定义需要的相关变量
        int index = 0;//用于扫描的
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';//把每次扫描得到的char保存到ch
        String keepNum = "";//用来拼接多位数

        //开始while循环的扫描expression
        while (true) {
            //先依次得到expression里的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);
            //开始判断ch是什么，做相应的处理
            //1-如果是运算符号
            if (operStack.isOper(ch)) {
                //判断当前的符号栈是不是空的
                if (!operStack.isEmpty()) {
                    //处理，如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符
                    //就需要从数栈里pop出两个数，再从符号栈里pop出一个符号，进行运算，把得到的结果再push入数栈，当前符号入符号栈
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        //把运算的结果入数栈
                        numStack.push(res);
                        //当前的符号还要入符号栈
                        operStack.push(ch);
                    } else {
                        //如果当前的操作符的优先级大于栈中的操作符，就直接入栈
                        operStack.push(ch);
                    }
                } else {
                    //如果为空，就直接入符号栈
                    operStack.push(ch);
                }
            } else {
                //如果是数，就直接入数栈
                //1-注意多位数72，当发现数字时直接入栈，就会把7入栈，只能分别字符7，而不是数字72
                //2-在处理数时，需要向expression表达式的index后再看一位，如果后一位还是数，那就往后扫描，如果是符号才入栈
                //3-因此我们需要定义一个变量（字符串变量）

                //处理多位数，先拼接ch
                keepNum += ch;
                //判断，如果ch已经是expression的最后一位了，就直接入栈
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                } else if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                    //如果后一位是运算符，就入栈keepNum=“1”或者“123”
                    numStack.push(Integer.parseInt(keepNum));
                    //重要部分！！！要清空原来的keepNum
                    keepNum = "";

                }
                //判断下一个字符是不是数字，如果是数字就继续往下扫描

                // numStack.push(ch-48);//这里的数字只是一个符号，要根据asiic码转化成数字
            }
            //让index+1，并判断是否扫描到expression最后
            index++;
            if (index >= expression.length()) {
                break;
            }
        }

        //当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并且运行
        while (true) {
            //如果符号栈为空，则计算到最后的结果，数栈中只有一个数字【结果】
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            numStack.push(res);//入栈
        }

        //把数栈的最后一个数pop出来，就是结果
        System.out.printf("表达式%s = %d", expression, numStack.pop());

    }
}

中缀改后缀逆波兰计算器

前缀表达式
从右往左扫描表达式，遇到数字就把数字压入堆栈，遇到运算符就弹出栈顶的两个数
用运算符对它们做相应的计算（栈顶元素和次顶元素），并把结果入栈
重复上面过程直到表达式最左端，最后运算出来的值就是表达式的结果

中缀表达式
1）中缀表达式是常见的表达式，比如(3+4)*5
2) 中缀表达式适合人的逻辑思维，但是不适合计算机的思维，所以在计算的时候，往往会把中缀表达式转成其他表达式来操作
（一般都是转换成后缀表达式）

后缀表达式（逆波兰表达式）
1）跟前缀表达式相似，知识运算符位于操作数之后
2）举例：(3+4)*5-6，对应的后缀表达式就是3 4 + 5 * 6 -

中缀表达式转后缀表达式
1）初始化两个栈：运算符栈s1和存储中间结果的栈s2
2）从左往右扫描中缀表达式
3）遇到操作数时，将其压入数栈
4）遇到运算符时：
1-如果s1运算符栈是空的，或者栈顶运算符为左括号（，那就直接把这个运算符入栈
2-否则，如果当前的运算符的优先级比栈顶运算符高，也是直接把这个运算符入栈
3-否则，就把s1运算符栈栈顶的运算符弹出并压入到s2数栈里，再次站到（4-1）与s1中断的栈顶运算符比较
5）如果遇到括号：
1-如果是左括号（，就直接押入s1运算符栈
2-如果是右括号），则依次弹出s1栈顶的运算符，并且压入s2，直到遇到左括号为止，此时把这一对括号丢弃
6）重复步骤2至5，直到表达式的最右边
7）把s1种剩余的运算符依次弹出并压入s2
8）依次弹出s2种的元素并且输出，结果的逆序就是中缀表达式对应的后缀表达式

（1）创建类回运算符对应的优先级

class Operation {
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;

    //写一个方法，返回对应的优先级数字
    public static int getValue(String operation) {
        int result = 0;
        switch (operation) {
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("不存在该运算符");
                break;
            }
            return result;
    }
}

（2）计算器

public class PolandNotation {
    public static void main(String[] args) {
        //完成把一个中缀表达式转成后缀表达式的功能
        //因为直接对字符串进行操作很不方便，所以要先把“中缀表达式字符串”转成“对应的List”，方便操作
        //把得打的中缀表达式的List => 后缀表达式对应的List
        String expression = "10+((2+3)*4)-5";

        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中序字符串转List后为：" + infixExpressionList);

        List<String> parseSuffixExpression = parseSuffixExpression(infixExpressionList);
        System.out.println("中序List转后续List为：" + parseSuffixExpression);

        int res02=calculate(parseSuffixExpression);
        System.out.println("后序List计算结果为："+res02);


        //先定义一个逆波兰表达式（后缀表达式）
        //(3+4)*5-6   =>   3 4 + 5 * 6 -
        //为了方便，逆波兰表达式的数字和符号使用空格隔开
        String suffixExpression = "30 4 + 5 * 6 - ";

        //思路
        //1-先把表达式方法一个ArrayList中去
        //2-把ArrayList传递给一个方法，遍历ArrayList配合栈完成计算

        List<String> List = getListString(suffixExpression);
        System.out.println("rpnList=" + List);

        int res = calculate(List);
        System.out.println("计算结果为：" + res);
    }


    /**把一个逆波兰表达式，一次把数据和运算符放入到Arraylist中去
     * 放到ArrayList中后方便取值，不然还要用index挨个遍历取
     * @MethodName: getListString
     * @Author: AllenSun
     * @Date: 2019/11/3 19:44
     */
    public static List<String> getListString(String suffixExpression) {
        //把suffixExpression分割
        String[] split = suffixExpression.split(" ");//按空格来分割
        List<String> list = new ArrayList<String>();
        for (String s : split) {
            list.add(s);
        }
        return list;
    }

    /**
     * 把一个中缀表达式转成对应的List
     *
     * @MethodName:
     * @Author: AllenSun
     * @Date: 2019/11/3 18:42
     */
    public static List<String> toInfixExpressionList(String s) {
        //先定义一个List，存放中缀表达式对应的内容
        List<String> ls = new ArrayList<String>();
        int i = 0;//这是一个指针，用于遍历中缀表达式字符串
        String str;//对多位数的拼接
        char c;//每遍历到一个字符，就放入到c
        do {
            //如果c是一个非数字，我们就需要加入到ls中去
            if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                //说明这不是数字
                ls.add("" + c);
                i++;//i后移
            } else {
                //如果是数字的话就需要拼接，考虑多位数问题
                str = "";//先清空
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                    str += c;//拼接
                    i++;
                }
                //拼接完以后把拼接后的多位数str加进去
                ls.add(str);
            }
        } while (i < s.length());
        return ls;
    }

    /**
     * 把中缀表达式对应的List  改成  后缀表达式的List
     *
     * @MethodName:
     * @Author: AllenSun
     * @Date: 2019/11/3 19:06
     */
    public static List<String> parseSuffixExpression(List<String> ls) {
        //定义两个栈
        Stack<String> s1 = new Stack<String>();
        //因为s2这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序操作
        //所以，就可以把栈Stack换成链表List，存储中间结果
        List<String> s2 = new ArrayList<String>();

        //遍历ls
        for (String item : ls) {
            //如果是一个数，那就入s2，用正则表达式取数
            if (item.matches("\\d+")) {
                s2.add(item);
            } else if (item.equals("(")) {
                s1.push(item);
            } else if (item.equals(")")) {
                //如果是右括号），则依次弹出s1栈顶的运算符，并且压入s2，直到遇到左括号为止，此时把这一对括号丢弃
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();//把（弹出
            } else {
                //当item的优先级 小于等于 s1栈顶的运算符的优先级
                //就把s1运算符栈栈顶的运算符弹出并压入到s2数栈里，再次站到与s1中断的栈顶运算符比较
                //此时，缺少一个比较优先级的方法，去写
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());

                }
                //还需要把item压入栈
                s1.push(item);
            }
        }

        //把s1中剩余的运算符依次弹出，并加入s2
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }
        return s2;
    }

    /**
     * 完成对逆波兰表达式的运算（后缀表达式的计算）
     * 1)从左往右扫描，把3和4压入堆栈
     * 2）遇到+运算符，因此弹出4和3（4是栈顶元素，3是次顶元素），计算出3+4的值，得7，再把7入栈
     * 3）把5入栈
     * 4）接下来遇到*运算符，因此弹出5和7，计算出7*5=35，把35入栈
     * 5）把6入栈
     * 6）最后是-运算符，计算出35-6的值，得29，由此得出最终结果
     *
     * @MethodName:
     * @Author: AllenSun
     * @Date: 2019/11/3 16:30
     */
    public static int calculate(List<String> list) {
        //先创建一个栈，只需要一个栈即可
        Stack<String> stack = new Stack<>();
        //遍历list，并放到栈里
        for (String item : list) {
            //使用正则表达式取出数
            if (item.matches("\\d+")) {//取出多位数
                //如果是数，直接入栈
                stack.push(item);
            } else {
                //如果是运算符，就pop两个数并且运算，然后再把数入栈
                //parseInt() 方法用于将字符串参数作为有符号的十进制整数进行解析
                int num2 = Integer.parseInt(stack.pop());//数取出来时是字符串，用parseInt转换成十进制int整数
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if (item.equals("+")) {
                    res = num1 + num2;
                } else if (item.equals("-")) {
                    res = num1 - num2;//因为是从左往右扫描，入栈时左边先入栈，出栈时右边先出栈，所以后出栈的num1-先出栈的num2
                } else if (item.equals("*")) {
                    res = num1 * num2;
                } else if (item.equals("/")) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符有误！");
                }
                //求出结果res之后，还要把这个值入栈，stack泛型放的是字符串，所以res要转成字符串
                stack.push(res + "");//还能这么转成字符串：加一个空串
            }

        }
        //for循环结束后，留在stack栈里的数就是最终的结果
        return Integer.parseInt(stack.pop());//最终的数只是字符串，要转成十进制整数
    }

}