数据结构与算法（三）——栈

一、栈

1、介绍

　　栈是一种先进后出的线性表，它要求只能在表尾（栈顶）进行插入和删除操作。可以用数组或链表来实现，一般用顺序表来实现。
　　栈的应用：
　　①子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
　　②处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
　　③表达式的转换（中缀表达式转后缀表达式）与求值（实际解决）。
　　④二叉树的遍历。
　　⑤图的深度优先（depth一first）搜索。

2、栈的顺序存储实现

　　顾名思义，用顺序表的方法实现，通常用数组。栈的顺序存储结构：

　　代码示例：数组实现栈

// 用数组实现栈
public class MyStack<T> {
    private T[] elementData;
    // 栈顶指针
    private int top;

    public MyStack(int initialCapacity) {
        elementData = (T[]) new Object[initialCapacity];
        top = 0;
    }

    // 入栈
    public T push(T item) {
        if (isFull()) {
            throw new RuntimeException("堆栈溢出~");
        }

        elementData[top] = item;
        top++;

        return item;
    }

    // 出栈
    public T pop() {
        if (empty()) {
            return null;
        }

        top--;
        return elementData[top];
    }

    // 读取栈顶元素
    public T peek() {
        if (empty()) {
            return null;
        }

        return elementData[top - 1];
    }

    // 判空
    public boolean empty() {
        return top == 0;
    }

    // 判满
    private boolean isFull() {
        return top == elementData.length;
    }

    // 栈的元素个数
    public int size() {
        int count = 0;
        for (int i = top - 1; i >= 0; i++) {
            count++;
        }
        return count;
    }

    @Override
    public String toString() {
        if (empty()) {
            return "[]";
        }

        StringBuilder builder = new StringBuilder();
        builder.append("[");
        for (int i = top - 1; i >= 0; i--) {
            builder.append(elementData[i])
                    .append(",");
        }

        // 去掉最后一个,
        builder.deleteCharAt(builder.length() - 1);
        builder.append("]");

        return builder.toString();
    }
}

　　代码示例：测试类

// 测试类
public class Main {
    public static void main(String[] args) {
        MyStack<Integer> stack = new MyStack<>(5);

        // 压栈
        stack.push(9);
        stack.push(5);
        stack.push(2);
        stack.push(7);

        while (!stack.empty()) {
            // 从栈顶弹出一个.会删除元素
            System.out.println(stack.pop());
        }

        // 从栈顶弹出一个.不会删除元素
        // stack.peek();
        // System.out.println(stack);
    }
}

// 结果
7  2  5  9

3、栈的链式存储实现

　　顾名思义，用链表的方法实现，通常用单链表。栈的链式储存结构：

　　代码示例：单链表（不带头结点）实现栈

public class MyLinkedStack<E> {

    // 头指针
    private Node<E> head;

    public MyLinkedStack() {

    }

    // 入栈
    public E push(E item) {
        final Node<E> node = new Node<>(item);

        node.next = head;
        head = node;

        return item;
    }

    // 出栈
    public E pop() {
        final Node<E> temp = head;

        if (temp == null) {
            return null;
        }

        head = head.next;
        return temp.item;
    }

    // 读取栈顶元素
    public E peek() {
        if (head == null) {
            return null;
        }

        return head.item;
    }

    // 判空
    public boolean empty() {
        return head == null;
    }

    // 栈的元素个数
    public int size() {
        int size = 0;

        Node<E> temp = head;
        while (temp != null) {
            size++;
            temp = temp.next;
        }

        return size;
    }

    @Override
    public String toString() {
        Node<E> temp = head;

        if (temp == null) {
            return "[]";
        }

        StringBuilder builder = new StringBuilder();
        builder.append("[");

        while (temp != null) {
            builder.append(temp.item)
                    .append(",");

            temp = temp.next;
        }

        // 去掉最后一个,
        builder.deleteCharAt(builder.length() - 1);
        builder.append("]");

        return builder.toString();
    }

    private static class Node<E> {
        public E item;

        public Node<E> next;

        public Node(E item) {
            this.item = item;
        }

    }
}

　　代码示例：测试类

// 测试类
public static void main(String[] args) {
    MyLinkedStack<Integer> stack = new MyLinkedStack<>();
    // 压栈
    stack.push(9);
    stack.push(5);
    stack.push(2);
    stack.push(7);

    while (!stack.empty()) {
        // 从栈顶弹出一个.会删除元素
        System.out.println(stack.pop());
    }
}

// 结果
7  2  5  9

4、前缀、中缀、后缀表达式

　　中缀表达式：（3 + 4）* 5 - 16
　　前缀表达式（波兰表达式）：- * + 3 4 5 16
　　后缀表达式（逆波兰表达式）：3 4 + 5 * 16 -

　　①计算前缀表达式："- * + 3 4 5 16"

　　计算流程图：注：这里仅支持多位整数计算。

　　代码示例：见【类Poland】

　　②计算中缀表达式："31+3 /1 -21"

　　计算流程图：创建两个栈，一个数栈，一个符号栈。注：这里仅支持多位整数计算，且不支持括号。

　　代码示例：见【类Poland】

　　③计算后缀表达式："11 2 3 + 4 * + 5 -"

　　计算流程图：注：这里仅支持多位整数计算。

　　代码示例：见【类Poland】

　　前缀和后缀计算流程的区别：①遍历表达式方向不同；②弹栈出来的运算符号先后不同，一个a - b，一个b - a。

　　④中缀转后缀：

　　流程图：创建一个栈 stack 和一个结果存储list。注：仅支持整数和括号。

　　代码示例：见【类Poland】

　　代码示例：Poland

// 前缀、中缀、后缀表达式
public class Poland {

    /**
     * 匹配整数或小数
     */
    private static final Pattern NUM_PATTERN = Pattern.compile("^(\-|\+)?\d+(\.\d+)?$");

    /**
     * 中缀表达式转后缀表达式
     *
     * @param infixExpression 11+((2+3) * 4) - 5
     * @return 11 2 3 + 4 * + 5 -
     */
    public static String toSuffixExpression(String infixExpression) {
        infixExpression = infixExpression.replace(" ", "");

        Stack<String> stack = new Stack<>();
        List<String> result = new ArrayList<>();

        StringBuilder builder = new StringBuilder();
        // 1.遍历
        for (int i = 0; i < infixExpression.length(); i++) {
            final char c = infixExpression.charAt(i);

            // ①.数,就直接添加到result.注意:可能是多位数
            if (isNum(c)) {
                builder.append(c);

                // 可能会越界.有下一个且下一个是数
                if (i != infixExpression.length() - 1 && isNum(infixExpression.charAt(i + 1))) {
                    continue;
                }

                result.add(builder.toString());

                // 清空 builder
                builder.delete(0, builder.length());
            } else if (c == '(') {
                stack.push(String.valueOf(c));
            } else if (c == ')') {
                // stack依次出栈添加到result中直到遇到'('
                while (!"(".equals(stack.peek())) {
                    result.add(stack.pop());
                }

                // 将'('弹出,消除这对括号
                stack.pop();
            } else {
                // ②.是运算符
                while (!stack.empty() && !"(".equals(stack.peek()) && priority(String.valueOf(c), stack.peek()) <= 0) {
                    result.add(stack.pop());
                }

                // 将c压栈
                stack.push(String.valueOf(c));
            }
        }

        // 2.尾处理.将stack中剩余的运算符依次弹出加入result
        while (!stack.empty()) {
            result.add(stack.pop());
        }

        // 3.此时result已是中缀表达式.用String输出
        for (String s : result) {
            builder.append(s)
                    .append(" ");
        }
        // 去除最后一个空格
        if (builder.toString().length() != 0) {
            builder.deleteCharAt(builder.length() - 1);
        }

        return builder.toString();
    }

    // 计算前缀表达式（波兰表达式）
    public static double calculatePrefix(String prefixExpression) {
        final String[] list = prefixExpression.split(" ");

        Stack<String> stack = new Stack<>();
        for (int i = list.length - 1; i >= 0; i--) {
            if (isNum(list[i])) {
                stack.push(list[i]);
            } else {
                final double num1 = Double.parseDouble(stack.pop());
                final double num2 = Double.parseDouble(stack.pop());

                stack.push(String.valueOf(cal(num2, num1, list[i])));
            }
        }

        // 最后stack中的数据是运算结果
        return Double.parseDouble(stack.pop());
    }

