java解析带有括号的字符串表达式列出组合结构

Java解析带有括号的字符串表达式列出组合结构

在编程中，我们经常需要解析带有括号的字符串表达式，特别是在数学计算和布尔逻辑中。本文将介绍如何使用Java解析带有括号的字符串表达式，并列出解析后的组合结构。

什么是带有括号的字符串表达式？

带有括号的字符串表达式是一种常见的数学或逻辑表达式，它使用括号来明确指定操作的优先级。例如，一个简单的加法表达式可以写为 (2 + 3)，其中括号指定了加法操作的优先级。复杂的表达式可能包含多个嵌套的括号，如 (2 + (3 * 4))。

解析带有括号的字符串表达式

要解析带有括号的字符串表达式，我们可以使用栈（Stack）数据结构和递归算法。以下是一个用Java实现的示例代码：

import java.util.Stack;

public class ExpressionParser {

    public static void main(String[] args) {
        String expression = "(2 + (3 * 4))";
        ExpressionNode root = parseExpression(expression);
        printExpressionTree(root);
    }

    public static ExpressionNode parseExpression(String expression) {
        Stack<ExpressionNode> stack = new Stack<>();

        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);

            if (c == '(') {
                ExpressionNode node = new ExpressionNode();
                stack.push(node);
            } else if (Character.isDigit(c)) {
                ExpressionNode node = new ExpressionNode();
                node.setValue(Character.getNumericValue(c));
                if (!stack.empty()) {
                    ExpressionNode top = stack.peek();
                    top.addChild(node);
                }
            } else if (c == '+' || c == '-' || c == '*' || c == '/') {
                if (!stack.empty()) {
                    ExpressionNode top = stack.peek();
                    top.setOperation(c);
                }
            } else if (c == ')') {
                if (!stack.empty()) {
                    ExpressionNode top = stack.pop();
                    if (!stack.empty()) {
                        ExpressionNode parent = stack.peek();
                        parent.addChild(top);
                    }
                }
            }
        }

        if (!stack.empty()) {
            return stack.pop();
        }

        return null;
    }

    public static void printExpressionTree(ExpressionNode node) {
        if (node == null) {
            return;
        }

        if (node.isLeaf()) {
            System.out.print(node.getValue());
        } else {
            System.out.print("(");
            printExpressionTree(node.getChild(0));
            System.out.print(" " + node.getOperation() + " ");
            printExpressionTree(node.getChild(1));
            System.out.print(")");
        }
    }
}

class ExpressionNode {
    private int value;
    private char operation;
    private ExpressionNode[] children;

    public ExpressionNode() {
        children = new ExpressionNode[2];
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public char getOperation() {
        return operation;
    }

    public void setOperation(char operation) {
        this.operation = operation;
    }

    public void addChild(ExpressionNode child) {
        for (int i = 0; i < children.length; i++) {
            if (children[i] == null) {
                children[i] = child;
                break;
            }
        }
    }

    public ExpressionNode getChild(int index) {
        if (index >= 0 && index < children.length) {
            return children[index];
        }
        return null;
    }

    public boolean isLeaf() {
        return children[0] == null && children[1] == null;
    }
}

在上述代码中，我们使用了一个ExpressionNode类表示表达式的节点。每个节点包含一个值、一个操作符和最多两个子节点。我们还使用了一个栈来跟踪节点的层次结构。

列出解析后的组合结构

为了列出解析后的组合结构，我们可以使用序列图（Sequence Diagram）和状态图（State Diagram）。

序列图

以下是使用mermaid语法绘制的解析过程的序列图：

sequenceDiagram
    participant Parser
    participant Stack
    participant ExpressionNode

    Parser ->> Stack: 创建空栈
    Parser ->> ExpressionNode: 创建根节点
    Parser ->> Stack: 压入根节点
    Parser ->> Stack: 弹出根节点
    Parser ->> Stack: 压入父节点