ExpressionTree: Postfix vers Infix

expression-trees java

Question

Je ne parviens pas à toString() ma toString() pour imprimer et imprimer des parenthèses. Dans ma notation infixe. Par exemple, si je saisis 12+3* le résultat sera 1 + 2 * 3 . Je voudrais qu'il soit imprimé ((1+2) *3) .
De plus, j'aimerais que mon arbre d'expression soit construit lorsqu'il contient un espace dans l'entrée. Par exemple, si je 12+ cela fonctionne, mais je veux pouvoir entrer 1 2 + et cela fonctionne toujours. Des pensées?

PS Ignore ma méthode d'évaluation, je ne l'ai pas encore implémentée!

 // Java program to construct an expression tree

import java.util.EmptyStackException;
import java.util.Scanner;
import java.util.Stack;

import javax.swing.tree.TreeNode;

// Java program for expression tree
class Node {

    char ch;
    Node left, right;

    Node(char item) {
        ch = item;
        left = right = null;
    }
    public String toString() {
        return (right == null && left == null) ? Character.toString(ch) : "(" + left.toString()+ ch + right.toString() + ")";
    }

}

class ExpressionTree {

    static boolean isOperator(char c) {
        if (    c == '+' || 
                c == '-' || 
                c == '*' || 
                c == '/'
               ) {
            return true;
        }
        return false;
    }

    // Utility function to do inorder traversal
    public void inorder(Node t) {
        if (t != null) {
            inorder(t.left);
            System.out.print(t.ch + " ");
            inorder(t.right);
        }
    }

    // Returns root of constructed tree for given
    // postfix expression
    Node constructTree(char postfix[]) {
        Stack<Node> st = new Stack();
        Node t, t1, t2;


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

            // If operand, simply push into stack
            if (!isOperator(postfix[i])) {
                t = new Node(postfix[i]);
                st.push(t);
            } else // operator
            {
                t = new Node(postfix[i]);

                // Pop two top nodes
                // Store top
                t1 = st.pop();      // Remove top
                t2 = st.pop();

                //  make them children
                t.right = t1;
                t.left = t2;

                // System.out.println(t1 + "" + t2);
                // Add this subexpression to stack
                st.push(t);
            }
        }

        //  only element will be root of expression
        // tree
        t = st.peek();
        st.pop();

        return t;
    }

    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        /*boolean keepgoing = true;
        while (keepgoing) {
            String line = input.nextLine();
            if (line.isEmpty()) {
                keepgoing = false;
            } else {
                Double answer = calculate(line);
                System.out.println(answer);
            }
        }*/
        ExpressionTree et = new ExpressionTree();
        String postfix = input.nextLine();
        char[] charArray = postfix.toCharArray();
        Node root = et.constructTree(charArray);
        System.out.println("infix expression is");
        et.inorder(root);
    }


    public double evaluate(Node ptr)
    {
        if (ptr.left == null && ptr.right == null)
            return toDigit(ptr.ch);
        else
        {
            double result = 0.0;
            double left = evaluate(ptr.left);
            double right = evaluate(ptr.right);
            char operator = ptr.ch;

            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;
        }
    }
    private boolean isDigit(char ch)
    {
        return ch >= '0' && ch <= '9';
    }
    private int toDigit(char ch)
    {
        return ch - '0';
    }
}

Réponse acceptée

Changer de main comme ça.

Scanner input = new Scanner(System.in);
String postfix = input.nextLine();
char[] charArray = postfix.replace(" ", "").toCharArray();
Node root = constructTree(charArray);
System.out.println("infix expression is");
System.out.println(root);

Réponse populaire

Pourquoi utilisez-vous inorder ()? root.toString () retourne exactement ce que vous voulez, "((1 + 2) * 3)"

Espaces que vous pouvez ignorer au début de la boucle:

    for (int i = 0; i < postfix.length; i++) {
        if (postfix[i] == ' ')
            continue;
        ...



Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi
Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi