Question

我有一个

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

给定一个字符串char* str，其中包含(，)的序列我需要为这个字符串构建一个树，例如：对于string（（）（））（），将构建以下树：

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

Answer 1

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

这是一个简单的算法：

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

这应该会给你一个漂亮的树。你需要检查字符串是否有效，并在需要时补偿/纠正。

Answer 2

此代码使用堆栈来存储对应于尚未看到close paren的开放parens的节点。当它看到一个打开的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来存储兄弟节点，这比你提出的更容易使用。但是同样的算法也应该在那里工作。

Answer 3

您可以使用堆栈来实现此功能，一旦找到左括号，然后将此节点添加到堆栈。如果再次左括号将child添加到堆栈的最顶层元素。在右括号中从堆栈中删除节点。那就是它。

为括号字符串构建树

3 个答案: