为括号串构建一个树

Build a tree for string of parentheses

本文关键字：一个 构建      更新时间：2023-10-16

我有一个

typedef struct node
{
   node* br;
   node* son;
};

给定由(、)的序列组成的字符串char* str我需要为这个字符串构建一个树，例如：对于字符串（（）（））（），将构建以下树：

       br        br 
node ----- node ---- NULL
    |son    |son
    |      NULL
    |   br        br      br
   node --- node --- node --- NULL
           |son   |son
          NULL   NULL

您的树有点难以阅读。我假设每个括号都是一个节点，所有嵌套的括号都是子节点。

这里有一个简单的算法：

We start with a root node representing the empty string.
For each char c in the string s:
    if c == '(':
        create a new child node
        move to the new created node
    else:
        move to the parent node

这会给你一棵好看的树。Ofc您必须检查字符串是否有效，并在需要时进行补偿/更正。

此代码使用堆栈来存储与尚未看到闭合paren的打开paren相对应的节点。当它看到一个打开的paren时，它会将一个新节点推送到堆栈中。当它看到一个闭合的paren时，它会从堆栈中删除当前的顶部节点，并使其成为其父节点的子节点，父节点就是它下面的节点。

#include <list>
#include <stack>
#include <functional>
#include <iostream>
struct Node {
    std::list<Node> children;
};
bool parse_parens (const char *str, Node *out)
{
    // stack of nodes for which open paren was seen but
    // close paren has not yet been seen
    std::stack<Node> stack;
    // push the virtual root node which doesn't correspond
    // to any parens
    stack.push(Node());
    for (size_t i = 0; str[i]; i++) {
        if (str[i] == '(') {
            // push new node to stack
            stack.push(Node());
        }
        else if (str[i] == ')') {
            if (stack.size() <= 1) {
                // too many close parens
                // (<=1 because root has no close paren)
                return false;
            }
            // Current top node on stack was created from the
            // open paren which corresponds to the close paren
            // we've just seen. Remove this node it from the stack.
            Node top = std::move(stack.top());
            stack.pop();
            // Make it a child of the node which was just below it.
            stack.top().children.push_back(std::move(top));
        }
        else {
            // bad character
            return false;
        }
    }
    if (stack.size() > 1) {
        // missing close parens
        return false;
    }
    // return the root node
    *out = std::move(stack.top());
    return true;
}
bool print_parens (const Node &node)
{
    for (std::list<Node>::const_iterator it = node.children.begin(); it != node.children.end(); ++it) {
        const Node &child = *it;
        std::cout << "(";
        print_parens(child);
        std::cout << ")";
    }
}
int main ()
{
    Node root;
    bool res = parse_parens("(())()(()())", &root);
    if (!res) {
        std::cout << "Error parsing!n";
        return 1;
    }
    print_parens(root);
    std::cout << "n";
    return 0;
}

这使用std::list来存储同级节点，这比您提出的更容易使用。然而，同样的算法也应该在那里工作。

您可以使用stack来实现这一点，找到左括号后，将此节点添加到stack中。如果再次使用左括号，则将子元素添加到堆栈的最顶端元素。在右括号中，从堆栈中删除节点。就是这样。

相关文章：