leecodecode【二叉树递归+对称】【2026.6.1打卡-java版本】

二叉树的最大深度

要点： 递：左子树，右子树， 归：null

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }

        int left = maxDepth(root.left);
        int right = maxDepth(root.right);

        return Math.max(left, right) + 1;
        
    }
}

相同的树

要点：递，两个节点对比， 归：不同

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p == null || q == null){
            return p == q;
        }

        return p.val == q.val  && isSameTree(p.left, q.left) && isSameTree(q.right, p.right);
        
    }
}

对称二叉树

要点：上面的，一个root，变成左右两边

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {

        return isSame(root,root);
        
    }

    public boolean isSame(TreeNode p, TreeNode q){
        if(p == null || q == null){
            return p == q;
        }

        return p.val == q.val && isSame(p.left, q.right) && isSame(p.right, q.left);
    }
}

平衡二叉树

要点：类似深度那个题目，递归长度，left - right绝对值大于1就直接-1

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {

        return height(root) == -1 ? false : true;
        
    }

    public int height(TreeNode root){
        if(root == null){
            return 0;
        }

        int left = height(root.left);
        if(left == -1){
            return -1;
        }
        int right = height(root.right);
        if(right == -1 || Math.abs(left - right) > 1){
            return -1;
        }

        return Math.max(left, right) + 1;
    }
}

二叉树的右视图

要点：深度==size的个数加入ans，先right在left

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        dfs(root, 0, ans);
        return ans;
        
    }

    public void dfs(TreeNode root, Integer depth, List<Integer> ans){
        if(root == null){
            return;
        }

        if(depth == ans.size()){
            ans.add(root.val);
        }

        dfs(root.right, depth+1, ans);
        dfs(root.left, depth+1, ans);
    }
}

随机知识

第6章：从零实现智能体核心

核心概念

• 智能体（Agent）：能够感知环境、自主决策并执行动作的AI系统。

• ReAct范式 ：交替进行推理（Reasoning） 和行动（Action），形成"思考-行动-观察"循环。

• 工具（Tool）：智能体调用的外部能力（如计算器、搜索引擎、代码执行器）。

关键实现

• 手工实现ReActAgent：包含提示构造、工具注册、循环控制、结果解析。

• 工具定义：每个工具包含名称、描述、参数schema、执行函数。

• 循环终止条件：达到最大迭代次数、任务完成标志。

核心代码模式

python

class ReActAgent:
    def run(self, task):
        for _ in range(max_steps):
            thought, action, action_input = self.think(task)
            observation = self.tools[action](action_input)
            if action == "finish":
                return observation

意义

从零实现帮助理解智能体的底层机制，为后续框架化学习奠定基础。

---

第7章：HelloAgents框架构建

核心概念

• 万物皆为工具 ：将Memory、RAG、MCP等模块都抽象为统一的BaseTool接口。

• 框架化优势：解耦LLM、标准化消息、集中配置管理、可扩展工具系统。

• 四种Agent范式：ReAct、Reflection、Plan-and-Solve、Tree-of-Thought。

关键组件

组件	作用
HelloAgentsLLM	统一多模型供应商接口，支持自动检测
Message（Pydantic）	标准化对话消息，带类型校验
Config（单例）	集中管理环境变量和运行时参数
BaseTool	所有工具的抽象基类，强制实现execute
ToolChain	串联多个工具形成流水线

设计模式

• 模板方法 ：Agent.run定义骨架，_execute由子类实现。

• 单例模式：配置管理使用单例，避免重复加载。

• 适配器模式 ：HelloAgentsLLM适配不同供应商API。

实践意义

框架降低了开发复杂度，提升了可维护性和扩展性，是构建生产级智能体的基础。

---

第8章：记忆系统与RAG

四种记忆类型

记忆类型	存储介质	评分/检索特点	用途
工作记忆	内存（TTL）	时间过期，不评分	临时缓存当前对话信息
情景记忆	向量数据库	时间近因性(0.2) + 重要性(0.5) + 情绪(0.3)	记录个人历史经历
语义记忆	图数据库（Neo4j）	图连接度(0.4) + 检索频次(0.3) + 全局重要性(0.3)	存储知识图谱
感知记忆	非结构化缓存	模式匹配后提炼	处理原始传感器数据

RAG系统关键组件

• 文档加载与解析：MarkItDown统一转换为Markdown。

• 智能分块：基于标题层次或语义边界（句子嵌入相似度变化点）。

• 嵌入模型：可选百炼API、本地Transformer、TF-IDF。

• 检索增强策略：

  • MQE：生成多个查询变体，合并结果。

  • HyDE：先生成假设文档，再用其嵌入检索。

遗忘与归档

• 智能遗忘：综合重要性、访问频率、时间衰减、图连接度计算遗忘分数。

• 记忆归档：将长期未用的记忆转移到冷存储（JSON文件等），需要时可恢复。

实践案例：智能学习助手

• 结合记忆检索和RAG检索，设计智能路由。

• 生成学习报告时利用情景记忆分析轨迹，语义记忆发现知识盲点。

---

第9章：上下文工程

核心思想

• 上下文是有限资源，边际收益递减 ：不加管理地塞入信息会导致上下文腐蚀（早期有用信息被后续噪音淹没）。

• 上下文工程 vs 提示工程：前者关注动态管理上下文生命周期，后者聚焦单次指令优化。

GSSC流水线

