【栈】数据结构与算法

栈的定义：

栈是限定在表尾进行插入和删除（先进先出）的线性表

• 我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom）
• 不含任何数据元素的栈称为空栈
• 栈又称为后进先出（Last In First Out）的线性表
• 栈本身是一个线性表，其数据元素具有线性关系，只不过它是一种特殊的线性表而已
• 栈的插入操作，叫作进栈，也称压栈、入栈
• 栈的删除操作，叫作出栈，也称弹栈

Stack栈接口的定义：

        同样栈可以顺序存储实现也可以链表存储实现 所以将共性抽取定义出Stack接口

package p1.接口;

//线性表接口的定义,继承迭代接口
public interface Stack<E> extends Iterable<E>{
    //返回栈中元素的个数
    public int size();
    
    //判断栈是否为空
    public boolean isEmpty();
    
    //压栈    （向栈的表尾添加元素）
    public void push(E element);
    
    //弹栈    （将栈的表尾元素返回并删除）
    public E pop();
    
    //返回栈的表尾元素
    public E peek();
    
    //清空栈
    public void clear();

}

        写一个ArrayStack类为Stack类的具体实现类。因为栈本身就是一种线性表，所以我们可以借用之前完成的ArrayList来实现我们的ArrayStack

package p2.线性结构;

import p1.接口.Stack;

import java.util.Iterator;

public class ArrayStack<E> implements Stack<E> {
    //栈的内部其实就是由一个线性表来实现的
    private ArrayList<E> list;

    //创建一个默认容量的栈（默认容量的线性表）
    public ArrayStack(){
        list = new ArrayList<E>();
    }

    //创建一个指定容量的栈（指定容量的线性表）
    public ArrayStack(int capacity){
        list = new ArrayList<E>(capacity);
    }

    //获取栈中有效元素的个数
    @Override
    public int size() {
        return list.size();
    }

    //判断栈是否为空
    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    //压栈（向栈的末尾中添加一个元素）
    @Override
    public void push(E element) {
        list.add(element);
    }

    //弹栈（在线性表的末尾删除一个元素，并返回它的值）
    @Override
    public E pop() {
        return list.remove(list.size() - 1);
    }

    //查看栈顶的元素
    @Override
    public E peek() {
        return list.get(list.size() - 1);
    }

    //清空栈中的所有元素
    @Override
    public void clear() {
        list.clear();
    }

    //返回线性表的迭代器
    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder(String.format("ArrayStack :%d/%d[", size(), list.getCapacity()));
        if(isEmpty()){
            sb.append(']');
        } else {
            for (int i = 0; i < size(); i++){
                sb.append(list.get(i));
                if (i != size()){
                    sb.append(',');
                }else {
                    sb.append(']');
                }
            }
        }
        return sb.toString();
    }
}

栈的应用——中缀表达式

• 是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间（例：3 + 4）
• 与前缀表达式（例：+ 3 4）或后缀表达式（例：3 4 +）相比，中缀表达式不容易被计算机解析，但仍被许多程序语言使用，因为它符合人们的普遍用法
• 与前缀或后缀记法不同的是，中缀记法中括号是必需的

例如：  

                                                                                                      

 

        想要将中缀表达式计算出来，我们就得将数字与符号分隔开，那我们要怎样将它们分开呢？

格式化表达式：

如果原封不动的遍历表达式字符串(10+20/2*3)/2+8

将得到如下结果：

[(, 1, 0, +, 2, 0, /, 2, *, 3, ), /, 2, +, 8]

最好的分隔结果是：

[(, 10, +, 20, /, 2, *, 3, ), /, 2, +, 8]

思路：将字符串格式化为如下情形，再进行分隔即可

#(#10#+#20#/#2#*#3#)#/#2#+#8

代码如下：

package p2.线性结构;
//中缀表达式计算器
public class InfixCalculator {
    public static void main(String[] args) {
        String expression = "(10+20/2*3)/2+8";
        try {
            int result = evaluateExpression(expression);
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Wrong expression :" + expression);
        }
    }

    private static int evaluateExpression(String expression) {
        //需要两个辅助栈
        ArrayStack<Character> operatorStack = new ArrayStack<>();
        ArrayStack<Integer> numberStack = new ArrayStack<>();

        //格式化表达式
        expression = insertBlanks(expression);
        String[] tokens = expression.split(" ");
        for (String token : tokens) {   //token == tokens[i]
            //过滤空串
            if (token.length() == 0) {
                continue;

                //遍历到 + - 号
            } else if (token.equals("+") || token.equals("-")) {
                while (!operatorStack.isEmpty() && (operatorStack.peek() == '+' || operatorStack.peek() == '-' || operatorStack.peek() == '*' || operatorStack.peek() == '/')) {
                    //如果之前是别的+ - * / 则需要弹栈 并计算
                    processAnOperator(numberStack, operatorStack);
                }
                //如果操作符栈为空 或者 不为空但栈顶为(
                operatorStack.push(token.charAt(0));

                //遍历到 * / 号
            } else if (token.equals("*") || token.equals("/")) {
                while (!operatorStack.isEmpty() && (operatorStack.peek() == '*' || operatorStack.peek() == '/')) {
                    //如果之前是别的* / 则需要弹栈 并计算
                    processAnOperator(numberStack, operatorStack);
                }
                //如果操作符栈为空 或者 不为空但栈顶为(
                operatorStack.push(token.charAt(0));

                //遍历到 (
            } else if (token.equals("(")) {
                operatorStack.push(token.charAt(0));

                //遍历到 )
            } else if (token.equals(")")) {
                //只要操作符栈的栈顶不是左括号( 就挨个弹栈计算即可
                while (operatorStack.peek() != '(') {
                    processAnOperator(numberStack, operatorStack);
                }
                //最后 清掉左括号
                operatorStack.pop();

                //遍历到数字
            } else {
                numberStack.push(new Integer(token));
            }
        }

        //处理最后面的操作符
        while (!operatorStack.isEmpty()) {
            processAnOperator(numberStack, operatorStack);
        }
        return numberStack.pop();
    }

    //操作符栈弹栈一个元素 数字栈弹栈两个数字 进行计算 并将新的结果进栈到数字栈
    private static void processAnOperator(ArrayStack<Integer> numberStack, ArrayStack<Character> operatorStack) {
        char op = operatorStack.pop();
        int num1 = numberStack.pop();
        int num2 = numberStack.pop();
        //num2 op num1
        if (op == '+') {
            numberStack.push(num2 + num1);
        } else if (op == '-') {
            numberStack.push(num2 - num1);
        } else if (op == '*') {
            numberStack.push(num2 * num1);
        } else {
            numberStack.push(num2 / num1);
        }
    }

    //对原表达式进行格式化处理 给所有的非数字字符两边添加空格
    private static String insertBlanks(String expression) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);
            if (c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '/') {
                sb.append(' ');
                sb.append(c);
                sb.append(' ');
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }
}

运行结果：