flowchart TD
    A["数据结构选择"] --> B["列表 / 数组"]
    A --> C["字典 / 哈希表"]
    A --> D["集合"]
    A --> E["栈 / 队列"]
    A --> F["树"]
    A --> G["图"]

    B --> B1["按顺序存储<br/>需要按索引访问"]
    C --> C1["键值对映射<br/>需要快速查找"]
    D --> C2["去重<br/>判断是否存在"]
    E --> C3["后进先出 / 先进先出<br/>任务调度"]
    F --> C4["层级结构<br/>文件树、DOM 树"]
    G --> C5["网络关系<br/>社交图谱、路由"]

flowchart TD
    A["类型意识"] --> B["数据能做什么操作？"]
    A --> C["数据不能做什么操作？"]
    A --> D["类型转换"]
    A --> E["类型错误"]

    B --> B1["字符串可以 + 拼接<br/>数字可以 + 相加"]
    C --> C2["字符串不能直接除法<br/>列表不能直接当字典的 key"]
    D --> D3["int → str → int<br/>注意：'123' → 123 是安全的<br/>'abc' → int 会报错"]
    E --> E4["最常见的 bug 来源<br/>Python 报错：TypeError<br/>JavaScript 报错：undefined is not a function"]

flowchart TD
    A["状态管理"] --> B["当前状态"]
    A --> C["历史状态"]
    A --> D["状态变化"]
    A --> E["状态一致性"]

    B --> B1["程序运行到某一步时<br/>所有变量的值"]
    C --> B2["哪些状态变化被记录？<br/>日志 / 事务 / 撤销功能"]
    D --> B3["状态机：当前状态<br/>+ 事件 → 下一状态"]
    E --> B4["并发时：多个线程<br/>是否看到一致的数据？"]

flowchart TD
    A["顺序执行"] --> B["第一步做什么？"]
    A --> C["第二步做什么？"]
    A --> D["每一步依赖什么？"]

    B --> B1["读取文件"]
    B1 --> C1["解析内容"]
    C1 --> D1["过滤无效行"]
    D1 --> E1["分类统计"]
    E1 --> F1["输出结果"]

flowchart TD
    A["条件判断"] --> B["if"]
    A --> C["else"]
    A --> D["多分支"]
    A --> E["边界条件"]

    B --> B1["if score >= 60:<br/>    print('及格')"]
    C --> C1["else:<br/>    print('不及格')"]
    D --> D1["elif score >= 80:<br/>    print('良好')"]
    D1 --> D2["elif score >= 90:<br/>    print('优秀')"]
    E --> D3["⚠️ 最容易出错的地方：<br/>score == 60？<br/>score > 60？<br/>边界值必须测试"]

flowchart TD
    A["循环类型"] --> B["遍历"]
    A --> C["计数"]
    A --> D["累积"]
    A --> E["搜索"]
    A --> F["终止条件"]

    B --> B1["for item in items:<br/>    process(item)"]
    C --> C2["for i in range(10):<br/>    print(i)"]
    D --> D3["total = 0<br/>for x in nums:<br/>    total += x"]
    E --> E4["found = False<br/>for item in items:<br/>    if item == target:<br/>        found = True"]
    F --> F5["⚠️ 死循环：<br/>没有终止条件<br/>或终止条件永远不满足"]

flowchart TD
    A["递归四要素"] --> B["基本情况"]
    A --> C["递归情况"]
    A --> D["问题缩小"]
    A --> E["调用栈"]

    B --> B1["递归停止的条件<br/>if n == 0: return 1"]
    C --> C2["函数调用自身"]
    C1["factorial(n) = n * factorial(n-1)"]
    D --> D3["每次调用<br/>问题规模必须减小"]
    D1["n=5 → n=4 → n=3 → n=2 → n=1 → n=0"]
    E --> E4["栈溢出：<br/>递归深度太大<br/>→ 改用循环"]

flowchart TD
    A["基础算法"] --> B["排序"]
    A --> C["搜索"]
    A --> D["分治"]
    A --> E["贪心"]
    A --> F["动态规划"]

    B --> B1["快排 / 归并 / 堆排<br/>选择排序（简单但慢）"]
    C --> C2["二分搜索<br/>（有序数组 O(log n)）"]
    D --> D3["大问题分成小问题<br/>分别解决，再合并"]
    D1["归并排序：分两半排序再合并"]
    E --> E4["每步选最优<br/>不保证全局最优<br/>但速度快"]
    F --> F5["保留子问题解<br/>避免重复计算<br/>适合重叠子问题"]

flowchart TD
    A["函数设计"] --> B["输入参数"]
    A --> C["返回结果"]
    A --> D["函数职责"]
    A --> E["副作用控制"]

    B --> B1["参数要干什么？<br/>参数的类型？<br/>参数有没有默认值？"]
    C --> C2["返回什么？<br/>返回值的类型？<br/>出错时返回什么？"]
    D --> D3["一个函数只做一件事<br/>函数名就是它的职责"]
    E --> E4["修改全局变量？<br/>读写文件？<br/>打印日志？"]
    E --> E5["⚠️ 副作用越少<br/>函数越容易测试和复用"]

flowchart TD
    A["模块抽象原则"] --> B["文件组织"]
    A --> C["功能分层"]
    A --> D["内部实现"]
    A --> E["外部接口"]

    B --> B1["一个模块<br/>= 一个功能域<br/>utils.py / models.py / api.py"]
    C --> C2["从上到下：<br/>用户接口 → 业务逻辑 → 数据操作"]
    D --> D3["外部不需要知道<br/>实现细节"]
    E --> E4["暴露的方法<br/>= 模块的门面"]

flowchart TD
    A["接口设计"] --> B["使用者需要知道什么？"]
    A --> C["使用者不需要知道什么？"]
    A --> D["输入契约"]
    A --> E["输出契约"]
    A --> F["错误契约"]

    B --> B1["函数名、参数、返回值"]
    C --> C2["内部逻辑<br/>用什么数据结构<br/>如何实现"]
    D --> D3["参数类型<br/>参数范围<br/>哪些参数必填"]
    E --> E4["返回值类型<br/>成功时返回什么"]
    F --> F5["失败时抛出什么异常<br/>或返回什么错误码"]

flowchart TD
    A["系统分解方向"] --> B["拆成子问题"]
    A --> C["拆成组件"]
    A --> D["拆成流程"]
    A --> E["拆成数据层"]

    B --> B1["'自动整理文件'<br/>= 扫描文件 + 分类 + 移动 + 报告"]
    C --> C2["UI 组件 / 数据处理组件<br/>/ 外部接口组件"]
    D --> D3["主流程 / 分支流程<br/>/ 异常流程 / 恢复流程"]
    E --> E4["原始数据层<br/>处理后数据层<br/>输出数据层"]

flowchart TD
    A["正确性意识"] --> B["能运行 ≠ 正确"]
    A --> C["示例正确 ≠ 普遍正确"]
    A --> D["小数据正确 ≠ 大数据正确"]
    A --> E["当前正确 ≠ 未来可维护"]

    B --> B1["代码跑通了<br/>但结果是错的"]
    C --> C2["[1,2,3] 排序正确<br/>[3,1,2] 排序错误"]
    D --> D3["100 条数据 OK<br/>100 万条数据超时"]
    E --> E4["今天对的代码<br/>明天需求变了还能用吗？"]

flowchart TD
    A["测试用例设计"] --> B["正常用例"]
    A --> C["边界用例"]
    A --> D["异常用例"]
    A --> E["回归测试"]

    B --> B1["typical case<br/>最常见的情况"]
    C --> C2["edge case<br/>0 / 负数 / 空字符串<br/>最大 / 最小值"]
    D --> D3["error case<br/>空输入 / 格式错误<br/>权限不足"]
    E --> E4["改代码后<br/>确保之前的功能没坏"]

flowchart TD
    A["调试六步法"] --> B["复现问题"]
    A --> C["缩小范围"]
    A --> D["提出假设"]
    A --> E["验证假设"]
    A --> F["修复问题"]
    A --> G["防止复发"]

    B --> B1["能稳定复现<br/>是调试的第一步"]
    C --> C2["print 大法 / 断点<br/>定位到具体函数和行"]
    D --> D3["'可能是这个变量<br/>在这个条件下出了问题'"]
    E --> E4["改代码验证<br/>假设对 → 修复<br/>假设错 → 重新假设"]
    F --> F5["只改最小范围<br/>不要改一行引发三行新问题"]
    G --> G6["加测试用例<br/>防止同样的 bug 再来"]

flowchart TD
    A["复杂度分析"] --> B["时间复杂度"]
    A --> C["空间复杂度"]
    A --> D["数据规模"]
    A --> E["性能瓶颈"]
    A --> F["可扩展性"]

    B --> B1["O(1) / O(log n) / O(n) / O(n²)"]
    B2["列表搜索：O(n)<br/>二分搜索：O(log n)"]
    C --> C3["用了多少内存<br/>有没有优化空间"]
    D --> D4["100 条 vs 100 万条<br/>设计完全不同"]
    E --> E5["瓶颈在哪里：<br/>CPU / 内存 / IO / 网络"]
    F --> F6["数据量翻 10 倍<br/>还能正常工作吗？"]

flowchart TD
    A["可读性四要素"] --> B["命名"]
    A --> C["注释"]
    A --> D["代码结构"]
    A --> E["简洁表达"]

    B --> B1["变量名 = 它的含义<br/>函数名 = 它的行为"]
    B1 --> B2["✅ total_price<br/>❌ tp / x / data"]
    C --> C3["为什么这么做<br/>而不是做什么"]
    C1["✅ '# 处理空值：0 会影响平均分'<br/>❌ '# 循环处理'"]
    D --> D4["空行分段<br/>缩进一致<br/>相关代码放一起"]
    E --> E5["同样逻辑<br/>有没有更简洁的写法？<br/>但不要过度简化"]

flowchart TD
    A["可维护性原则"] --> B["低耦合"]
    A --> C["高内聚"]
    A --> D["单一职责"]
    A --> E["可替换"]
    A --> F["可扩展"]

    B --> B1["模块之间依赖少<br/>改一个不影响其他"]
    C --> C2["模块内部关系紧密<br/>做的事高度相关"]
    D --> D3["一个函数只干一件事<br/>一个模块只负一组责任"]
    D1["❌ 上传文件<br/>✅ 只负责上传<br/>    命名由另一个模块负责"]
    E --> E4["依赖抽象，不依赖具体实现<br/>换实现不用改调用方"]
    F --> F5["加功能容易<br/>改现有代码风险小"]

flowchart TD
    A["Git 工作流"] --> B["工作区"]
    A --> C["暂存区"]
    A --> D["本地仓库"]
    A --> E["远程仓库"]

    B --> B1["你正在改的代码"]
    C --> C2["git add 后的代码"]
    D --> D3["git commit 后的代码"]
    E --> E4["git push 后的代码<br/>其他人可见"]

flowchart TD
    A["重构时机"] --> B["消除重复"]
    A --> C["提取函数"]
    A --> D["改善命名"]
    A --> E["简化条件"]
    A --> F["拆分模块"]

    B --> B1["同一段代码<br/>出现 3 次以上 → 提取"]
    C --> C2["超过 20 行<br/>或需要单独说明的逻辑 → 提取"]
    D --> D3["x / tmp / data<br/>→ 含义清晰的名字"]
    E --> E4["多层嵌套 if<br/>→ 提前 return<br/>→ 卫语句"]
    F --> F5["超过 300 行的文件<br/>→ 拆成多个文件"]

