我们有一个这种格式的输入字符串"(1(2(4)(5))(3(6(8)(9))(7)))"
我们必须构建一个二叉树，使得1 是根节点，第一个完整的括号包含(2(4)(5)) 包含1 的左孩子的家庭(3(6(8)(9))(7)) 是根 A 的右孩子的家庭。
最后，树看起来像这样。
Like this
我无法找到编写转换此算法的确切算法。提前致谢！
【问题讨论】：
标签： string algorithm binary-tree parentheses
当然，我不能只在这里为你的作业编写代码 :-) 但我认为如果你将每个符号都视为一个操作可能会有所帮助，例如
( = down
1 = add
( = down
2 = add
( = down
4 = add
) = up (goes to level of 2)
( = down
5 = add
) = up (goes to level of 2)
) = up (goes to level of 1)
( = down
3 = add
( = down
6 = add
( = down
8 = add
) = up (goes to level of 6)
( = down
9 = add
) = up (goes to level of 6)
) = up (goes to level of 3)
( = down
7 = add
) = up (goes to level of 3)
) = up (goes to level of 1)
) = up (leaves)
如果您考虑递归算法，您可能会将“向下”视为递归方法调用，而“向上”视为从递归方法调用返回（自动发生，然后方法本身完成）。
我强烈建议你尝试解决问题，因为学习真的很重要。
但是，如果您仍然找不到解决方案，您可以在此处找到有关如何解决问题的详细说明。 https://www.geeksforgeeks.org/construct-binary-tree-string-bracket-representation/
【讨论】：
思考堆栈。 当你看到 "(" 将元素推入堆栈，当你看到 ")" 时弹出堆栈，但将其作为子元素分配给堆栈的顶部元素。
让我们看一下"( 1 ( 2 ( 4 ) ( 5 ) ) ( 3 ( 6 ( 8 ) ( 9 ) ) ( 7 ) ) )"的例子
(1 -> 推 1
(2 -> 推 2
(4 -> 推 4
) -> 弹出 4，但将 4 作为子级分配到堆栈顶部，即 2（查看左侧是否可用，然后分配为左侧子级，否则分配为右侧子级）
当前树：
当前树：
当前树：
(3 -> 推 3
(6 -> 推 6
(8 -> 推 8
) -> 弹出 8，堆栈顶部 6 的左侧可用，将 8 分配为 6 的左侧
当前树：
(9 -> 推 9
) -> pop 9 -> 将其添加到堆栈的右孩子的顶部，即 6 的右孩子，因为 6 的左边被视为 8。
当前树：
当前树：
(7 -> 推 7
) -> pop 7 -> 将其添加到堆栈顶部，即 3 的右孩子，因为 3 的左孩子被视为 6。
当前树：
在 Java 中使用堆栈实现的完整可运行示例是：
import java.util.*;
public class Main
{
public static void main(String[] args) {
TreeNode root = buildTree("(1(2(4)(5))(3(6(8)(9))(7)))");
levelOrder(root);
}
static class TreeNode {
int val;
TreeNode left, right;
public TreeNode(int val) {
this.val = val;
}
}
private static TreeNode buildTree(String s) {
Deque<TreeNode> dq = new ArrayDeque<>();
TreeNode rootNode = null;
for ( int i = 0; i < s.length(); i++ ) {
if ( s.charAt(i) == '(' ) {
Integer current = Integer.parseInt(String.valueOf(s.charAt(i+1)));
dq.push(new TreeNode(current));
} else if ( s.charAt(i) == ')' ) {
TreeNode node = dq.pop();
if ( dq.isEmpty() ) {
break;
} else {
rootNode = dq.peek();
if (rootNode.left == null) {
rootNode.left = node;
} else {
rootNode.right = node;
}
}
}
}
return rootNode;
}
private static void levelOrder(TreeNode root) {
Deque<TreeNode> dq = new ArrayDeque<>();
dq.offer(root);
while(!dq.isEmpty()) {
int sz = dq.size();
for ( int i = 0; i < sz; i++ ) {
TreeNode node = dq.poll();
System.out.print(node.val + " ");
if ( node.left != null ) {
dq.offer(node.left);
}
if ( node.right != null ) {
dq.offer(node.right);
}
}
System.out.println();
}
}
}
【讨论】：
字符串按前序顺序列出节点。因此，递归解决方案将是一种可能的选择。
在 JavaScript 中你可以这样写：
class Node {
constructor(value) {
this.value = value;
this.children = [];
}
}
function createTree(str) {
// Extract numbers and parentheses from input into an array
let tokens = str.match(/\d+|./g);
if (!tokens) return null;
let i = 1; // skip first character, as it must be a "("
function recur() {
let node = new Node(tokens[i++]);
while (tokens[i++] != ")") {
node.children.push(recur());
}
return node;
}
return recur();
}
// Demo run
let str = "(1(2(4)(5))(3(6(8)(9))(7)))";
let tree = createTree(str);
// Output the tree in JSON format
console.log(JSON.stringify(tree, null, 2));请注意，此实现不会对输入进行任何验证。假设输入的语法正确。
该算法将接受非二叉树的编码，因为这种格式可以编码具有任意数量子节点的节点。
【讨论】：