4.中缀表达式转后缀表达式的应用:实现多位浮点数的加减乘除运算

先简单介绍几个概念:

1.前缀表达式

 

2.中缀表达式

 

3.后缀表达式

 

 

4.中缀表达式转后缀表达式的流程:

 

代码实现:

用于计算中作为存储结构的栈:

package com.vi.algorithm.stack;

import com.vi.algorithm.linear.LinkList;

//  计算器栈，用于实现加减乘除的计算器,在链表实现的栈的基础上，对功能做扩展
public class CalculateStack<T> extends LinkListStack<T> {

    public CalculateStack() {
    }

    //  判断当前元素是否操作符
    public static boolean isCommand(String str) {
        return str.matches("[\+\-\*\/]");
    }

    //  判断当前操作符的优先级
    public static int priority(String str) {
        if ("+".equals(str))
            return 0;
        if ("-".equals(str))
            return 1;
        if ("*".equals(str) || "/".equals(str))
            return 2;
        if("(".equals(str) || ")".equals(str))
            return -1;
        throw new RuntimeException("非法操作符");
    }

    public static void main(String[] args) {
//        System.out.println(new CalculateStack<>().isCommand("\"));
        CalculateStack<Integer> cs = new CalculateStack<>();
        cs.push(1);
        cs.push(2);
        cs.push(3);

        System.out.println(cs.peek());
        cs.list();
    }

}

实现栈用到的两个类:

package com.vi.algorithm.stack;

import com.vi.algorithm.linear.LinkList;

//  用链表实现栈
public class LinkListStack<T> {
    private LinkList<T> stack;

    public LinkListStack() {
        stack = new LinkList<>();
    }

    //  链表式的不存在存满的情况
    public boolean isFull() {
        return false;
    }

    //  判断是否为空
    public boolean isEmpty() {
        return stack.length() == 0;
    }

    public T pop() {
        if (stack.isEmpty()) {
            System.out.println("栈为空！");
            return null;
        }
        T result = stack.remove(stack.length() - 1);
        return result;
    }

    public boolean push(T data) {
        try {
            stack.insert(data);
        } catch (Exception e) {
            System.out.println("插入失败！");
            return false;
        }
        return true;
    }

    //  查看栈顶元素但是不弹出
    public T peek() {
        return stack.get(stack.length() - 1);
    }

    //  遍历
    public void list() {
        if (stack.isEmpty()) {
            System.out.println("栈为空！");
            return;
        }
        for (int i = stack.length() - 1; i >= 0; i--) {
            System.out.printf("stack[%d] = %d
", i, stack.get(i));
        }
    }
}

链表:

package com.vi.algorithm.linear;

import java.util.Iterator;

/**
 * 单向链表
 */
public class LinkList<T> implements Iterable<T> {
    // 头结点
    private Node<T> head;
    // 链表长度
    private int length;

    public LinkList() {
        head = new Node<>(null, null);
        length = 0;
    }

    // 内部类，节点类型
    private class Node<T> {
        T data;
        Node next;

        public Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "data=" + data +
                    ", next=" + next +
                    '}';
        }
    }

    // 清空链表
    public void clear() {
        if (head == null)
            return;
        head.next = null;
        length = 0;
    }

    // 判断链表是否为空
    public boolean isEmpty() {
        return length == 0;
    }

    // 获取链表中元素的个数
    public int length() {
        return length;
    }

    // 获取第i个元素的值
    public T get(int i) {
        if (head == null)
            return null;
        Node cursor = head;
        for (int index = 0; index <= i; index++) {
            if (cursor.next != null)
                cursor = cursor.next;
            else
                throw new RuntimeException("下标越界");
        }
        return (T) cursor.data;
    }

    // 在链表索引i处插入元素t
    public void insert(int i, T t) {
        if (head == null)
            return;
        Node cursor = head;

        int index = 0;
        while (index <= i - 1) {
            if (cursor != null) {
                cursor = cursor.next;
            } else
                throw new RuntimeException("下标越界");
            index++;
        }

        if (cursor != null) {
            if (cursor.next != null) {
                Node newNode = new Node(t, cursor.next);
                cursor.next = newNode;
            } else {
                Node newNode = new Node(t, null);
                cursor.next = newNode;
            }
            length++;
        }
    }

    // 在链表最后的位置插入一个元素
    public void insert(T t) {
        if (head == null)
            return;

        insert(length, t);
    }

    // 删除链表中索引i处的元素并返回
    public T remove(int i) {
        if (head == null)
            return null;
        Node cursor = head;
        for (int index = 0; index <= i - 1; index++) {
            if (cursor.next == null)
                throw new RuntimeException("下标越界");
            cursor = cursor.next;
        }

        if (cursor.next == null) {
            return null;
        } else {
            Node target = cursor.next;
            Node next = target.next;
            cursor.next = next;
            target.next = null;
            length--;
            return (T) target.data;
        }
    }

    // 查找t在链表中的索引位置，如果不存在返回-1
    public int indexOf(T t) {
        Node cursor = head.next;
        int index = 0;
        while (cursor != null) {
            if (cursor.data.equals(t)) {
                return index;
            }
            index++;
            cursor = cursor.next;
        }
        return -1;
    }

    @Override
    public Iterator<T> iterator() {
        return new Literator();
    }

    private class Literator implements Iterator {
        Node cursor;

        public Literator() {
            cursor = head;
        }

        @Override
        public boolean hasNext() {
            return cursor.next != null;
        }

        @Override
        public Object next() {
            cursor = cursor.next;
            return cursor;
        }
    }
}

将中缀表达式转成后缀表达式以及计算表达式的值

package com.vi.algorithm.demo;

import com.vi.algorithm.stack.CalculateStack;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;

//  波兰表达式计算(后缀表达式) 
public class PolandCalculations {
    public static void main(String[] args) { // 1+(2*3)+4
        String expression  = infixToSuffix("3.1+4.2*5.6-4.6");
        System.out.println(expression);
        System.out.println("计算的结果是:"+calculate(expression));
    }

    //  多位正浮点数计算
    public static float calculate(String expression) {
        // (30+4)*5-6 -> 30 4 + 5 * 6 -
        String[] target = expression.split(" ");
        List<String> strings = Arrays.asList(target);
        Stack<String> numberStack = new Stack<>();
        for (String str : strings) {
            if (str.matches("[\+\-\*\/]")) {
                //  如果是运算符，从数栈中弹出两个数进行计算
                BigDecimal num2 = new BigDecimal(numberStack.pop());
                BigDecimal num1 = new BigDecimal(numberStack.pop());
                float result = calculate(num1, num2, str);
                //  把计算出的结果压入数栈
                numberStack.push(result + "");
            } else {
                //  如果是运算符，压入数栈
                numberStack.push(str);
            }
        }
        return Float.parseFloat(numberStack.pop());
    }

    private static float calculate(BigDecimal num1, BigDecimal num2, String str) {
        if ("+".equals(str))
            return num1.add(num2).floatValue();
        if ("-".equals(str))
            return num1.subtract(num2).floatValue();
        if ("*".equals(str))
            return num1.multiply(num2).floatValue();
        if ("/".equals(str))
            return num1.divide(num2).floatValue();
        throw new RuntimeException("非法的操作符");
    }

    /**
     * 中缀表达式转后缀表达式，假设输入的中缀表达式都是符合规范的
     * 思路:
     * 1.准备两个栈，一个s1存操作符，另一个s2存处理以后的表达式
     * 2.遍历中序表达式，遇到数，压入s2栈,遇到操作符进行判断，如果s1为空，直接压入s1,如果不为空，判断是否"(","("直接压入
     * 3.判断是否")"，如果是，弹出s1中的元素，依次压入s1栈，直至遇到"(",将"("弹出
     * 4.如果不是以上情况，则判断当前运算符的优先级是否高于栈顶运算符的优先级，如果高于栈顶，把当前运算符压入s1，如果低于栈顶，把栈顶弹出压入s2,依次和新栈顶继续比较
     * 5.遍历结束，把s1元素弹出依次压入s2,倒序输出s2元素，即转换后的后缀表达式
     *
     * @param infixExpression
     * @return
     */
    private static String infixToSuffix(String infixExpression) {
        //  把字符串表达式转换成列表
        int index = 0;
        ArrayList<String> list = new ArrayList<>();
        //  把运算符存进列表
        while (index < infixExpression.length()) {
            if (infixExpression.substring(index, index + 1).matches("[()\+\-\*\/]")) {
                list.add(infixExpression.substring(index, index + 1));
            } else {
                //  把操作数存进列表
                String num = infixExpression.substring(index, index + 1);
                while (index != infixExpression.length() - 1 && !infixExpression.substring(index + 1, index + 2).matches("[()\+\-\*\/]")) {
                    index++;
                    num = num + infixExpression.substring(index, index + 1);
                }
                list.add(num);
            }
            index++;
        }
        //  准备一个栈存放运算符
        CalculateStack<String> stack = new CalculateStack<>();
        //  准备一个列表存放结果
        ArrayList<String> result = new ArrayList<>();
        //  顺序遍历集合
        for (int i = 0; i < list.size(); i++) {
            if (!list.get(i).matches("[()\+\-\*\/]")) {
                //  如果不是运算符，直接存入result
                result.add(list.get(i));
            } else {
                //  如果是运算符
                if (stack.isEmpty()) {
                    //  栈为空，直接压入
                    stack.push(list.get(i));
                } else if ("(".equals(list.get(i))) {
                    //  如果是左括号，直接压入
                    stack.push(list.get(i));
                } else if (")".equals(list.get(i))) {
                    //  如果是右括号，弹出栈顶元素直到"("
                    while (!"(".equals(stack.peek())) {
                        result.add(stack.pop());
                    }
                    stack.pop();
                } else {
                    //  判断运算符优先级
                    if (CalculateStack.priority(list.get(i)) > CalculateStack.priority(stack.peek())) {
                        stack.push(list.get(i));
                    } else {
                        while (!stack.isEmpty() && CalculateStack.priority(stack.peek()) >= CalculateStack.priority(list.get(i))) {
                            result.add(stack.pop());
                        }
                        stack.push(list.get(i));
                    }
                }
            }
        }
        while (!stack.isEmpty()) {
            result.add(stack.pop());
        }
        //  把列表转成字符串
        final String[] str = {""};
        result.forEach(ele -> {
            str[0] = str[0] + ele +" ";
        });
        return str[0].substring(0,str[0].length()-1);
    }
}

运行结果如下:

当前代码并不支持负数的计算，如果要加入对负数的运算，可以先把中缀表达式处理一下，例如:判断开头是否有负数,如果有将 -99之类的负数转成(0-99),再将表达式其他的(-xx)这样的项数替换成(0-99),

再转换成后缀表达式计算即可。