嵌套路径递归决策树遍历与决策聚合至DecisionResult的实现咨询

核心思路 #

通过递归遍历整个决策树，识别每个decision节点，将其decisionId及对应节点信息存入DecisionResult的映射中。遍历逻辑严格遵循树的结构模式：decision→reason→decision→outcome→terminal，遇到不同类型节点时，递归处理其子节点。

类型定义（先明确结构） #

// 节点基础类型
type BaseNode = {
  type: 'decision' | 'reason' | 'outcome' | 'terminal';
};

// 决策节点
type DecisionNode = BaseNode & {
  type: 'decision';
  decisionId: string;
  reasons: ReasonNode[];
};

// 理由节点
type ReasonNode = BaseNode & {
  type: 'reason';
  next: DecisionNode | OutcomeNode;
};

// 结果节点
type OutcomeNode = BaseNode & {
  type: 'outcome';
  terminal: TerminalNode;
};

// 终端节点
type TerminalNode = BaseNode & {
  type: 'terminal';
  status: 'success' | 'failure';
};

// 聚合结果类型
type DecisionResult = {
  decisions: Record<string, DecisionNode>;
};

示例决策树JSON数据 #

{
  "type": "decision",
  "decisionId": "D001",
  "reasons": [
    {
      "type": "reason",
      "next": {
        "type": "decision",
        "decisionId": "D002",
        "reasons": [
          {
            "type": "reason",
            "next": {
              "type": "outcome",
              "terminal": {
                "type": "terminal",
                "status": "success"
              }
            }
          }
        ]
      }
    },
    {
      "type": "reason",
      "next": {
        "type": "outcome",
        "terminal": {
          "type": "terminal",
          "status": "failure"
        }
      }
    }
  ]
}

遍历与聚合实现函数 #

function aggregateDecisions(node: BaseNode, result: DecisionResult): void {
  switch (node.type) {
    case 'decision':
      // 将决策节点存入映射
      result.decisions[node.decisionId] = node;
      // 遍历所有子reason节点
      node.reasons.forEach(reason => aggregateDecisions(reason, result));
      break;
    case 'reason':
      // 递归处理reason指向的下一个节点
      aggregateDecisions(node.next, result);
      break;
    case 'outcome':
      // 递归处理终端节点（无决策，仅终止路径）
      aggregateDecisions(node.terminal, result);
      break;
    case 'terminal':
      // 终端节点为路径终点，直接返回
      return;
  }
}

// 初始化结果并执行遍历
function getDecisionResult(root: BaseNode): DecisionResult {
  const result: DecisionResult = { decisions: {} };
  aggregateDecisions(root, result);
  return result;
}

使用示例 #

// 假设root是示例JSON解析后的节点
const root: DecisionNode = /* 示例JSON数据 */;
const decisionResult = getDecisionResult(root);

// 输出结果：{ decisions: { D001: [D001节点], D002: [D002节点] } }
console.log(decisionResult);

关键说明 #

• 递归函数会遍历树的每一条路径，不会遗漏任何decision节点
• 映射以decisionId为键，直接存储整个决策节点，方便后续快速查找
• 遍历逻辑完全匹配指定的结构模式，可适配任意深度的决策树

内容的提问来源于stack exchange，提问作者BreenDeen