个人中心
gpt4 book ai didi

Java 二进制表达式树 - 检查表达式中的括号

转载 作者：行者123 更新时间：2023-11-29 06:02:59 24 4
gpt4 key购买 nike

<分区>

我编写了这个程序，它将采用一个中缀符号表达式并从中构建一个二叉树。现在唯一实际有效的输入表达式就像 2 + 2。我似乎完全不知道如何让它处理括号并接受更长的表达式，例如 ( ( 2 + 2 ) * 3 )。对于我的输出，我试图将其转换为后缀表示法并计算表达式。所以现在如果我在没有括号的情况下插入 2 + 2，我的输出是 22+ 并且它会评估它所以它会打印 4。

我需要找到一种方法，让它打印出每个数字和运算符之间有空格的输出，并让它接受带括号的更长表达式。我现在不知道如何从这里继续。谁能帮帮我？

谢谢!

这是我的代码:

class ExpressionEvaluator<T> {

    ExpressionEvaluator() {
        Scanner reader = new Scanner(System.in);

        System.out.println("Enter your expression: ");
        String expression = reader.nextLine();    // Reads the expression and trims the spaces.
        expression = expression.replaceAll(" ", "");
        ExpressTree<T> tree = new ExpressTree(expression); // Creates a new binary tree.
    }

    public static void main(String[] args) {
        new ExpressionEvaluator();
    }
}


interface Tree<T> {

    // This is the tree interface with its methods.
    public Node<T> getRoot();

    public void setRoot(Node<T> value);
}


class ExpressTree<T> implements Tree<T> {

    private Node<T> _root;
    private String _value, _expression;
    private Node<T> _treeNode;
    private Stack storage1;
    private Stack<String> storage2;

    public ExpressTree(String expression) {
        expressTreeBuilder(expression);        // Calls the expressTreeBuilder method on the expression.
        postfixTraversal(this.getRoot());
        System.out.println("");
        System.out.println(this.storage2.pop());
    }

    public Node<T> getRoot() {        // Gets the root of the tree.
        return _root;
    }

    public void setRoot(Node<T> _treeNode2) {        // Sets the root which will always be an operator.
        this._root = _treeNode2;
    }

    public boolean isDigit(char value) {    // Method to check if a value is a digit or not.
        if (Character.isDigit(value)) {
            return true;
        } else {
            return false;
        }
    }

    public void expressTreeBuilder(String expression) {

        storage1 = new Stack();    // Stores the nodes.
        storage2 = new Stack<String>();        // Stores the value of the nodes.
        _treeNode = new Node();        // Creates a new node
        _value = null;
        String next = "";

        for (int i = 0; i < expression.length(); i++) {
            char traverse = expression.charAt(i);
            if (i + 1 < expression.length()) {
                next = Character.toString(expression.charAt(i + 1));
            }

            if (traverse == '+') {        // This checks to see the expression is an addition operator.
                Node<T> pop1, pop2;        // It pops the first 2 values from the stack and stores them
                String value1, value2;    // in pop1 and pop2. Then it uses another stack to add them.
                pop1 = (Node<T>) storage1.pop();
                value1 = storage2.pop();    // Stores the right side value.
                value2 = next;    // Stores the left side value.
                _treeNode = new Node();
                _treeNode.setElement(Character.toString(traverse));
                pop2 = new Node();
                pop2.setElement(next);
                pop1.setParent(_treeNode);
                pop2.setParent(_treeNode);
                _treeNode.setLeftSide(pop1);        // Sets the right side of the subtree.
                _treeNode.setRightSide(pop2);        // Sets the left side of the subtree.
                storage1.push(_treeNode);
                storage1.push(pop2);
                int add = (Integer.parseInt(value2) + Integer.parseInt(value1));
                storage2.push(Integer.toString(add));
                this.setRoot(_treeNode);
                i++;
            } else if (traverse == '-') {        // This checks to see the expression is a subtraction operator.
                Node<T> pop1, pop2;        // It pops the first 2 values from the stack and stores them
                String value1, value2;    // in pop1 and pop2. Then it uses another stack to subtract them.
                pop1 = (Node<T>) storage1.pop();
                value1 = storage2.pop();    // Stores the right side value.
                value2 = next;    // Stores the left side value.
                _treeNode = new Node();
                _treeNode.setElement(Character.toString(traverse));
                pop2 = new Node();
                pop2.setElement(next);
                pop1.setParent(_treeNode);
                pop2.setParent(_treeNode);
                _treeNode.setLeftSide(pop1);        // Sets the right side of the subtree.
                _treeNode.setRightSide(pop2);        // Sets the left side of the subtree.
                storage1.push(_treeNode);
                storage1.push(pop2);
                int subtract = (Integer.parseInt(value2) - Integer.parseInt(value1));
                storage2.push(Integer.toString(subtract));
                this.setRoot(_treeNode);
                i++;
            } else if (traverse == '*') {    // This checks to see the expression is a multiplication operator.
                Node<T> pop1, pop2;    // It pops the first 2 values from the stack and stores them
                String value1, value2;    // in pop1 and pop2. Then it uses another stack to multiply them.
                pop1 = (Node<T>) storage1.pop();
                value1 = storage2.pop();    // Stores the right side value.
                value2 = next;    // Stores the left side value.
                _treeNode = new Node();
                _treeNode.setElement(Character.toString(traverse));
                pop2 = new Node();
                pop2.setElement(next);
                pop1.setParent(_treeNode);
                pop2.setParent(_treeNode);
                _treeNode.setLeftSide(pop1);        // Sets the right side of the subtree.
                _treeNode.setRightSide(pop2);        // Sets the left side of the subtree.
                storage1.push(_treeNode);
                storage1.push(pop2);
                int multiply = (Integer.parseInt(value2) * Integer.parseInt(value1));
                storage2.push(Integer.toString(multiply));
                this.setRoot(_treeNode);
                i++;
            } else if (traverse == '(') {

            } else {
                _treeNode = new Node();
                String digits = "";
                while (i < expression.length() && isDigit(expression.charAt(i))) {
                    digits += expression.charAt(i);    // Checks if the value found at the expression is digit
                    if (digits.length() == 1) {
                        break;
                    }
                    i++;
                }

                _treeNode.setElement(digits);        // If it is it will set the element of the node
                storage1.push(_treeNode);        // The node will be pushed onto the stack.
                storage2.push(digits);            // This node will store it's value.
            }
        }
    }

    public void infixTraversal(Node<T> n) {
        if (n != null) {
            infixTraversal(n.getLeftSide());
            System.out.print(n.element() + "");
            infixTraversal(n.getRightSide());
        }
    }

    public void postfixTraversal(Node<T> n) {
        if (n != null) {
            postfixTraversal(n.getLeftSide());
            postfixTraversal(n.getRightSide());
            System.out.print(n.element());
        }
    }
}


class Node<T> {

    public Node<T> _left, _right, _parent;
    private String _element;

    public Node() {
        this._element = null;
        this._left = null;
        this._right = null;
        this._parent = null;
    }

    public String element() {                    // Gets the value of the node.
        return _element;
    }

    public Node<T> getLeftSide() {                // Gets the left side of the node.
        return _left;
    }

    public Node<T> getRightSide() {                // Gets the right side of the node.
        return _right;
    }

    public Node<T> getParent() {                // Gets the parent of the node.
        return _parent;
    }

    public void setElement(String e) {            // Sets the value of the node.
        _element = e;
    }

    public void setLeftSide(Node<T> n) {        // Sets the left side of the node.
        _left = n;
    }

    public void setRightSide(Node<T> n) {        // Sets the right side of the node.
        _right = n;
    }

    public void setParent(Node<T> n) {            // Sets the parent of the node.
        _parent = n;
    }
}

24 4 0
文章推荐： java - 在 java 支持代码中使用资源包字符串？
文章推荐： ios - 在自定义 Swift 框架中的 Objective-C 文件上使用 Swift
文章推荐： ios - 禁用 SpriteKit 中 SKNode 的旋转
文章推荐： java - 使用升序和降序数字在 Java 中打印居中金字塔
行者123
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com