flowchart TD
    A["程序外部依赖"] --> B["用户"]
    A --> C["数据"]
    A --> D["文件"]
    A --> E["网络"]
    A --> F["数据库"]
    A --> G["外部服务"]

    B --> B1["用户输入<br/>用户期望"]
    C --> C2["输入数据格式<br/>数据是否干净"]
    D --> D3["文件是否存在<br/>读写权限"]
    E --> E4["网络是否通<br/>API 是否可达"]
    F --> F5["连接池<br/>事务一致性"]
    G --> G6["第三方服务<br/>是否限流/超时"]

flowchart TD
    A["反馈机制"] --> B["日志"]
    A --> C["错误信息"]
    A --> D["监控"]
    A --> E["用户反馈"]
    A --> F["测试反馈"]

    B --> B1["INFO / WARNING / ERROR<br/>关键操作记录"]
    C --> C2["给用户的错误信息<br/>要说明什么出错了<br/>不要暴露内部细节"]
    D --> D3["CPU / 内存 / 请求量<br/>异常告警"]
    E --> E4["用户说好用才是真的好用"]
    F --> F5["自动化测试<br/>每次提交跑一遍"]

flowchart TD
    A["风险意识"] --> B["数据丢失"]
    A --> C["权限错误"]
    A --> D["安全漏洞"]
    A --> E["性能崩溃"]
    A --> F["依赖失效"]

    B --> B1["定期备份<br/>写操作前先备份"]
    C --> C2["最小权限原则<br/>不要给 root 权限"]
    D --> D3["SQL 注入 / XSS<br/>敏感数据加密"]
    E --> E4["超时控制<br/>资源限制<br/>熔断机制"]
    F --> F5["指定版本号<br/>不要用 latest<br/>依赖检查"]

flowchart TD
    A["最小学习闭环"] --> B["1. 选一个真实小问题"]
    A --> C["2. 写清楚输入和输出"]
    A --> D["3. 设计数据结构"]
    A --> E["4. 拆成函数"]
    A --> F["5. 写最小可运行版本"]
    A --> G["6. 添加测试用例"]
    A --> H["7. 调试并记录错误"]
    A --> I["8. 用 Git 管理版本"]
    A --> J["9. 写 README"]
    A --> K["10. 复盘设计取舍"]

    B --> B1["'整理桌面下载文件夹'<br/>'批量重命名照片'<br/>'生成周报摘要'"]
    C --> C2["输入：文件夹路径<br/>输出：分类后的文件列表"]
    D --> D3["文件路径列表<br/>按类型分类的字典"]
    E --> E4["scan() / classify() / move() / report()"]
    F --> F5["先跑通主流程<br/>不考虑边界情况"]
    G --> G6["正常用例 + 边界用例"]
    H --> H7["记下来：<br/>踩了哪些坑？"]
    I --> I8["每一步 commit<br/>commit message 写清楚"]
    J --> J9["这个脚本是干什么的<br/>怎么用"]
    K --> K10["这次设计<br/>哪里不合理？<br/>下次怎么改？"]

flowchart TD
    A["常见误区"] --> B["❌ 把编程等同于语法"]
    A --> C["❌ 把会复制代码等同于会编程"]
    A --> D["❌ 把能运行等同于正确"]
    A --> E["❌ 把刷题等同于工程能力"]
    A --> F["❌ 把框架等同于基本功"]
    A --> G["❌ 把 AI 生成等同于理解"]
    A --> H["❌ 把代码行数等同于能力"]

    B --> B1["语法只是工具<br/>思维才是核心"]
    C --> C2["复制粘贴解决不了<br/>第一次遇到的新问题"]
    D --> D3["跑通 ≠ 正确<br/>需要测试用例证明"]
    E --> E4["面试造火箭<br/>入职拧螺丝<br/>工程是另一套能力"]
    F --> F5["框架是别人搭好的结构<br/>不知道底层原理<br/>一出问题就抓瞎"]
    G --> G6["AI 能生成代码<br/>但 AI 不能帮你 debug<br/>你不理解代码<br/>就无法维护和改进"]
    H --> H7["简洁的代码<br/>往往比冗长的代码<br/>更难写、更值钱"]