Question

我试图读取由空格分隔的用户输入并将值插入树中。一切都正常，直到我有两位数的整数。它似乎是读取每个整数char并插入树时，我希望它首先读取，然后将双位整数插入树

E，G。当用户输入9 3 + 7 *时这工作正常，但是，当用户输入10 3 + 7 *时，它将首先插入10作为1然后插入0.我希望它插入10.（这是前缀格式的等式）

这是我到目前为止所做的：

在我的主要班级

public static void main(String [] args){
    Scanner scan = new Scanner(System.in);
    ExpressionTree et = new ExpressionTree();
    System.out.println("\nEnter equation: ");
    et.buildTree(scan.nextLine());
}

在我的buildTree方法中..

public void buildTree(String eqn){
    for(int i = 0; i <= eqn.legnth()-1; i++)
    insert(eqn.charAt(i));    //how to insert 10 instead of 1 and then 0??
}

我知道我的buildTree方法存在问题，但我不确定我需要做什么来阅读两位数的字符..

完整代码：

package expressiontreetest;

import java.util.Scanner;


class ExpressionTree {
class TreeNode {
    char data;
    TreeNode left, right;

    /** constructor **/
    public TreeNode(char data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}
class StackNode {
    TreeNode treeNode;
    StackNode next;
    public StackNode(TreeNode treeNode) {
        this.treeNode = treeNode;
        next = null;
    }
}

private static StackNode top;
public ExpressionTree() {
    top = null;
}
public void clear() {
    top = null;
}
private void push(TreeNode ptr) {
    if (top == null) top = new StackNode(ptr);
    else {
        StackNode nptr = new StackNode(ptr);
        nptr.next = top;
        top = nptr;
    }
}
private TreeNode pop() {
    if (top == null) throw new RuntimeException("Underflow");
    else {
        TreeNode ptr = top.treeNode;
        top = top.next;
        return ptr;
    }
}
private TreeNode peek() {
    return top.treeNode;
}
private void insert(char val) {
    try {
        if (isDigit(val)) {
            TreeNode nptr = new TreeNode(val);
            push(nptr);
        }
        else if (isOperator(val)) {
            TreeNode nptr = new TreeNode(val);
            nptr.left = pop();
            nptr.right = pop();
            push(nptr);
        }
    }
    catch(Exception e) {
        System.out.println("Invalid Expression");
    }
}
    //if it is a valid digit return true
private boolean isDigit(char ch) {
    return ch >= '0' && ch <= '9';
}
    //if it is a valid operator return true 
private boolean isOperator(char ch) {
    return ch == '+' || ch == '-' || ch == '*' || ch == '/';
}

private int toDigit(char ch) {
    return ch - '0';
}

    //starting from index 0 increment the index after char has been inserted into the tree 
    //and terminate the for loop once we have reached equation legnth
public void buildTree(String eqn) {
//            String [] eqnSubparts = eqn.split(" ");
//          System.out.print("\neqnSubparts: " + eqnSubparts);

    for (int i = 0; i <= eqn.length() - 1; i++) {               
//                    System.out.print("\neqnSubparts: " + eqnSubparts[i]);
                    insert(eqn.charAt(i));   
            }
}

public double evaluate() {
    return evaluate(peek());
}

public double evaluate(TreeNode ptr) {
    if (ptr.left == null && ptr.right == null) return toDigit(ptr.data);
    else {
        double result = 0.0;
        double left = evaluate(ptr.left);
        double right = evaluate(ptr.right);
        char operator = ptr.data;
                    //switch statment for oper
        switch (operator) {
        case '+':
            result = left + right;
            break;
        case '-':
            result = left - right;
            break;
        case '*':
            result = left * right;
            break;
        case '/':
            result = left / right;
            break;
        default:
            result = left + right;
            break;
        }
        return result;
    }
}

}

/** class ExpressionTreeTest **/
public class ExpressionTreeTest {
public static void main(String[] args) {
    Scanner scan = new Scanner(System. in );
    System.out.println("Expression Tree Test");

    /** make object of ExpressionTree **/
    ExpressionTree et = new ExpressionTree();

    System.out.println("\nEnter equation in prefix form");



            //String line = scan.nextLine();
            //System.out.print("First digit : " + line);
            et.buildTree(scan.nextLine());


    System.out.print("\nInput : ");

    System.out.println("\n\nEvaluated Result : " + et.evaluate());
}
}

Answer 1

用户输入中的每组字符之间是否有空格？换句话说就像10个空格3空格+空格7.如果没有，尝试以这种格式输入然后你可以在空间上分割输入

Answer 2

你的buildTree()方法中的问题是，你在迭代方程的每个字符，你没有考虑空格。您可以做的是，使用String[] eqnSubparts = eqn.split(" ")在空间周围拆分eqn，然后遍历此数组并在树中插入数组的每个条目。
注意：如果您还想在树中插入空格，那么在插入数组的每个条目时进行迭代时，也要插入一个空格。

Answer 3

为什么不根据空格对字符串进行标记？而不是使用逐字符方法，为什么不采用逐字符串方法。在java中使用split函数。

split(" ")

此函数返回一个字符串数组。

10 3 + 7 * ----＆gt;将其存储在一个字符串数组中。

String arrayOfStrings[];
arrayOfStrings = inputString.split(" ")

字符串1 = 10

字符串2 = 3

字符串3 = +

字符串4 = 7

字符串5 = *

我认为你应该把它作为字符串而不是单个字符插入。

Java读取行以空格分隔并插入树中

3 个答案: