Question

这是我的班级：

import java.io.*;
import java.util.*;
import java.lang.*;
import java.util.Scanner;
import java.util.List;
import java.util.Stack;

/**
 *
 * @author rtibbetts268
 */
public class InfixToPostfix
{
        /**
         * Operators in reverse order of precedence.
         */
    private static final String operators = "_-+/*";
    private static final String operands = "0123456789x";

    public String xToValue(String postfixExpr, String x)
    {
        char[] chars = postfixExpr.toCharArray();
        StringBuilder newPostfixExpr = new StringBuilder();

        for (char c : chars)
        {
            if (c == 'x')
            {
                newPostfixExpr.append(x);
            }
            else
            {
                newPostfixExpr.append(c);
            }
        }
        return newPostfixExpr.toString();
    }

    public String convert2Postfix(String infixExpr)
    {
        char[] chars = infixExpr.toCharArray();
        StringBuilder in = new StringBuilder(infixExpr.length());

        for (int i : chars)
        {
            if (infixExpr.charAt(i) == '-')
            {
                if (isOperand(infixExpr.charAt(i+1)))
                {
                    if (i != infixExpr.length())
                    {
                        if (isOperator(infixExpr.charAt(i-1)))
                            in.append('_');
                    }
                    else
                    {
                        in.append(infixExpr.charAt(i));
                    }
                }
                else
                {
                   in.append(infixExpr.charAt(i));
                }
            }
            else
            {
                in.append(infixExpr.charAt(i));
            }
        }

        chars = in.toString().toCharArray();
        Stack<Character> stack = new Stack<Character>();
        StringBuilder out = new StringBuilder(in.toString().length());

        for (char c : chars)
        {
            if (isOperator(c))
            {
                while (!stack.isEmpty() && stack.peek() != '(')
                {
                    if (operatorGreaterOrEqual(stack.peek(), c))
                    {
                        out.append(stack.pop());
                    }
                    else
                    {
                        break;
                    }
                }
                stack.push(c);
            }
            else if (c == '(')
            {
                stack.push(c);
            }
            else if (c == ')')
            {
                while (!stack.isEmpty() && stack.peek() != '(')
                {
                    out.append(stack.pop());
                }
                if (!stack.isEmpty())
                {
                    stack.pop();
                }
            }
            else if (isOperand(c))
            {
                out.append(c);
            }
        }
        while (!stack.empty())
        {
            out.append(stack.pop());
        }
        return out.toString();
    }

    public int evaluatePostfix(String postfixExpr)
    {
        char[] chars = postfixExpr.toCharArray();
        Stack<Integer> stack = new Stack<Integer>();
        for (char c : chars)
        {
            if (isOperand(c))
            {
                stack.push(c - '0'); // convert char to int val
            }
            else if (isOperator(c))
            {
                int op1 = stack.pop();
                int op2 = stack.pop();
                int result;
                switch (c) {
                    case '*':
                        result = op1 * op2;
                        stack.push(result);
                        break;
                    case '/':
                        result = op2 / op1;
                        stack.push(result);
                        break;
                    case '+':
                        result = op1 + op2;
                        stack.push(result);
                        break;
                    case '-':
                        result = op2 - op1;
                        stack.push(result);
                        break;
                }
            }
        }
        return stack.pop();
    }

    private int getPrecedence(char operator)
    {
        int ret = 0;
        if (operator == '_')
        {
            ret = 0;
        }
        if (operator == '-' || operator == '+')
        {
            ret = 1;
        }
        else if (operator == '*' || operator == '/')
        {
            ret = 2;
        }
        return ret;
    }

    private boolean operatorGreaterOrEqual(char op1, char op2)
    {
        return getPrecedence(op1) >= getPrecedence(op2);
    }

    private boolean isOperator(char val)
    {
        return operators.indexOf(val) >= 0;
    }

    private boolean isOperand(char val)
    {
        return operands.indexOf(val) >= 0;
    }

}

在其中我使用方法convert2Postfix()

将中缀表达式更改为后缀表达式

在一开始我有一小段我正在重写字符串输入，其中所有负数都在'_'前面而不是"-"。它不起作用。

例如：将-4改为_4

我需要做些什么来完成这项工作？

Answer 1

这里有一些错误，这是第一个错误：

 for (int i : chars)

将chars转换为相应的int。例如，如果字符包含一个单个字符“A”：

  char [] chars = new char[1];
    chars[0] = 'A';
    for(int i: chars){
        System.out.println(i); //You will have a '65' here
    }

你的真正含义可能是：

 for (int i=0;i<chars.length;++i)

这也是错误的：

  if (isOperator(infixExpr.charAt(i-1)))

应该是：

  if (isOperator(infixExpr.charAt(i)))

然后，您在堆栈中放置和删除元素的方式存在问题。完成所有这些更改后，您还应执行此操作：

 return out.reverse().toString();

而不是：

 return out.toString();

以下是我最终的结果：http://pastebin.com/2TLqPUsH （当然改变课程的名称）

将中缀转换为后缀时识别负值

1 个答案: