前提

1. 根据各个版本的模型特点，经常换搭配，参考请留意时间和版本

2. Grok4.6 和 GPT 不降智为前提

跨端大任务

• 讨论+设计： Opus 5 High / Max （主要是避免 Sol 的雷霆大思考，Opus 目前还是没那么多废话）

• 可行性分析：GPT5.6 Sol High / 看雷达图95以上 （主要是利用 Sol 的雷霆大思考，提前发现计划中可能的问题，又不至于让它太发散）

• 执行：Opus 5 监督 Grok 4.6 （DSF 正式版也行）执行 （体感上就像是着急下班的高级程序员，干活雷厉风行，不过度思考）

• 验收：GPT5.6 Sol 或 GLM 5.3（依然是利用雷霆大思考去发现问题）

• 复工：Opus 5 High / Max 充新做计划 或 监督 Grok 4.6 补充执行

目标明确的小任务

定义很简单，知道是哪的问题，也知道错误原因，直接告诉 Agent 问题和怎么改，基本上指哪打哪。

这种小任务就不用计划和可行性分析了，直接执行即可。

• 执行：Grok4.6 （DSF 正式版也行） 直接执行，

• 验收：基本上不用验收，因为直接能看到改好了，如果验收可以走 GLM 5.3 或 Kimi-K3

如果你好奇如何让Opus5 监督 Grok4.6 干活

我使用的是 Paseo，可以利用 Paseo 的 Skill，从 Claude 中调起一个 Grok 的子 Agent，然后让 Opus5 控制这个子 Agent 即可。

一句话总结，速度快，价格低，小问题指哪打哪。

价格

梁圣之所以是梁圣，还是极致的性价比。但是绝对不会是白菜价，今天也是发出了涨价提示。

但是 DeepSeek V4 Flash 依然很能打，最起码不用再去印度薅 Grok 4.5 的羊毛了，能力跟速度都不相上下。

当然不能说白菜价，我每天估计会用到 3 块钱左右，按照一月20天算，差不多60块钱。

但是如果跟 Grok4.5 的 Coder 能掰手腕，那门槛还是要降低不少的。

能力

在 Pro 没发布前，我不敢说什么，但用 DeepSeek V4 Flash，我个人还是建议走 Grok 的思路，短平快，指哪打哪。

不错的 websearch 能力，不错的速度，长超的上下文（1 M），都是优点。

但是我绝对不会在跨多端系统、复杂上下文、需要深度理解代码架构和意图的事情上让它来当主力。

它可以是一个不错的执行者，小问题的快速修复者，甚至做可行性分析，但绝对不是主力。

其实我有点期待 Pro 的表现（AI 平权）。

推荐场景

1. 作为详细计划的执行者，速度快，能力够，价格实惠。（Luna Max 太慢了）

2. 作为可行性分析者，能力够，速度快，提出不一样观点的分析。

3. 作为明确的、小范围问题的直接解决者。

4. 代码解释，指定一个模块或者工作区的待提交内容，让它给你讲明白

备注

我主要还是以个人 Coding 为基础有上述看法，必然是偏见的。

DeepSeek V4 Flash 目前还缺少多模态，但是在文学创作、世界知识上肯定还有其它不错的表现。

本文仅探讨 Coding。

先抛结论

适合：用于 明确的小任务 和 复杂任务执行 上

不适合：用于整体代码分析和模糊目标上

Grok 4.5的优点及能力

1. 体感上，比 GPT 5.4 要强，但是赶不上5.5 High。

2. 速度上可以说是一骑绝尘。

3. 支持多模态，能看图！

了解了能力边界和优势，我们就可以开始利用能力去快速达成我们的目的。

比 5.4 要强的能力

这表示着 Grok 4.5 有着不错的能力，一些目标明确，轻量级的任务，只要描述/讨论清楚，即可交给他直接执行，不用再去设计计划和可行性分析，也能保证不错的执行结果。

对于我：我经常会把一明确问题和文件的事情跟他直接聊，都明确之后，我会直接在 Grok 里执行。

速度快

5.4的能力加上超快的速度，能在执行小任务的时候更快落实，表现在

1. 对于已经有计划的任务，快速落实

2. 对于代码解释等简单任务的快速回答

3. 对顺手修复 的快速落地

对于我：我会在解释代码的时候经常用，因为 GLM5.2和 GPT5.6都太慢了，甚至影响/打断思考流；其次我会将 Sol 设计的计划交给 Grok 4.5 执行，然后让 Opus 4.8 去验收；当然还有一些明确问题的顺手修复。

多模态

这是 GLM 5.2 缺失的，虽然可以用插件/Skill 完善，但是 Grok 自带的多模态更加方便。

当有些需求难以用文字描述的时候，一张图片的参考，是非常有用的，特别是对于前端页面的设计。

对于我：主要用在前端页面的模仿上，我有时可能说不准确，一张图片作为参照，比什么语言都更好的解决问题。

总结

Grok 4.5 真的是以不错的质量，超高的速度在 LLM 的发展史上写下了一笔。

了解 Grok 的能力边界和优势，与其它模型配合，才能更好的帮助我们完成任务。

昨天夜里 kimi-k3 也发布了，期待。

我先抛我的场景下 个人主观感受

在 讨论 阶段：我可能更偏向用 Terra 极高

在 计划 阶段： 简单用 terra 极高，复杂任务用 Sol 高

在 执行 阶段：我更偏向用 Luna 极高

在 验收 阶段：我更偏向于 Terra 极高

我个人 Plus 真实用的话，对比 5.5 跟 5.6

Sol 高 > 5.5 xhigh

Terra 极高 ≈ 5.5 高

Luna 极高 > 5.4 xhigh

跟 advisor 讨论模糊概念到清晰：

• 5.5极高：7～8

• sol 高：8

• 额度感觉差不多，但智商高了一个层级，期间 sol 还压缩了一次上下文，sol 这次是我为数不多一路点头同意的

• terra 极高：7

• terra 的讨论不如 sol 高来的深刻，就是..不那么「知心」，我估计之后讨论我会选 sol 高，额度用的都差不多

根据上面的讨论上下文，设计计划：

• 5.5极高：12

• 5.5高：7～8

• sol高：22 😭

• sol 给的计划极为详细，感觉给豆包做都能做对那种，大约是之前1.5～1.7倍的长度

• terra 极高：7

• terra 极高的感觉跟5.5的高差不多，计划内容普通，长度正常

新窗口，执行上面的计划：

• 5.4极高：不超过7，一般在5以下

• luna 极高：4

• 执行的速度要慢一些或者差不多，但是记住了我让他记录的技术债，也追加到对应的 doc 里了，以前很少能记住，执行完的自己验收也比之前要严谨的多。

• terra 极高：7

• terra 执行速度一般(Gork4.5超级快)，但是执行结果都是没问题的

新窗口，根据上面的计划和执行报告验收（含数据库MPC检查）：

• 5.5高：差不多5～8，不超过12

• sol高：用了17

• Terra 极高：用了 5

• sol确实是比5.5多测试了几项，测试也更深入了，但没想到超额这么多，但是 MCP 查了不少作为辅助确认

尾巴

一上午跑了两轮任务测试，几乎花完了所有的 5H 限制

不知道是不是第一天的关系，5.6 明显更「知心」，有点肥波5的那个意思了

也可能 5.5 最近流口水太多了。

Codex / 未开启 x1.5

纯个人主观体感，仅供参考。

先抛结论

AI 黑盒不只会让代码失控，而且会导致越来越依赖 AI

代码失控

AI 时代来的轰轰烈烈，传统的程序员难免受到冲击。网络上一些「不用学编程，就能写程序」的口号也层出不穷，AI 确实在某些层面能达到真正的c，真的能用，能达到预期。但是对这些「产物」的掌控力呢？

AI，省力，但不省功

这些 Vibe Coding 的产物，没有在项目初期就规划软件工程和模式，甚至我还见过在一个 py 文件里写8000行代码的例子。这些「产物」能用吗？当然能用，从一个程序员角度，你能解释其一二吗？不能，因为我只操作 AI，AI 去操作了8000行的 py，解释不了。

AI 的黑盒产物，让代码越来越失控，而这种失控，就会导致更严重的问题。

更加依赖AI

有人说，代码没有失控啊，我控制AI，AI控制代码而已，最终还是我在主导的。如果这么说也没错，但是对 AI 的依赖就更强了。我不会提那种末日危机的论调，什么之后没有电、没有网怎么办之类的，AI 必然会成为基础设施的一层，去大大提高人类的生产力。

AI 的能力上去了，而只能依赖 AI 的我们，能下下降了

是我们不想写代码吗？不想「古法编程」了吗？不，而是我们面对代码开无从下手 ，为什么？因为 AI 的写作习惯、编程能力都远超我们，他们的设计思路更我们也不相同。我们改不动了！

越省力，越费功

最后就会导致一件事情，越让 AI 写，越费功，费的是我们自己的「武功」。我先抛出这个死循环

AI 越来越像黑盒 -> 我们越来越无从下手 -> 只能越来越依赖 AI -> AI 越来越像黑盒

这就导致了几个问题

1. AI 的「产物」越来越不可控

2. 我们的能力，越来越差

3. 「项目」风险越来越高

倡导

如果你是一个程序员，我还是倡导大家，先设计符合自己水平的设计规范，然后让 AI 严格遵守规范去开发。

达到 AI 写出的代码，你随时可以接手，你随时可控。

下一篇，我将详细说说理想中的 AI 参与的编程该是什么图景。

AI 编程杂谈开篇

开启一个新的系列文章，分享我在使用 AI 时的一些主观感受，主要聚焦在编程方面。

这是开篇，我不想写太长，只想一次一个主题地分享我的使用体会，也算是跟大家交流经验。毕竟 AI 从 2025 年开始就发展飞快，无论是 Seedance 的视频生成、Image 2 的图片生成，还是 DeepSeek V4、GLM 5.2、GPT-5.5 和 Fable 5 的出现，都大大提升了人们的效率。

说不准这杂谈，在几年后就变成了考古文物——古法 AI 记录。

AI 的模仿能力

我想分享一个核心观点：AI 的模仿能力。

优先利用 AI 的模仿能力，再让其进行创造。

为什么我会这么说？因为我最近发现，如果你直接抛出一个需求给 AI，从 AI 的视角来看，可能有无数的解法——有高级/低级之分，有从架构考虑的，也有从快速迭代考虑的。它该以哪个为基准？如果用户没有明确的指示，AI 就会自己提炼和体会。小项目它可能不会用复杂的解法，但这样就难以控制，逐渐地，代码会变成黑盒。

利用模仿能力

我先抛出观点：如果 AI 的能力足够强，那它就能完全理解你写的代码是什么水平、项目是什么层次、你的写作特点和习惯是什么。

所以，我们就要借此利用它的模仿能力，即——

根据现有项目，去总结习惯。

也就是先提供自己的真实项目，让 AI 自己去理解和抽象出你的代码习惯、写作特点，然后让 AI 以此为基准，进行后续开发。

为什么要利用模仿能力

理由很简单：避免黑盒。如果你还想让代码有长久的生命力，而不是一堆屎山，那就一定要避免黑盒。

这里的黑盒不一定是所谓的复杂，它包括——

你看不懂的思路、你不常用的语法、你不熟悉的领域。

这些其实都是黑盒，它们会让你失去对代码的掌控，让代码失去生命力。

总结

2026 年，我发现 AI 的能力已经很强，对代码的理解非常到位。所以我提出：

1. 要利用这种理解能力

2. 抽象出自己的设计风格

3. 在自己风格的基础上让 AI 进行开发

4. 从而避免黑盒的出现。

最近睡眠

最近睡得时间很短（6小时），但是深度睡眠非常足，每天都是60～90分钟，快速眼动30～50分钟

深度睡眠

深度睡眠充足之后的感觉是

精力十足、注意力集中

特别是解决复杂的代码问题，能更多的专注在多个上下文思维链里面

快速动眼

快速动眼睡眠充足之后

对前一天的复杂逻辑的理解突然深入了、开窍了

AI分析

其实 AI 也给了我差不多的解释

思考

其实最近睡得总时长不是很够，当然我也知道8小时睡眠不是针对所有人，但是针对我的平均时长来说，不是很足，不过我的精神状态依旧很好，原因归结于深度睡眠和快速动眼睡眠的高质量。

下一步我可能会进一步总结经验，看看该如何保持高质量的睡眠，而不是高时长的睡眠。

与大家分享。

之前设计的“太好了”...AI 写了一堆复杂泛型，我看起来头都疼。

又不是服务端，所以前端只留了一些基础类型，不想搞得太复杂。

我个人还是想对代码保留一些自主权，不能搞到最后，自己不写代码，也看不懂代码...

我还是偏向于设计一些设计规范，然后让 AI 在规范内编码。

最起码我自己还能找到某一部分代码在哪，要不然纯黑盒了...

我经常跟 AI 聊完之后，就 水一下论坛 或者 切换到 IDE 去 Review。

Pet 能一直置顶挺不错的，我就偶尔扫一眼状态。

当 Pet 那显示绿色对号了，我就点 Pet 返回 CodexApp 窗口。

但是输入框的光标（闪动竖线）不显示，有时候无法输入文字，只能重启。

最近发现在 Codex 界面，再点一下 Pet，就能恢复正常， 光标能正常显示。

就是水论坛切换窗口时，发现的小问题与临时解决方案，供大家分享。

以前的理解

以前对感恩的理解还比较肤浅，就是你对我好，我也对你好。是对别人给予的帮助的一种回应，再说说直白一点，就是表达自己的感谢之情，心里少一些亏欠（因为别人帮助了自己嘛）。也可以说是感激之情。

一次感悟

最近突悟出一些东西，是在我开车等红灯的时候。家附近的一家商场，出了停车场就是红绿灯，经常会遇到红灯的情况，比较烦躁。感觉10次得有8次都是红灯，每次等红灯的时候脑子只会蹦出一个句怎么总是红灯🔴。

突然有一次，我开车出来，下着小雨，我又着急回家。发现是绿灯🟢，开心之情难以言表。

回去的路上我突然有所感悟，路口还是那个路口，红绿灯的规律也没有变化，为什么今天难得的开心？

是单纯的因为着急回去，结果是绿灯而开心吗？好像并单纯是这样。

我发现： 每次在那个路口，我都在强化自己的默认行为网络，加深对这个红绿灯的讨厌，不停的在心里说一到这里就红灯 ！！！

我想打破这个默认行为，所以在这一次🌧️着急回家却遇到绿灯时，我告诉自己这次真幸运 ，加深遇到绿灯时的记忆和印象。

之后

那个路口的红灯🔴还是很多，但是我的心态不一样了，从之前怎么又是红灯？ 到现在之前好几次是绿灯 甚至我现在到这个路口已经什么都不想了，就是一个普通的路口而已。

我认为唯一的变化是我主动打破了那个默认行为，不再重复的加深印象，反而在每次绿灯的时候，加深印象对绿灯表示感恩。

感恩

我突然意识到，这次不单单是打破一个负反馈的认知，而是发现了感恩这件事，你越去感恩一些平凡的小事，你就会打破之前糟糕的认识。世界还是这个世界，人还是那些人，但是主动的去感恩，重复加深对美好的印象，心情或者说心境，真的变了。

感恩一切遇到的好事，不管是大事还是小情。

与大家分享。

情况

根据官方教程，使用离线安装脚本进行安装。

安装后实际上在 /opt/halo 下运行的一个 Docker 的实例，实际是从 Nginx 反向代理出去的。

如果你和我的情况，那么就可以往后看（我使用的是 linux 系统）

拉取最新的 halo 应用

docker pull registry.fit2cloud.com/halo/halo-pro:2.24.2

这里的版本号是从下面的网址获取的，包括仓库地址

https://releases.halo.run/releases/

如图所示，就是最新的镜像地址

拉取成功后如上图所示

修改本地docker-compose.yaml

进入/opt/halo 目录，如果你是别的目录就进入你自定义的目录

大概率会看到一个Data 目录，一个install.log 还有一个docker-compose.yaml

我们主要改这个docker-compose.yaml

首先把我们docker-compose.yaml的第一个 image 改成上面那个 Docker 地址，即你 pull 的地址

services:
  halo:
    image: registry.fit2cloud.com/halo/halo-pro:${HALO_VERSION}

改成下面的，注意跟上面拉取的仓库路径是否相同

services:
  halo:
    image: registry.fit2cloud.com/halo/halo-pro:2.24.2

上面的 2.24.2 就是版本号

${HALO_VERSION} 不用管，这个对应的是隐藏文件.env 的版本号，有能力的直接改 env 文件，切记要检查你的registry 仓库是否一样。

停止并更新

停止当前运行的 Halo 实例

 先 cd 切换到 docker-compose.yaml 所在的目录

 先查看当前运行的实例列表
 docker ps
 然后记住 CONTAINER ID 

 然后停止即可
 docker stop 753cf24e3e12

 然后更新并开启容器
 docker-compose up -d

正常会看到下图所示，我是 PG 数据库，所以显示 pg，如果你是 mysql，则显示 mysql，启动后直接刷新博客即可

检查

进入 console/overview 查看概览，即可看到已经升级到最新的 2.24.2 系统了

难点

1. 要先拉取官方提供的 Halo 的 docker image

2. 然后修改 docker-compose.yaml 文件中的 image 与拉取的相同

3. 进入 halo 目录，先停止，再docker-compose up -d即可

最近用 AI 来改造代码和框架，我在 Review 的时候，发现自己屎山变高级了，或者说屎山上多了一块扎眼的金子。

本来是非常简单、没有太多复用、只有一两个页面在用的逻辑，现在不光要写Schema 配置、设计字典、抽离业务函数、还要有一个函数做校验、解析字典并吐出最终规则。

在 Review 的时候看的云里雾里，写的真好，但好像不适合我，把清爽的屎山镀上了金，即不清爽了但却还是屎山。

我在 Review 的时候就在想，是变高级了？还是更难以理解了。看来在初期让 AI 充分的理解项目风格、包括自己的代码习惯都需要严格的写到 MD 里面去，否则真的会跑偏。

从上次写博客到现在好久了，Hexo 博客系统好像也不这么流行了，其实主要是没有写作后台，2026年在 AI 的帮助下，从新迁移这套主题到更流行的 Halo 博客系统，希望能够继续博客的写作。