阶段	职责	失败风险
Gather	收集原始信息	遗漏关键源，模型无知
Select	筛选相关信息	选择噪音，模型偏离
Structure	结构化组织	逻辑混乱，模型误解
Compress	压缩保留精华	过度压缩丢失细节

分层上下文管理

• TerminalTool（即时访问层）：当前子任务的实时数据，生命周期极短。

• MemoryTool（会话记忆层）：跨轮次但不跨会话的中间结果。

• NoteTool（持久笔记层）：长期任务状态、计划、检查点。

渐进式披露

• 按需逐步获取信息，而非一次性全部加载。

• 优势：适合大规模、有层级结构、可分解的任务（如代码调试、文献综述）。

• 探索引导：设定预算、价值启发式、元认知评估，避免低效探索。

工具扩展

• 笔记自动整理：临时笔记积累后，自动提升重要内容为项目/任务笔记。

• 人机协作审批：危险命令需用户确认，防止智能体误操作。

---

第10章：智能体通信协议

三种协议对比

协议	设计理念	解决核心问题	适用场景
MCP	上下文共享	智能体与工具/数据源的标准化连接	数据获取、工具调用
A2A	对话式协作	不同供应商智能体之间的协同	多智能体团队协作
ANP	网络拓扑	大规模智能体网络中的发现与路由	去中心化智能体网络

MCP（Model Context Protocol）

• 三要素：Resources（数据资源）、Tools（可执行操作）、Prompts（提示模板）。

• 通信：基于JSON-RPC 2.0，默认使用stdio（本地进程），可扩展HTTP/WebSocket。

• 扩展实践：实现数据库查询、图表生成、报表工具，支持工具间协作。

A2A（Agent-to-Agent Protocol）

• 核心概念：Task（任务生命周期）、Message（双向消息）、Artifact（交付物）。

• 协作流程：任务创建 → 状态追踪 → 中间结果流式返回 → 最终结果。

• 冲突解决：优先级协商、随机退避、仲裁节点、投票机制。

ANP（Agent Network Protocol）

• 网络拓扑：星型、网状、分层、链式，根据规模动态演进。

• 关键机制：基于DID的身份认证、Agent Name System（ANS）服务发现、智能路由。

• 容错设计：心跳检测、备份切换、状态恢复。

组合应用

• 典型架构：MCP连接工具层，A2A协调智能体协作，ANP管理整个网络。

• 示例：企业智能运维平台，三种协议各司其职。

---

第11章：Agentic RL与智能体训练

核心演进

• 从LLM训练到Agentic RL：传统SFT难以优化多步长期目标，强化学习通过延迟奖励解决。

• PBRFT vs Agentic RL：前者只考虑初始提示（单步偏好比较），后者包含历史观察序列（处理部分可观测MDP）。

训练方法

方法	特点	优势
SFT（监督微调）	使用人类标注的(输入,输出)对训练	简单直接，建立基础能力
LoRA	低秩适配，只训练小参数量	资源节省，多任务适配器切换
GRPO	群组相对奖励，无需价值网络	训练稳定，内存占用少
PPO	需价值网络，剪辑目标	经典算法，适用范围广

奖励函数设计

• 关键挑战：避免奖励黑客（如重复动作刷分）。

• 精细设计：部分正确奖励、推理合理性评分、冗长惩罚。

• 多任务示例：代码生成、客服对话、游戏AI分别定制奖励权重。

工具学习与分层RL

• 工具学习：训练智能体在合适时机选择合适的工具，奖励设计需结合工具调用有效性。

• 分层RL：高层负责任务规划，低层执行具体工具调用，通过课程学习逐步增加工具数量和任务难度。

泛化与在线学习

• 泛化评估：分布外测试、扰动测试、元推理测试。

• 在线学习挑战：数据质量控制、灾难性遗忘、安全性保障。解决方案包括经验回放、弹性权重巩固、定期回滚。

实践案例：数学推理智能体

• 使用GSM8K数据集训练，结合过程奖励模型（PRM）提升推理步骤质量。

• 课程学习从简单算术逐步过渡到复杂应用题。

---

总结思维导图（文字版）

text

智能体开发全景
├── 第6章：从零实现 → 理解底层机制（ReAct、工具）
├── 第7章：框架化 → 统一抽象（万物为工具）、设计模式
├── 第8章：记忆+RAG → 四种记忆类型、遗忘归档、智能检索
├── 第9章：上下文工程 → GSSC流水线、渐进式披露、三层管理
├── 第10章：通信协议 → MCP（工具）、A2A（协作）、ANP（网络）
└── 第11章：训练优化 → Agentic RL、奖励设计、工具学习

以上为各章知识要点，建议结合实际代码和项目经验加深理解。

碎碎念：后续会更新每天学习的八股和算法 题，开始准备秋招的第22天。努力连续更新100天！以后每天就按，秋招项目【java+agent】，科研，必做项目，算法，八股，锻炼身体来总结。

总结：今天效率巨低，还是算法题及时反馈感强，不想学其他的，不行！以后要以程序员为职业，首先就是要热爱代码呀！！！！！加油加油加油

1.算法要系统过一遍【灵神】10/27【早上中午】2h

2.秋招项目，【java】开始实际看业务，2.9/10；无

【agent】还在学，决定把helloagent看一遍，11/16；2h

3.科研要跑一下，无

4.检测项目也得总结文档，2h

5.训练项目看看先选择好，3h

6.背八股，无

7.锻炼身体，无

反思：不能一心一意的学习，效率低，学习不要听东西。