思维链提示词：CoT / ToT / GoT 系统化指南（2026 年版）

原创灵阙教研团队

A 推荐入门 | 约 13 分钟阅读更新于 2026-02-28

AI 导读

思维链提示词：CoT / ToT / GoT 系统化指南（2026 年版） 1. 引言大语言模型（LLM）在面对复杂推理任务时，直接给出答案的准确率往往不理想。2022 年，Google 的 Jason Wei 等人提出了 Chain-of-Thought（CoT）提示技术，通过引导模型"一步步思考"显著提升了推理能力。此后，Tree-of-Thought（ToT）和...

思维链提示词：CoT / ToT / GoT 系统化指南（2026 年版）

1. 引言

大语言模型（LLM）在面对复杂推理任务时，直接给出答案的准确率往往不理想。2022 年，Google 的 Jason Wei 等人提出了 Chain-of-Thought（CoT）提示技术，通过引导模型"一步步思考"显著提升了推理能力。此后，Tree-of-Thought（ToT）和 Graph-of-Thought（GoT）相继提出，将思维结构从线性链条扩展到树状和图状。

本文系统化梳理这三种思维结构提示技术的原理、实现方法、适用场景和最佳实践。

2. 思维结构概览

CoT（链式思维）           ToT（树状思维）          GoT（图状思维）
──────────                ──────────              ──────────

  A → B → C → D            A                         A ←→ B
                          / | \                      / \  / \
                         B  C  D                    C   D   E
                        /|     |\                    \ / \ /
                       E F     G H                    F   G
                                                       \ /
                                                        H

线性推理，步步推进     多路径探索，选最优       任意连接，融合思考

维度	CoT	ToT	GoT
论文发表	2022 (Wei et al.)	2023 (Yao et al.)	2023 (Besta et al.)
结构类型	线性链	树（有向无环）	有向图（可有环）
搜索策略	单路径	BFS / DFS	拓扑排序
回溯能力	无	支持	支持
合并能力	无	有限	核心能力
实现复杂度	低	中	高
API 调用次数	1 次	多次	多次
适用场景	常规推理	规划/搜索	复杂综合/创意

3. Chain-of-Thought（CoT）：链式思维

3.1 核心原理

CoT 的核心思想是让模型在给出最终答案之前，先输出中间推理步骤。这模拟了人类"思考过程"的外显化，使模型能够：

将复杂问题分解为简单子步骤
在每一步利用上一步的结论
减少跳跃性推理导致的错误

3.2 CoT 的三种范式

3.2.1 Zero-shot CoT

最简单的实现，只需在提示词中加入"请一步步思考"。

提示词：
Q: 一家商店里有 23 个苹果。如果他们用了 20 个苹果做午餐，又买了 6 个，
   那么他们还有多少个苹果？

让我们一步步思考。

模型输出：
1. 商店最初有 23 个苹果
2. 午餐用了 20 个：23 - 20 = 3 个
3. 又买了 6 个：3 + 6 = 9 个
4. 所以最终还有 9 个苹果

答案：9

关键触发短语（效果由高到低）：

"Let's think step by step"（经典，最有效）
"让我们一步步思考"
"请详细说明你的推理过程"
"在给出答案之前，先分析每个步骤"

3.2.2 Few-shot CoT

提供带有推理过程的示例，让模型模仿。

提示词：
Q: Roger 有 5 个网球。他又买了 2 罐网球，每罐有 3 个。
   他现在有多少个网球？
A: Roger 最初有 5 个网球。2 罐 x 3 个/罐 = 6 个网球。
   5 + 6 = 11。答案是 11。

Q: 食堂有 23 个苹果。如果他们用了 20 个做午餐，又买了 6 个，
   那么他们还有多少个苹果？
A:

Few-shot CoT 的效果通常优于 Zero-shot，因为示例提供了推理格式和粒度的参考。

3.2.3 Auto-CoT

自动生成 CoT 示例，减少人工编写的工作量。

# Auto-CoT 的基本流程
def auto_cot(questions, model):
    # 1. 对问题进行聚类
    clusters = cluster_questions(questions)

    # 2. 从每个聚类中选择代表性问题
    representatives = select_representatives(clusters)

    # 3. 用 Zero-shot CoT 为每个代表性问题生成推理链
    demonstrations = []
    for q in representatives:
        reasoning = model.generate(q + "\nLet's think step by step.")
        demonstrations.append((q, reasoning))

    # 4. 用生成的示例作为 Few-shot CoT 的范例
    return demonstrations

3.3 CoT 的变体

Self-Consistency（自洽性采样）

核心思想：对同一个问题生成多条推理路径，然后用多数投票选择最终答案。

问题: 当我 6 岁时，我妹妹是我年龄的一半。现在我 70 岁，我妹妹多大？

路径 1: 6 岁时妹妹 3 岁，年龄差 3 岁。70 - 3 = 67。答案：67 ✓
路径 2: 6 岁时妹妹 3 岁，年龄差 3 岁。70 - 3 = 67。答案：67 ✓
路径 3: 6/2 = 3，70/2 = 35。答案：35 ✗

多数投票：67（2/3 一致）

Self-Consistency 通常能在 CoT 基础上再提升 5-15% 的准确率。

CoT with Verification（带验证的思维链）

在生成推理链后，增加一个验证步骤。

[生成阶段]
Q: 36 x 25 = ?
步骤 1: 36 x 25 = 36 x (20 + 5)
步骤 2: 36 x 20 = 720
步骤 3: 36 x 5 = 180
步骤 4: 720 + 180 = 900

[验证阶段]
验证：900 / 36 = 25 ✓
验证：900 / 25 = 36 ✓
结果确认：900

3.4 CoT 最佳实践

实践	说明
匹配任务复杂度	简单任务不需要 CoT（反而可能降低性能）
提供清晰的推理示例	Few-shot 的示例要覆盖不同推理模式
使用结构化格式	编号步骤比自由格式更可靠
结合 Self-Consistency	多路径采样 + 投票显著提升准确率
适配模型能力	较小的模型可能无法有效利用 CoT
控制推理长度	过长的推理链可能引入累积误差

3.5 CoT 的局限性

单一路径：只探索一条推理路径，如果前期步骤出错，无法自我纠正
不适合探索性问题：需要比较多个方案的问题，线性推理不够
可能过度思考：对简单问题使用 CoT 反而引入不必要的中间步骤
成本增加：推理步骤意味着更多的输出 token

4. Tree-of-Thought（ToT）：树状思维

4.1 核心原理

ToT 将推理过程组织为一棵搜索树：

每个节点代表一个"思维状态"（partial solution）
每个分支代表一种可能的推理方向
通过评估函数选择最有前景的分支
支持回溯（backtracking）和剪枝（pruning）

4.2 ToT 的工作流程

Step 1: 思维分解（Thought Decomposition）
  将问题分解为可以逐步推进的思维单元

Step 2: 思维生成（Thought Generation）
  在每个节点生成 k 个候选思维
  - 采样生成：独立采样 k 次
  - 提议生成：一次性生成 k 个候选

Step 3: 状态评估（State Evaluation）
  评估每个思维状态的前景
  - 价值评估：打分 1-10
  - 投票评估：模型投票选择最优

Step 4: 搜索算法（Search Algorithm）
  - BFS（广度优先）：每层保留 top-b 个状态
  - DFS（深度优先）：深入探索一条路径，失败则回溯

4.3 ToT 实现示例

以"24 点游戏"为例：给定 4 个数字，使用加减乘除使结果等于 24。

输入：1, 2, 3, 4

第一层（选择第一步运算）：
  思维 A: 1 + 2 = 3（剩余：3, 3, 4）  评估：中等
  思维 B: 2 * 3 = 6（剩余：1, 6, 4）  评估：有前景
  思维 C: 3 * 4 = 12（剩余：1, 2, 12） 评估：有前景

第二层（基于思维 B：1, 6, 4）：
  思维 B1: 6 - 1 = 5（剩余：5, 4）    评估：5*4=20, 低前景
  思维 B2: 6 * 4 = 24（剩余：1, 24）   评估：24-1=23/24+1=25, 低
  思维 B3: 1 + 6 = 7（剩余：7, 4）    评估：7*4=28, 低

第二层（基于思维 C：1, 2, 12）：
  思维 C1: 1 + 2 = 3（剩余：3, 12）   评估：3*12=36, 低
  思维 C2: 2 * 12 = 24（剩余：1, 24）  评估：同上
  思维 C3: 12 / 2 = 6（剩余：1, 6）   评估：低
  思维 C4: 12 + 2 = 14（剩余：1, 14）  评估：低

回溯到第一层，尝试更多组合...
  思维 D: 1 * 2 = 2（剩余：2, 3, 4）
  思维 D1: 2 + 3 = 5（剩余：5, 4）
  思维 D2: 2 * 3 = 6（剩余：6, 4）    评估：6*4=24！