不过从今年起，这个博客可能不只有精雕细琢的大作，也有一些碎碎念、吐槽以及个人观点。先记录下来，比什么都重要。18年到26年，转瞬即逝...

岁月不饶人，我也没过饶岁月。2026 加油 💪 ！

引入

我们知道如何构建一个图的数据结构，那么现在，我们看看如何根据一棵图的图形，创建一张图到内存中去。

创建数据结构

#define MAX_VEX_NUM 50  //最大的容量暂定为50
typedef enum {DG, UDG} GraphType;  //选择有向图还是无向图
typedef struct {
    char vexs[MAX_VEX_NUM];  //一维数组存储顶点
    int arcs[MAX_VEX_NUM][MAX_VEX_NUM];   //二维数组（邻接矩阵）存储边
    int vexnum, arcnum;  //记录顶点的数量和边的数量，等下用作循环判断条件
    GraphType type;  //记录图得类型
} MGraph;

数据结构中

• 记录顶点的数量和边的数量，等下用作循环判断条件
• 记录图得类型，等下用于写入矩阵

获取数据

void create_MG(MGraph *MG)
{
    
    int type;  //存储图得类型
    printf("请输入图的类型，有向图（输入0）无向图（输入1） :");
    scanf("%d", &type);
    //如果是0，那就是有向图，如果是1那就是无向图
    if (type == 0)
        MG->type = DG;
    else if (type == 1)
        MG->type = UDG;
    else
    {
        printf("请输入正确的图类型，有向图（输入0）无向图（输入1）");
        return;
    }
    
    //获取数值
    printf("请输入顶点个数:");
    scanf("%d", &MG->vexnum);  //数值赋值给 MG 的 vexnum
    printf("请输入边个数：");
    scanf("%d", &MG->arcnum);
    getchar();  //接收最后那个回车
    
    int i;
    int v1, v2;
    //有多少个顶点，就输入多少次
    for (i = 1; i <= MG->vexnum; i++)
    {
        printf("请输入第%d个顶点的值:", i);
        scanf("%c", &MG->vexs[i]);
        getchar();
    }
    //以上就完成了所有信息的获取

我们一部分一部分的讲

• 先输入1或0判断图类型，然后存到结构体中
• 然后输入顶点数和边树，方便下面判断循环次数
• 接着根据顶点数，接收每个顶点得值
• 所有数据获取完毕

初始化矩阵

//初始化邻接矩阵，双层循环将二维数组都填充为0
   for (i = 1; i <= MG->vexnum; i++)
   {
       for (j = 1; j <= MG->vexnum; j++)
       {
           MG->arcs[i][j] = 0;
       }
   }

这里我们先把矩阵创建出来

• 判断条件就是顶点的个数，有多少顶点创建多大的矩阵
• 矩阵中默认的值为0

在矩阵中定位

//定位
// 输入矩阵指针和顶点得值，判断在一维数组中这是第几号，并返回
int getIndexOfVexs(char vex, MGraph *MG)
{
    int i;
    //有多少结点循环多少次
    for (i = 1; i <= MG->vexnum; i++)
    {
    //如果值等于输入的值，那么就把在一维数组中的位置返回
        if (MG->vexs[i] == vex)
        {
            return i;
        }
    }
    return 0;
}

这个定位的函数，主要是

• 将用户输入的值，在一维数组中找到它的位置
• 然后将这个位置返回
• 我们就能通过这个位置在矩阵中定位到它了

处理边的信息

//输入边的信息，建立邻接矩阵，有多少边执行多少次
   char c1, c2;
   int j, k;
   for (k = 1; k <= MG->arcnum; k++) {
       printf("请输入第%d个边: ", k);
       scanf("%c %c", &c1, &c2);
       //利用上面的定位函数，找到输入的顶点在一维数组中的位置
       v1 = getIndexOfVexs(c1, MG);
       v2 = getIndexOfVexs(c2, MG);
       
       if (MG->type == 1)  //如果是y无向图，则对称矩阵，把对称位置上的值同时赋值为1
           MG->arcs[v1][v2] = MG->arcs[v2][v1] = 1;
       else  //如果是有向图，则只在指定位置赋值。
           MG->arcs[v1][v2] = 1;
       getchar();
   }

有多少个顶点就循环多少次

• 接收到构成边的两个顶点
• 然后利用上面的定位函数，返回在一维数组中的位置
• 接着判断图得类型
• 无向图，那么矩阵对称，则在对称位置同时赋值 1
• 有向图，矩阵不对称，所以只在对应位置赋值 1

总代码

#include <stdio.h>
#include <stdlib.h>
#define MAX 50

typedef enum{DG,UDG} GraphType;

typedef struct {
    char vex[MAX];  //定义一维数组存储顶点
    int arcs[MAX][MAX];  //定义二维数组存储边
    int vexnum,arcnum;  //存储顶点和边的数量
    GraphType type;  //存储图的类型
}Graph;

int position(char c , Graph *G){
    int i;
    for(i=1;i<=G->vexnum;i++){
        if(G->vex[i]==c){
            return i;
        }
    }
    return 0;
}

void Create(Graph * G){
    //获取图的类型
    int type;
    printf("请输入图的类型，有向图输入1，无向图输入0:");
    scanf("%d",&type);
    if(type==1){
        G->type=DG;
    }else if(type==0){
        G->type=UDG;
    }else{
        printf("输入的类型不正确！\n");
        return;
    }
    //获取图得顶点数和边数
    printf("图有几个顶点:");
    scanf("%d",&G->vexnum);
    printf("图有几条边:");
    scanf("%d",&G->arcnum);
    getchar();
    //获得每个顶点得值
    
    for(int k=1;k<=G->vexnum;k++){
        printf("请输入第%d个结点的值：",k);
        scanf("%s",&G->vex[k]);
        getchar();
    }
    //值全部获得完毕
    
    //矩阵初始化
    int i,j;
    for (i = 1; i <= G->vexnum; i++)
    {
        for (j = 1; j <= G->vexnum; j++)
        {
            G->arcs[i][j] = 0;
        }
    }
    //有多少个结点循环多少次
    char V1,V2;
    int V1p,V2p;
    for(int l=1;l<=G->arcnum;l++){
        printf("请输第%d个边的信息：",l);
        scanf("%c %c",&V1,&V2);
        V1p=position(V1,G);
        V2p=position(V2,G);
        
        if(G->type==UDG){
            G->arcs[V1p][V2p]=G->arcs[V2p][V1p]=1;
        }else{
            G->arcs[V1p][V2p]=1;
        }
        getchar();
    }
}

void print_MG(Graph MG){
    printf("-------------------------------\n");
    int i, j;
    if(MG.type == DG)
    {
        printf("图类型 : 有向图\n");
    }
    else
    {
        printf("图类型：无向图\n");
    }
    printf("图中的顶点有: %d 个\n",MG.vexnum);
    printf("图中的边/弧有: %d 个\n",MG.arcnum);
    
    printf("顶点的集合:");
    for (i = 1; i <= MG.vexnum; i++){
        printf("%c ", MG.vex[i]);
    }
    printf("\n");
    printf("邻接矩阵:\n");
    
    for (i = 1; i <= MG.vexnum; i++)
    {
        printf("%c ", MG.vex[i]);
        j = 1;
        for (; j < MG.vexnum; j++)
        {
            printf("%d ", MG.arcs[i][j]);
        }
        printf("%d ", MG.arcs[i][j]);
        printf("\n");
    }
}
int main()
{
    Graph MG;
    Create(&MG);
    print_MG(MG);
    return 0;
}

我们将上面的图输入程序，我们用 a、b、c、d 代替v1、v2、v3、v4

运行结果
请输入图的类型，有向图输入1，无向图输入0:0
图有几个顶点:4
图有几条边:5
请输入第1个结点的值：a
请输入第2个结点的值：b
请输入第3个结点的值：c
请输入第4个结点的值：d
请输第1个边的信息：a b
请输第2个边的信息：b c
请输第3个边的信息：c d
请输第4个边的信息：d a

请输第5个边的信息：a c

图类型：无向图
图中的顶点有: 4 个
图中的边/弧有: 5 个
顶点的集合:a b c d
邻接矩阵:
a 0 1 1 1
b 1 0 1 0
c 1 1 0 1
d 1 0 1 0

运行结果同矩阵相同，成功！

尾巴

这是我的个人学习笔记，主要是应付考研复习使用，充斥着一些吐槽和个人观点，并不严谨，欢迎大家参考、指正。

引入

学了那么多图的知识，是时候动手设计一下图的存储结构了，图跟线性表、树有那么大得差别，所以图的数据结构要复杂很多。

思考

我们先回忆一下线性表和树得存储结构

• **线性表：**一对一的关系，用数组和链表就能很好的表示。
• **树：**一对多得关系，用数组和链表得特性结合在一起就可以很好的表示。

那么图呢？

• 图上的任意一个顶点都可以是第一个顶点，谁开始都行。
• 任意一个顶点的邻接点也不存在次序关系，多对多，大家都一样。

我们观察下面的四张图

这四张图形态各异，但是

• 各个结点的邻接点都相同
• 边也都相同
• 所以位置虽然不一样，但其实都是一张图。

那么该如何将图在内存中表示呢？

• 既然任意两个顶点都可能存在联系
• 我们不能线性的表达数据元素之间得关系
• 因为内存的物理位置也是线性的，而图的元素关系是平面的。
• 既然线性关系不行，那用多重链表呢？可以！
• 但会造成巨大的资源浪费，各个顶点得度数如果相差很大，就会造成很大的浪费。

解决

想明白上面得问题，我们就来回答这个问题

• 图是由顶点和边两部分组成的，合在一起表示困难，我们分开表示就好了
• **顶点：**因为不分大小、主次，用一个简单的一维数组来存储就好
• **边、弧：**其实就是顶点和顶点之间得关系，一个二维数组来存储就好
• 所以，我们使用邻接矩阵方案，撒花！

无向图的邻接矩阵

**图的邻接矩阵（Adjacency Matrix）：**存储方式是用两个数组来表示图。

• 一个一维数组存储图中得顶点信息
• 一个二维数组（邻接矩阵）存储图中边、弧的信息

我们试着来存放上面这个无向图，首先设计一个一维数组 vexs 存放顶点信息

接着设计一个邻接矩阵（二维数组）arcs，存放边和边得信息

因为是无向图，所以

• 无论是先行再列看（V0，V1）还是 先列再行看（V1，V0）都可以
• 邻接矩阵存储得是边、弧，如果存在就写1，反之则写0
• 这个邻接矩阵也是一个对称矩阵，因为这是一个无向图。

无向图邻接矩阵的存储结构

我们设计这个存储结构时

• 设计两个数组
• 顶点数组vertex[4]
• 边数组 arc[4][4] 为对称矩阵
• 边数组中，0表示顶点间不存在边，1表示顶点间存在边

所谓对称矩阵，就是

• N 阶矩阵的元满足
• a[i][j]=a[j]i
• 也就是从矩阵的左上角到右下角为轴
• 右上角得元与左下角相对应得元全都是相等的

有了这个数据结构，我们就可以很轻松的知道

• 任意两个顶点之间是否存在边，0就是没边，1就是有边
• 某个顶点的度，就是顶点 Vi 在邻接矩阵中第 i 行或 i 列的元素的和。
• 还记得无向图顶点的度嘛？就是该顶点邻接的边的个数
• 就是这一列或这一行，有多少个 1，加起来就是这个 Vi 的度
• 最后一个就是求 Vi 顶点的所有邻接点
• 就是将第 i 行元素扫描一遍，只要 arc[ i ][ j ]为1就是邻接点

V1 的度是2，因为无论行、列，为1的元素加起来，都是2
V1 的邻接点是 V0、V2，因为 V1 行只有 V0、V2 的元素为1

我们看看图对不对，没有问题！

有向图的邻接矩阵

我们在无向图中发现，邻接矩阵竟然是对称的，原因也很简单

• 因为无论是顶点 A 到顶点 B 还是顶点 B 到顶点 A 都是相同的
• 那么在有向图中，给顶点规定了方向之后，会不会好一些呢？

有向图最重要的一点就是区分方向，我们按照上面的思路，首先设计一个一维数组 vexs 存放顶点信息

接着设计一个邻接矩阵（二维数组）arcs，存放边和边得信息

因为我们要注意方向

• 所以行为弧为、列为弧头
• 如果不规定，那么 A->B 和 B->A 就一样了
• 这就不是有向图了

有向图邻接矩阵的存储结构

我们设计这个存储结构时

• 设计两个数组
• 顶点数组vertex[4]
• 边数组 arc[4][4] ，有向图矩阵并不对称
• 边数组中，0表示顶点间不存在边，1表示顶点间存在边

有向图有入度和出度的概念，所以

• 顶点 V1 的入度为1，正好是第 V1列的各数之和
• 顶点 V1 的出度为2，正好是第 V2行的各数之和
• 我们看看下表

V1 的入度是1，出度是2

• V1列所有元素的和为1
• V1行所有元素的和为2
• 我们看下图验证一下

没有问题，我们接下来实际设计一下数据结构。

邻接矩阵（网）

我们在上一节，说到了网这个概念，实际上就是每条边上带有权的图，就是网。

• 网跟上面的思路一样，使用两个数组搞定
• 在数组中的元素就不在是0和1了
• 因为每条边有权，所以我们就将每条边的权值赋值到二维数组中

网最重要的一点就是看好权值，我们按照上面的思路，首先设计一个一维数组 vexs 存放顶点信息

接着设计一个邻接矩阵（二维数组）arcs，存放边和边得信息

这里有三种情况

• 如果有弧，则将权值写入
• 如果指向自己，那就写$\infty$
• 如果没有弧，那就写入$\infty$
• $\infty$ 表示计算机允许的，一个大于所有权值的值。

代码实现

typedef enum { DG, UDG } GraphType; //声明图的类型，有向还是无向
typedef struct {
    char vexs[MAX_VEX_NUM];  //一维数组，用于存放顶点
    int arcs[MAX_VEX_NUM][MAX_VEX_NUM];  //二维邻接矩阵，存放边、弧
    int vexnum, arcnum;  //存放顶点数量和边、弧的数量
    GraphType type;  //从有向和无向中选择一个
} MGraph;

好了，理解了上述概念，我们下节课来讲，如何创建一个图。

尾巴

这是我的个人学习笔记，主要是应付考研复习使用，充斥着一些吐槽和个人观点，并不严谨，欢迎大家参考、指正。

引入

前面我们基本讲了什么是图结构，以及顶点、边和弧之间不同状态的特殊图结构，我们今天继续，看看这些顶点、边和弧之间的关系。

关系

我们来讲讲顶点和边的一些关系

顶点和边的关系

我们说，如果存在一个无向图，G（V，E）

• 图中的两个顶点构成的边$(V1 , V2)\in E$属于 E 的集合
• 那么我们就说 V1 和 V2 互为邻接点（Adjacent）
• 也就说明 V1 和 V2 相邻接，不是连接！。
• 对于边(V1 , V2)来说
• 边(V1 , V2)依附（Incident）于 顶点 V1和 V2
• 也可以说边(V1 , V2)与顶点 V1 、V2 相关联

无向图中的度

顶点 V 的度（Degree）是和 V 相关联的边的数目，记为 TD（V）

• V 相关联得边根据上面得定义，就是根顶点 V 相连接的边
• 上图中顶点 A、B互为邻接点
• 边（A，B）依附于顶点 A 与 B 上
• 顶点 A 的度为 A 关联得边得数目
• 关联的边有（A，B）、（A，C）（A，D）
• 所以顶点 A 得度为 3
• B 的关联边是（B，A）、（B，C）度是 2

有向图中的度

那么在有向图中的度呢？现在有有向图 G=（V，E）

• 如果弧$<V1,V2>\in E$，注意是尖括号。属于边的集合E
• 则称顶点 V1邻接到顶点 V2
• 顶点 V2 邻接自顶点 V1
• V1是弧尾，V2是弧头，所以这里得邻接是有方向的
• 邻接自和邻接到是不同的，请注意！

所以，有向图就跟无向图不同了

• 以顶点 V 为头的弧的数目称为 V 的入度（InDegree）记为 ID（V）
• 以顶点 V 为尾的弧的数目称为 V 的出度（OutDegree）记为 OD（V）
• 因此，该顶点 V 的度为$TD(V)=ID(V)+OD(V)$

我们看上面的有向图中

• 顶点 A 为头，指向 A 的入度为2
• 顶点 A 为尾，从 A 出去的出度为1
• A 的度为$2+1=3$

路径

在图中，我们从一个顶点到另一个顶点的路线，称为路径（Path）

无向图的路径

以下四种是在无向图 G 中顶点 A 到顶点 D 的四种不同的路径

我们看到顶点到顶点之间有这么多种不同的走法

• 以后我们学习图的主要目的就是简化路径
• 找出最优路径

有向图的路径

以下是在有向图 G 中从 B 到 D 的路径

有向图的路径需要额外注意方向

• 如果我从 A 到 B 是不行的，因为没有 A 为弧头、B 为弧尾的边。
• 必须是按照有向图的指向来从一个顶点到另一个顶点

路径的长度

路径的长度就是路径上边或弧的数量。

回路（环）

如果从第一个顶点到最后一个顶点相同的路径，我们称之为环

简单环

既然一个顶点到最后一个顶点得路径如果相同，我们就称之为环，那么什么是简单环呢？

• 在第一个顶点到最后一个顶点得环路上，每个顶点只出现一次。
• 除了第一个和最后一个顶点外，其余顶点都不重复出现得回路
• 满足以上条件，就是简单环了
• 简单来说，就是路径上的顶点不能重复，且能构成环状。

右侧图不是简单环得原因是

• 环可以是 BCADCB，C 出现了两次
• 所以不是简单环。

连通图

如果在一个无向图中

• 顶点 V1 到顶点 V2 有路径，则称 V1 和 V2 是连通的。
• 如果图中得任意两个顶点 Vi 和 Vj 都是连通的
• 我们就称这个图 G 为连通图（ConnectedGraph）

为什么左边得图不是连通图呢？因为

• E F没有一个顶点跟 ABCD 连通
• 所以并不是所有顶点都互相连通，不是连通图

注意：
完全图是：任意两个顶点必须是连接得，也就是得有边。
连通图是：任意两个顶点只要有路径能连过去就行。

连通分量

无向图中的极大连通子图称为连通分量。

• 无向图，就是边没有指定方向得图。
• 极大，就是必须包含这个子图中所有的顶点
• 连通，就是任意两个顶点都互相连通。
• 子图，就是顶点和边都属于无向图 G （V，E）。
• **注意:**具有极大顶点数的连通子图包含依附于这些顶点所有的边。

我们看上面的图

• ABCD 一定是图 G 的子图
• ABCD 的任意两个结点相互连接的
• 子图 ABCD 顶点数也是最大
• 那么我们就说子图 ABCD 是图 G 的极大连通子图
• 也是图 G 的连通分量

强连通图

我们说的连通图是无向图，对于有向图来说

• 如果对于每一对儿 Vi 到 Vj 都存在路径，则称 G 是强连通图。
• 相应的，对于有向图中得极大强连通子图称为有向图的强连通分量。

为什么左侧得不是强连通图？

• 因为任意两个顶点没有连通

但是右侧得可以是左侧图到极大强连通子图

• 任意两个顶点联通
• 是左侧图的子图
• 所有的顶点都包含，极大。

连通图生成树

连通图生成树，顾名思义，通过连通图生成一棵树，连通图的生成树是一个极小的连通子图，为什么呢？因为：

• 它含有图中全部的 n 个顶点
• 但只有 n-1条边，因为 n-1条边就可以生成一棵树了

中间两个图，都符合以下条件

• 它含有图中全部的 n 个顶点
• 但只有 n-1条边，因为 n-1条边就可以生成一棵树了
• 所以是极小连通子图，也是连通图生成树

最右边的图，不符合以下条件

• 虽然符合只有 n-1 条边
• 没有包含有图中全部的 n 个顶点
• 所以不是极小连通子图

有向树

如果一个有向图，符合以下条件

• 有一个顶点入度为0，即没有其它顶点指向它
• 其它顶点得入度都是1，也就是其他顶点都只有一个顶点指向它
• 我们就称这是一棵有向树。

上面两张图不是有向树，左图因为 D 结点的入度为3，右图因为 A 结点入度为2

上图是有向树

• F 得入度为0，没有顶点指向 F
• E G的入度都为1
• 所以上图是有向树

尾巴

这是我的个人学习笔记，主要是应付考研复习使用，充斥着一些吐槽和个人观点，并不严谨，欢迎大家参考、指正。

引入

终于，我们迎来了新的数据结构，图结构。之前的线性表，主要是一对一的关系，一个元素和另一个元素的关系。树结构，主要层与层之间一对多的关系，即一个结点可以有 N 个子树，N 个子树也只对应一个双亲结点。那么大家也应该猜到了，图解决的是多对多的数据关系。

图的定义

（顶点1有一个环的图结构）

**图（Graph）：**是有顶点的又穷非空集合和顶点之间的边集合组成。

• 通常表示为G（V，E）
• G 是一个图
• V 是图 G 中顶点的集合
• E 是图 G 中边的集合。

对于上面的图

• 每一个圆圈表示图的一个顶点，顶点放在一起就是 V
• 连接顶点的连线称之为图的边，边放在一起就是 E

数据元素的称呼

我们回顾一下线性表和树的数据

• 线性表中我们把数据称之为元素
• 树中我们把数据称之为结点
• 图中我们把数据称之为顶点（Vertex）

没有数据元素

我们回顾一下线性表和树没有数据元素时

• 线性表可以没有数据元素，称为空表。
• 树中可以没有结点，称为空树。
• 图一般不为空，我们一般说顶点集合 V 要有穷非空。

数据元素的关系

我们回顾一下线性表和树中数据元素之间的关系

• 线性表中的数据元素，一对一，我们说它们有线性关系。
• 树结构中的数据元素，一对多，我们说相邻两层的结点具有层次关系。
• 图结构中的数据元素，多对多，任意两个顶点之间都可能有关系，顶点之间的逻辑关系用边来表示，边集可以为空，即数据元素可以跟任何其他数据元素无关。

图的边

图中的各种特性和定义比较多，我们分开讲

无向边

看着上面这张图，我们来说明一下

• 若顶点 Vi 到 Vj 之间的边没有方向
• 则称这条边为无向边（Edge）
• 用无序偶（Vi，Vj） 来表示
• V 是顶点的集合哈，Vi 和 Vj 就是其中的两个顶点。别忘了。

知道了上面的概念之后，我们就可以说

• 上图G1是一个无向图，如果 $G1=\left { V1 , E2\right }$
• 顶点的集合：$V1=\left{A,B,C,D\right}$
• 边的集合：$E1=\left{(A,B),(B,C),(C,D),(D,A),(A,C)\right}$

有向边

看着上面这张图，我们来说明一下

• 若顶点 Vi 到 Vj 之间的边有方向
• 则称这条边为有向边，也称为弧（Arc）
• 用有序偶 < Vi , Vj > 表示，注意这里是尖括号
• Vi 称为弧尾，Vj 称为弧头。
• 因为是有向边，所有 Vi 和 Vj 顺序不能错，一定是尾巴指向头。

知道了上面的概念之后，我们就可以说

• 上图G2是一个有向图，如果 $G2=\left { V2 , E2\right }$
• 顶点的集合：$ V1= \left{ A,B,C,D \right} $
• 边的集合：$E1=\left{(B,A),(B,C),(C,A),(A,D)\right}$
• 这里边的集合要注意顺序！！！

简单图

什么叫做简单图呢？在一个图结构中

• 若不存在顶点到其自身的边
• 同一条边不重复出现
• 满足以上两个条件的图，叫做简单图。

以下两个都不是简单图

**注意：**我们目前讲的主要都是简单图，因为应用广泛。

特殊的图

根据图边、弧和顶点的不同情况，又分为以下几种常见图

无向完全图

如果在一个无向图中

• 任意两个顶点之间都存在边
• 则称该图为无向完全图
• n 个顶点的无向完全图有 $n\times(n-1)\div2$ 条边
• 上面就是一张无向完全图，所有顶点都连着边
• ABCD 4个顶点就是 $4\times(4-1)\div2=6$ 条边

有向完全图

如果在一个有向图中

• 任意两个顶点之间都存在方向互为相反的两条弧
• 则称该图为有向完全图
• n 个顶点的无向完全图有 $n\times(n-1)$ 条边
• 上面就是一张无向完全图，所有顶点都与另一个顶点互为相反弧
• ABCD 4个顶点就是 $4\times(4-1)=12$ \条边

稀疏图和稠密图

这里讲的稀疏和稠密都是相对而言的，通常

• 边或者弧数小于 $n\times \log n$时的图为稀疏图
• 反之为稠密图

带权图

这里说的权根我们在哈夫曼树中说的权是一样的

• 图的边或者弧带有与它相关的数字
• 我们把这些相关树称作权（weight）
• 我们称这种带权图为网（NetWork）

子图

如果有两个图 G1=（V1，E1）和 G2=（V2，E2）

• 如果 $V2 \subseteq V1$，G2的顶点都在 G1 的顶点的集合内
• 并且！！！
• $E2 \subseteq E1$，G2的边都在 G1 的边的集合内
• 记住，上面两个条件如果同时成立！
• 我么你就说 G2 是 G1 的子图
• 简单就是，我的顶点你也有，我的边你也有，那我就是你的子图

上面两张图中，红框内的都是左边图的子图。
记住有向图还要关注方向是否相同！

基础知识还有不少，我们下节继续！

尾巴

这是我的个人学习笔记，主要是应付考研复习使用，充斥着一些吐槽和个人观点，并不严谨，欢迎大家参考、指正。

未完待续…

未完待续…

引入

上一节我们发现，树、森林和二叉树之间竟然有这么多有趣的关联，前根和后根遍历结果竟然都可以跟二叉树相同。二叉树竟然这么的独特，今天我们就来看看，如何打造一棵完美二叉树！

从一个问题出发

我们在使用二叉树的时候，会遇到类似这样的问题

• 这是一棵二叉树，结点连接线上的数字，是访问这个结点的概率
• 我们有5%的几率访问 A、15%访问 B、70%访问 C、10%访问 D
• 那么问题来了，既然绝大多数都是访问 C 的
• 那访问 C 必须要先判断是否是 A 或者 B，这样太麻烦了

要弄清楚这个问题，我先首先要弄清楚刚才哪些加了数字的结点是什么。

带权叶子结点

还是这张图，我们看到这棵二叉树有一点点不同

• 结点前有一个数值，我们把这种结点间连线的相关书叫做权。
• 我们管这些叶子结点，叫做带权叶子结点。
• 数值越大，权重越大。

结点的路径长度

我们引申出一个新定义，结点的路径长度，我们来看一下

结点的路径长度

**定义：**根结点到叶子结点的路径上的连接数。

上图中，C 结点的路径长度为 3。

• 根到右子树，为1
• 右子树到右子树为，为2
• 右子树到右子树的左子树 C ，为3

树的路径长度

**定义：**根到每一个结点的路径长度之和。

上图中，我们来算一下

• 根到 A 是1
• 根到 B 是2
• 根到 C 是3
• 根到 D 是3
• 所以$1+2+3+3=9$
• 上面这棵树的路径长度为9。

结点带权路径长度

结点的路径长度是根到结点，那么带上权呢？

**定义：**结点的路径长度与结点权值的乘积。

我们还是拿 C 结点举例

• C 结点的路径长度我们算过了，长度是 3
• 那么 C 结点的带权路径长度就是$3 \times 70=210$
• C 结点的带权路径长度为210

树的带权路径长度

**定义：**根到每一个结点的路径长度乘以权值的和。

上图中，我们来算一下

• 根到 A 是1，权值是5，$1 \times 5=5$
• 根到 B 是2，权值是15，$2 \times 15=30$
• 根到 C 是3，权值是70，$3 \times 70=210$
• 根到 D 是3，权值是10，$3 \times 10=30$
• 所以$5+30+210+30=275$
• 上面这棵树的带权路径长度为275。

我们将树的带权路径长度称为 WPL（Weighted Path Length）
记住，WPL 就是树中所有叶子结点的带权路径长度之和。

最优二叉树

我们称 WPL 的值越小，构造出来的二叉树就约优秀，那么该如何构造出最优的二叉树呢？对了，最优二叉树我们也称为哈夫曼树！

初始化

首先，我们在森林中选择两课根结点权值最小的树，上图所示

• 我们把 A B C D 看做四棵树组成的森林
• A B C D 就是四个根节点，四个根节点都有一个权值
• 我们把最小的两个提取出来，即 C 和 D

接着我们来操作上面的两个最小的结点

• 把两个结点中权值较小的放到左边，即 C 放到左边，作为左孩子
• 权值较大的结点放在右边，作为右子树
• 将左右子树的权值相加，得到6，作为左右子树的双亲结点，我们记作N1

继续添加

我们剩下的还有两个结点，A 和 B

• 上一步我们得到了一个 N1，权值是 C D 的和
• 此时我们从 A 和 B 中选择一个较小的结点 B，拿出来

我们开始比较 B 和 N1

• 如果 B 比 N1 大，那就放右边作为右子树，反之作为左子树
• 因为 B 是5，N1是6，所以我们把 B 放在左边
• 同样的生成一个 N2，N2的权值是 N1和 B 的和，即5+6=11

最后剩下的结点 A 相同，最后得到这棵哈夫曼树的根权值为18。
哈夫曼树构造完毕。

哈夫曼树的优点？

我们费劲儿构建的这棵哈夫曼树有什么厉害的地方呢？

• WPL 最小，WPL 还记得吧？就是树的带权路径
• 我们不可能构建出比哈夫曼树更好的排列方式
• 所以我们将哈夫曼树也成为完美二叉树。

回到问题

还记得我们开头这个问题吗？既然访问节点的概率就是权值的话，我们用哈夫曼树的构建方式，将 A B C D 重新构建之后，就可以解决啦！

尾巴

这是我的个人学习笔记，主要是应付考研复习使用，充斥着一些吐槽和个人观点，并不严谨，欢迎大家参考、指正。