    // 计算中缀表达式
    public static double calculateInfix(String infixExpression) {
        infixExpression = infixExpression.replace(" ", "");

        MyStack<Double> numStack = new MyStack<>(20);
        MyStack<Character> operStack = new MyStack<>(20);

        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < infixExpression.length(); i++) {
            final char c = infixExpression.charAt(i);

            if (!isOper(c)) {
                // 数,注意：可能是多位数
                builder.append(c);

                // 可能会越界.有下一个且下一个是数
                if (i != infixExpression.length() - 1 && !isOper(infixExpression.charAt(i + 1))) {
                    continue;
                }

                numStack.push(Double.parseDouble(builder.toString()));

                // 清空 builder
                builder.delete(0, builder.length());
            } else {
                // 符号
                if (!operStack.empty() && priority(c, operStack.peek()) <= 0) {
                    // 注意顺序
                    final double num1 = numStack.pop();
                    final double num2 = numStack.pop();

                    final double cal = cal(num1, num2, operStack.pop());
                    numStack.push(cal);
                }

                // 将当前符号入栈
                operStack.push(c);
            }
        }

        while (!operStack.empty()) {
            final double num1 = numStack.pop();
            final double num2 = numStack.pop();

            final double cal = cal(num1, num2, operStack.pop());
            numStack.push(cal);
        }

        return numStack.pop();
    }

    // 计算后缀表达式（逆波兰表达式）
    public static double calculateSuffix(String suffixExpression) {
        final String[] list = suffixExpression.split(" ");

        Stack<String> stack = new Stack<>();
        for (String s : list) {
            if (isDecimal(s)) {
                stack.push(s);
            } else {
                final double num1 = Double.parseDouble(stack.pop());
                final double num2 = Double.parseDouble(stack.pop());

                stack.push(String.valueOf(cal(num1, num2, s)));
            }
        }

        // 最后stack中的数据是运算结果
        return Double.parseDouble(stack.pop());
    }

    /**
     * 计算
     *
     * @param num1 数1
     * @param num2 数2
     * @param oper 运算符
     * @return
     */
    private static double cal(double num1, double num2, char oper) {
        double 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;
    }

    private static double cal(double num1, double num2, String oper) {
        return cal(num1, num2, oper.charAt(0));
    }

    /**
     * 判断是不是数字 int double long float
     */
    private static boolean isDecimal(String s) {
        return NUM_PATTERN.matcher(s).matches();
    }

    /**
     * 判断是不是数字
     *
     * @param val
     * @return
     */
    private static boolean isNum(String val) {
        return val.matches("\d+");
    }

    /**
     * 判断是不是数字
     *
     * @param val
     * @return
     */
    private static boolean isNum(char val) {
        // '0'[48] -> '9'[57]
        return val >= 48 && val <= 57;
    }

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

    /**
     * 判断是不是一个符号
     *
     * @param val
     * @return
     */
    private static boolean isSymbol(char val) {
        return isOper(val) || val == '(' || val == ')';
    }

    /**
     * 比较两个符号的优先级
     *
     * @param oper1 符号1 + - * /
     * @param oper2 符号2
     * @return 1:符号1>符号2 ; 0:符号1=符号2 ; -1:符号1<符号2
     */
    public static int priority(char oper1, char oper2) {
        if (oper1 == '*' || oper1 == '/') {
            if (oper2 == '*' || oper2 == '/') {
                return 0;
            }
            return 1;
        }

        // oper1 = + -
        if (oper2 == '*' || oper2 == '/') {
            return -1;
        }
        return 0;
    }

    /**
     * 比较两个符号的优先级
     *
     * @param oper1 符号1 + - * /
     * @param oper2 符号2
     * @return 1:符号1>符号2 ; 0:符号1=符号2 ; -1:符号1<符号2
     */
    public static int priority(String oper1, String oper2) {
        return priority(oper1.charAt(0), oper2.charAt(0));
    }

}

　　代码示例：测试类