解答：1 * 2 = 2, 2 * 3 = 6, 6 * 4 = 24

4.4 ToT 的代码框架

class TreeOfThought:
    def __init__(self, model, max_depth=3, branching_factor=3):
        self.model = model
        self.max_depth = max_depth
        self.branching_factor = branching_factor

    def solve(self, problem):
        root = ThoughtNode(state=problem, depth=0)
        return self.bfs(root)

    def bfs(self, root):
        queue = [root]
        for depth in range(self.max_depth):
            candidates = []
            for node in queue:
                # 生成候选思维
                thoughts = self.generate_thoughts(node, self.branching_factor)
                for thought in thoughts:
                    child = ThoughtNode(
                        state=node.state + "\n" + thought,
                        depth=depth + 1,
                        parent=node
                    )
                    # 评估状态
                    child.value = self.evaluate_state(child)
                    candidates.append(child)

            # 保留 top-b 候选
            queue = sorted(candidates, key=lambda x: x.value, reverse=True)
            queue = queue[:self.branching_factor]

            # 检查是否找到解
            for node in queue:
                if self.is_solution(node):
                    return node

        return queue[0]  # 返回最优候选

    def generate_thoughts(self, node, k):
        prompt = f"""
        问题：{node.state}
        请生成 {k} 个不同的下一步思考方向：
        """
        return self.model.generate(prompt, n=k)

    def evaluate_state(self, node):
        prompt = f"""
        对以下推理状态的前景进行评估（1-10 分）：
        {node.state}
        评估标准：是否有可能达到正确答案？
        """
        return float(self.model.generate(prompt))

4.5 ToT 适用场景

场景	说明	示例
数学谜题	需要尝试多种运算组合	24 点、数独
创意写作	需要探索多个情节方向	故事大纲、广告语
规划问题	需要比较多条路径	旅行规划、项目排期
代码生成	需要尝试多种实现方案	算法设计
策略游戏	需要前瞻性思考	棋类分析

4.6 ToT 的局限性

成本高：每个节点都需要 LLM 调用，API 费用显著增加
延迟高：多轮 LLM 调用导致端到端延迟大幅增加
评估函数依赖 LLM：评估本身可能不准确
不支持思维合并：不同分支的有价值思维无法融合

5. Graph-of-Thought（GoT）：图状思维

5.1 核心原理

GoT 是 ToT 的进一步泛化，将思维结构从树扩展为有向图：

节点合并：不同推理路径的中间结果可以合并
循环推理：允许对已有结论进行修正和迭代
多源融合：可以从多个角度的推理结果中综合最终答案

5.2 GoT 的核心操作

GoT 定义了三类基本操作：

1. 生成（Generate）
   从一个思维节点生成新的思维节点
   类似 CoT 的"下一步"和 ToT 的"分支"

2. 聚合（Aggregate）
   将多个思维节点合并为一个
   这是 GoT 的独特能力

3. 精炼（Refine）
   对一个思维节点进行自我改进
   类似于 Self-Refine

5.3 GoT 适用场景

场景	说明	为什么需要图结构
排序问题	将大数组分块排序后合并	合并操作
文档摘要	分段摘要后综合	多源聚合
多视角分析	从不同角度分析后综合	思维融合
代码审查	多个审查意见综合成结论	聚合 + 精炼
论证分析	正方、反方论点综合	对立思维合并

5.4 GoT 实现示例

以"对一段文本进行多维度分析"为例：

原始文本: "公司 Q3 营收同比增长 15%，但利润率下降 3 个百分点"

[生成] 维度拆分：
  节点 A: 财务分析 → "营收增长 15% 显示业务扩张"
  节点 B: 成本分析 → "利润率下降说明成本增长超过营收增长"
  节点 C: 趋势分析 → "增收不增利可能预示定价压力或效率问题"

[聚合] A + B → 节点 D:
  "公司处于增长期但成本控制能力减弱，可能是扩张投入所致"

[聚合] D + C → 节点 E:
  "短期增长与长期盈利能力之间存在张力，需要关注成本结构变化"

[精炼] E → 节点 F:
  "建议关注三个指标：1) 营销费用率 2) 人员增速 vs 营收增速
   3) 毛利率趋势，以判断利润率下降是战略性投入还是结构性恶化"

5.5 GoT 的代码框架

