编辑代码

// 设置标准输入接口
const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

// 定义二叉树节点类
class TreeNode {
  constructor(val, left = null, right = null) {
    this.val = val; // 节点值
    this.left = left; // 左子节点
    this.right = right; // 右子节点
  }
}

// 定义二叉树类
class Tree {
  constructor(val) {
    this.root = new TreeNode(val); // 创建根节点
    this.size = 1; // 记录树的节点数量
  }

  // 解析输入字符串构建二叉树
  buildTree(str) {
    let stack = [this.root]; // 使用栈存储当前处理的节点
    let node = this.root; // 当前节点
    let isLeft = true; // 标记是否处理左子节点

    // 遍历输入字符串
    for (let i = 1; i < str.length; i++) {
      const char = str[i];

      if (char === "{") {
        // 遇到左括号，将当前节点入栈
        stack.push(node);
        isLeft = true;
      } else if (char === "}") {
        // 遇到右括号，弹出栈顶节点
        stack.pop();
      } else if (char === ",") {
        // 遇到逗号，切换到处理右子节点
        isLeft = false;
      } else if (char !== " ") {
        // 遇到字母，创建新节点
        const newNode = new TreeNode(char);
        // 根据isLeft标记，设置为左子节点或右子节点
        if (isLeft) {
          stack[stack.length - 1].left = newNode;
        } else {
          stack[stack.length - 1].right = newNode;
        }
        node = newNode;
        this.size++;
      }
    }
  }

  // 中序遍历方法
  inorderTraversal(node = this.root) {
    let result = "";

    // 递归实现中序遍历：左子树 -> 根节点 -> 右子树
    const inorder = (node) => {
      if (!node) return;
      inorder(node.left); // 遍历左子树
      result += node.val; // 访问当前节点
      inorder(node.right); // 遍历右子树
    };

    inorder(node);
    return result;
  }
}

// 主函数
void (async function () {
  // 读取输入字符串
  const str = await readline();
  // 创建二叉树并以第一个字符为根节点值
  const tree = new Tree(str[0]);
  // 解析字符串构建二叉树
  tree.buildTree(str);
  // 输出中序遍历结果
  console.log(tree.inorderTraversal());
})();

// 示例说明：
// 输入：A{B{D,E{G,H}},C{F}}
// 构建的二叉树：
//       A
//      / \
//     B   C
//    / \   \
//   D   E   F
//      / \
//     G   H
// 中序遍历结果：DBGEHACF