// 测试类
public static void main(String[] args) {
    // 1.计算前缀表达式: (3+4)×5-16=19
    final double v = Poland.calculatePrefix("- * + 3 4 5 16");
    System.out.println("计算前缀表达式的结果是:" + v);

    // 2.计算中缀表达式: 31+3 /1 -21=13  (仅支持多位整数计算，且不支持括号)
    final double v1 = Poland.calculateInfix("31+3 /1 -21");
    System.out.println("计算中缀表达式的结果是:" + v1);

    // 3.中 转 后
    String infixExpression = "11+( (2+3) * 4) - 5";
    System.out.println("中缀表达式:" + infixExpression);
    final String suffixExpression = Poland.toSuffixExpression(infixExpression);
    System.out.println("中转后:" + suffixExpression);

    // 4.计算后缀表达式: 11+( (2+3) * 4) - 5=26
    final double v2 = Poland.calculateSuffix(suffixExpression);
    System.out.println("计算后缀表达式的结果是:" + v2);
}

// 结果
计算前缀表达式的结果是:19.0
计算中缀表达式的结果是:13.0
中缀表达式:11+( (2+3) * 4) - 5
中转后:11 2 3 + 4 * + 5 -
计算后缀表达式的结果是:26.0

5、栈实现综合计算器

　　综合计算器的实现会用到逆/波兰表达式，只是功能更全面，支持"+"、"-"、"*"、"/"、"(" 、")"，多位整数及小数运算。
　　代码示例：栈实现的综合计算器

public class MyCalculator {

    public double calculate(String expression) {
        // 1.中转后
        final String suffixExpression = this.toSuffixExpression(expression);

        System.out.println(suffixExpression);

        // 2.计算后缀表达式
        return Poland.calculateSuffix(suffixExpression);
    }

    /**
     * 中缀表达式转后缀表达式.支持小数,多位整数
     *
     * @param infixExpression "12.8 + (2 - 3.55)*4+10/5.0"
     * @return "12.8 2 3.55 - 4 * + 10 5.0 / +"
     */
    private String toSuffixExpression(String infixExpression) {
        if (infixExpression == null || "".equals((infixExpression = infixExpression.replaceAll("\s+", "")))) {
            throw new RuntimeException("infixExpression is illegal!");
        }

        Stack<String> stack = new Stack<>();
        List<String> result = new ArrayList<>();

        StringBuilder builder = new StringBuilder();
        // 1.遍历
        for (int i = 0; i < infixExpression.length(); i++) {
            final char c = infixExpression.charAt(i);

            // ①.数,就直接添加到result.注意:可能是多位数 或 小数
            if (isDecimal(c)) {
                builder.append(c);

                // 可能会越界.有下一个且下一个是数
                if (i != infixExpression.length() - 1 && isDecimal(infixExpression.charAt(i + 1))) {
                    continue;
                }

                result.add(builder.toString());

                // 清空 builder
                builder.delete(0, builder.length());
            } else if (c == '(') {
                stack.push(String.valueOf(c));
            } else if (c == ')') {
                // stack依次出栈添加到result中直到遇到'('
                while (!"(".equals(stack.peek())) {
                    result.add(stack.pop());
                }

                // 将'('弹出,消除这对括号
                stack.pop();
            } else {
                // ②.是运算符
                while (!stack.empty() && !"(".equals(stack.peek()) && Poland.priority(String.valueOf(c), stack.peek()) <= 0) {
                    result.add(stack.pop());
                }

                // 将c压栈
                stack.push(String.valueOf(c));
            }
        }

        // 2.尾处理.将stack中剩余的运算符依次弹出加入result
        while (!stack.empty()) {
            result.add(stack.pop());
        }

        // 3.此时result已是中缀表达式.用String输出
        for (String s : result) {
            builder.append(s)
                    .append(" ");
        }
        // 去除最后一个空格
        if (builder.toString().length() != 0) {
            builder.deleteCharAt(builder.length() - 1);
        }

        return builder.toString();
    }

    /**
     * 是不是小数
     *
     * @param val
     * @return
     */
    private boolean isDecimal(char val) {
        // '0'[48] -> '9'[57]
        return (val >= 48 && val <= 57) || val == '.';
    }

}

　　代码示例：测试类

// 测试类
public static void main(String[] args) {
    MyCalculator calculator = new MyCalculator();
    final double v = calculator.calculate("12.8 + (2 - 3.55)*4+10/5.0");

    System.out.println("result = " + v);
}

// 结果
12.8 2 3.55 - 4 * + 10 5.0 / +
result = 8.600000000000001