class GraphOfThought:
    def __init__(self, model):
        self.model = model
        self.nodes = {}
        self.edges = []

    def generate(self, parent_ids, prompt):
        """从一个或多个父节点生成新思维"""
        context = "\n".join(
            self.nodes[pid].content for pid in parent_ids
        )
        new_content = self.model.generate(
            f"基于以下思考：\n{context}\n\n{prompt}"
        )
        node_id = self.add_node(new_content, parent_ids)
        return node_id

    def aggregate(self, node_ids, instruction):
        """合并多个思维节点"""
        contents = [self.nodes[nid].content for nid in node_ids]
        merged = self.model.generate(
            f"请综合以下多个分析：\n"
            + "\n---\n".join(contents)
            + f"\n\n综合指令：{instruction}"
        )
        node_id = self.add_node(merged, node_ids)
        return node_id

    def refine(self, node_id, feedback):
        """精炼一个思维节点"""
        original = self.nodes[node_id].content
        refined = self.model.generate(
            f"原始分析：{original}\n"
            f"改进方向：{feedback}\n"
            f"请提供改进后的分析："
        )
        new_id = self.add_node(refined, [node_id])
        return new_id

6. 三种方法的综合对比

6.1 性能对比

以不同任务类型的准确率提升为参考：

任务	直接回答	CoT	ToT	GoT
算术推理	60%	85%	88%	87%
符号推理	40%	75%	82%	80%
常识推理	70%	80%	83%	85%
创意写作	N/A	良好	优秀	优秀
规划问题	50%	65%	80%	78%
排序问题	N/A	一般	一般	优秀

6.2 成本对比

假设单次 LLM 调用成本为 1 单位：

方法	典型 API 调用次数	相对成本	延迟
直接回答	1	1x	~1s
Zero-shot CoT	1	~1.5x（更多输出 token）	~2s
Few-shot CoT	1	~2x（更长的输入）	~3s
Self-Consistency	5-10	5-10x	~5s
ToT (BFS, b=3, d=3)	~30	30x	~30s
GoT	~20-50	20-50x	~30-60s

6.3 选择指南

你的任务需要什么？

├── 简单的逐步推理
│   └── 使用 CoT（Zero-shot 或 Few-shot）
│
├── 需要比较多种方案
│   └── 使用 ToT（BFS 或 DFS）
│
├── 需要综合多个视角
│   └── 使用 GoT（聚合操作）
│
├── 需要高可靠性
│   └── CoT + Self-Consistency
│
├── 预算有限
│   └── Zero-shot CoT（成本最低）
│
└── 实时性要求高
    └── Zero-shot CoT 或直接回答

7. 进阶技术

7.1 Algorithm of Thoughts（AoT）

2023 年提出，核心思想是让模型在单次推理中模拟算法化的搜索过程（如 DFS），减少 API 调用次数。

7.2 Everything of Thoughts（XoT）

2024 年提出，结合外部知识库和强化学习，动态选择最优的思维结构。

7.3 与 o1/o3 等推理模型的关系

OpenAI 的 o1 和 o3 系列模型内置了类似 CoT 的"隐式推理链"。使用这些模型时：

不需要显式 CoT：模型自动在内部进行多步推理
ToT/GoT 仍有价值：当需要外部可审计的推理过程、多路径搜索或思维合并时
互补使用：o1 作为 ToT/GoT 中每个节点的推理引擎

8. 实践建议

8.1 快速入门路径

入门：Zero-shot CoT
  ↓
进阶：Few-shot CoT + Self-Consistency
  ↓
高级：ToT（用于规划/搜索类问题）
  ↓
专家：GoT（用于多维综合分析）

8.2 常见陷阱

陷阱	说明	解决方案
过度使用 CoT	简单问题不需要 CoT	根据任务复杂度选择
推理链过长	累积误差导致最终结果偏差	控制步骤数量，增加验证
评估函数不准	ToT 的搜索效果依赖评估质量	使用多次投票评估
忽略成本	ToT/GoT 的 API 调用成本高	先估算成本再决策
硬编码推理模板	不同任务需要不同的推理格式	针对任务类型定制模板

9. 结论

CoT、ToT、GoT 代表了提示词工程中"结构化思维"的三个递进层次：

CoT 是基础，几乎所有需要推理的任务都能从中受益
ToT 在需要搜索和比较的场景中显著优于 CoT
GoT 在需要多视角融合的复杂分析中展现独特价值

随着推理模型（o1/o3/Gemini 2.0 Thinking）的发展，显式的 CoT 正在被模型内化。但 ToT 和 GoT 的"结构化搜索和融合"思想，仍然是构建复杂 AI 系统的重要设计模式。

Maurice | maurice_wen@proton.me