情况

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

安装后实际上在 /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 重新构建之后，就可以解决啦！

尾巴

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

引入

我们学习了树、二叉树、以及森林的知识。我们直到遍历二叉树非常的方便，甚至学会了给二叉树增加线索，提高效率。那么问题来了，如果一棵树，不是二叉树，一个结点下有 N 个孩子，那么我们遍历和操作起来，就会很复杂，因为不知道这棵树是深度长还是宽度广，如果都能转换成二叉树来操作就爽了！今天我们就看看普通树和森林，如何转换成二叉树。

普通树转换为二叉树

既然二叉树最方便操作，我们如何能够将普通树转换成二叉树呢？

上面是一棵普通树，有三层，我们将这棵树转换成二叉树

第一步，操作兄弟结点

• 兄弟结点就是位于二叉树同一层的所有结点
• 同一个双亲的所有兄弟结点连接起来
• 如果没有兄弟则不需要链接

第二步，去掉原有的连接线，规则如下

• 每一个结点，只保留结点和其长子的连接线
• 如果没有左孩子只有右孩子的话，那就保留右孩子的，以此类推
• 去掉结点与其他孩子的连接线

第三步，变成二叉树

• 仔细看就是前一张图的结点连接线
• 红线表示左子树
• 绿线表示右子树
• 把二叉树画出来即可

森林转换为二叉树

森林转换为二叉树，其实跟刚才的普通树转换为二叉树差不多

• 先将森林的每棵普通树转换为二叉树，不会的看上面。
• 然后将森林里，每棵二叉树的根看做兄弟，进行连线
• 每棵树的根，都是右子树，所以如果森林有三棵树
• 那就是第一棵树作为二叉树的根，第二棵树是根的右子树，第三颗树是第二棵树的右子树

我们来看一个例子

这片森林有三棵树，每棵树都不是二叉树，我们将其先都转换成二叉树的形式

然后我们把三棵树的根连在一起，每棵树的根，都是右子树

然后我们根据普通树转二叉树的规则，再加上每棵树的根都是右子树，将森林转换成二叉树

二叉树转换到树、森林

第一步：我们知道如何将二叉树转换成树和森林，我们接着看看，如何反向转换

• 如果一个结点 A，是结点 X 的左孩子
• 那么这个结点 A 的右孩子的右孩子的右孩子…所有的右孩子
• 都划线连接到 X，就是结点 A 的双亲
• 我们看看下面的图

这张图就是根据上面的规则进行连线，我们来看一下

• 先找哪些节点是双亲的左孩子，B、F、H
• 再看看 B、F、H 有没有右子树，B 和 H 有
• 接着看看 B 和 H 的右子树还有没有右子树，B的右子树下还有个 D
• B 的右子树 C、B 的右子树的右子树 D 连接到 B 的双亲 A
• H 的右子树 I 连接到 H 的双亲 G
• Done！

第二步：去掉所有双亲到右孩子之间的连线

注意，G 到 I 是可以的，因为 H 才是 I 的双亲。

最后我们把二叉树转换回了森林。

**注意：**判断二叉树是森林还是普通树的方法是看二叉树的根节点有没有右子树，如果有，那根据倒推原理，一定是森林，没有就是普通树。

总结

普通树转换为二叉树

• **加线：**兄弟结点加线
• **去线：**每个结点都只保留与第一个孩子的连线
• **调整：**树本身的连线是左子树，我们划的线是右子树

森林转换为二叉树

• **二叉：**先把普通树都转换为二叉树
• **连根：**把所有二叉树的根连接起来
• **调整：**第一棵二叉树是根，其它根都是右孩子

二叉树转换为树、森林

• **判断：**判断根有没有右子树，有就是森林，没有就是普通树
• **连线：**把右孩子们和双亲链接在一起。
• **去线：**把所有结点到右孩子的连线去掉
• **调整：**剩下的就是普通树或者森林

思考

我们为什么费劲把普通树和森林转换为二叉树呢？
因为普通树和森林遍历不方便。

普通树的遍历

如果我们使用先根的方法遍历普通树

• 先输出根
• 然后从左到右输出全部子树
• 然后再从左到右输出子树的子树
• 依次类推

同样的，如果我们使用后根的方法遍历普通树

• 先输出子树
• 然后再从左到右输出子树的双亲
• 依次类推

我们看看例题

**先根遍历结果是：**A B E F C G D H I J
**后根遍历结果是：**A B E F C G D H I J

森林的遍历

其实森林的遍历跟树的遍历一样

• 第一棵结束就下一棵
• 然后把所有的便利结果放在一起就行了

发现

前人们惊人的发现了以下事实，对于森林、树的遍历和二叉树的遍历

• 森林、树的前根遍历 等同于 二叉树的前序遍历
• 森林、树的后跟遍历 等同于 二叉树的中序遍历

好了！有意思的事情来了！下节继续！

尾巴

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

60秒读全文

这是一篇在 Nintendo Switch 6.2.0系统上，将游戏数据和存档从 128G 内存卡 转移 到 256G 内存卡，转移成功后，下载的游戏数据及存档有被 Switch 系统认到，并可正常使用的。

引入

前天下了《任天堂明星大乱斗 特别版》的时候，发现自己去年11月买的 128G microSD 卡竟然满了，以为能用一段时间呢… 今天进入 Manage Software 一看《DOOM》竟然要 30G ，《异度之刃2》、《任天堂明星大乱斗 特别版》、《Diabol III》都要十几个 G ，所以入了 256 G 的新 microSD 卡，老卡就留着之后进军 Vlog 吧。
至于为什么要写这篇文章呢？因为发现网上流传的几种方法我复现都失败了，也算是记录一下，万一下次换 512G 的内存卡呢？废话不多说，老 128G microSD 卡换256G，游戏文件和存档该如何转移呢？我们接着看~

准备

我们在开始前，请确认下面的东西已经准备好了

• Nintendo Switch 主机一台。
• **老内存卡：**我的就是128G 的老卡，不要动里面的数据。
• **新内存卡：**不用提前格式化，等下会讲。
• **高速读卡器：**如果没有像我 110+G 要等死…
• **PC / Mac：**用于操作文件转移。

思路

我们的大概思路如下

• 格式化新内存卡，让 Switch 认到
• 老内存卡的数据拷贝到新内存卡
• 存储老内存卡数据之后的新内存卡 Switch 还能认到。

碰壁

我 Google 了一下目前网络上的换内存卡的方法，大致有三种
（你如果只想解决问题，可以跳过碰壁这一节）

第一种不推荐方法
昨天刚换了
先关机 把旧卡nintendo文件夹拷贝到电脑上
插入新卡开机，进系统后识别到新卡后会看见在卡上的数字版游戏会出现云图标，再关机拔新卡
然后把nintendo文件夹覆盖到新卡上
新卡插回机器，开机后游戏仍然有云图标，点进去会让你下载，不过是瞬间就下好了 因为数据是有的
来源：https://bbs.nga.cn/read.php?tid=12603922&rand=638

不推荐原因

• 这种方法卡还是没有被机器认到，因为显示云图标
• 有可能 Switch 会删除你的文件，因为文件校验可能会有问题

第二种不推荐方法
1把老卡nintendo文件夹全部拷贝到电脑上；
2 把新卡放进任天堂Switch中，此时，NintendoSwitch会提示你重启，确定重启，然后拔出新卡，ns会关机；
3新卡连上电脑，将之前拷贝的nintendo文件夹复制到新卡根目录 最后百分之几的时候会提示有相同内容，选择全部覆盖；
4将任天堂Switch开机，所有游戏图标都有个云下载提示，不要管它，插入拷贝好的新卡，提示重启，确定—然后就ok了。
PS：这里一定要让NintendoSwitch在开机状态下插入新卡自己重启一次，如果关机状态插入新卡，开机以后进所有游戏都会报错。
来源：https://zhuanlan.zhihu.com/p/49452671

不推荐原因

• 新卡放进去会提示校验失败，让你重新格式化卡片
• 但这一种方法提供了一个思路，让新卡在开机状态下，让 Switch 认一次，也就是不弹出校验失败的提示框。

第三种不推荐方法
1把老卡nintendo文件夹全部拷贝到电脑上；
2 把新卡放进任天堂Switch中，此时，NintendoSwitch会提示你重启，确定重启，然后拔出新卡，ns会关机；
3新卡连上电脑，将之前拷贝的nintendo文件夹复制到新卡根目录 最后百分之几的时候会提示有相同内容，选择全部覆盖；
4将任天堂Switch开机，所有游戏图标都有个云下载提示，不要管它，插入拷贝好的新卡，提示重启，确定—然后就ok了。
PS：这里一定要让NintendoSwitch在开机状态下插入新卡自己重启一次，如果关机状态插入新卡，开机以后进所有游戏都会报错。
来源：https://bbs.a9vg.com/thread-5284744-1-1.html

不推荐原因

• 其实不用在 Switch 开机状态下强行拔卡，容易造成老内存卡数据损坏
• 其实有其他方法让 Switch 认到新卡

**当然了：**上面三种方法，我都没能成功，有运气因素，不过如果我下面的方法失效了，你们也可以试试上面的方法。

动手

我们开始吧，我标红的地方一定要着重看，顺序、先后很重要！

Switch 端操作

我们先操作 Switch

• 长按 Switch 电源键，关闭 Switch
• 然后将 Switch 支架打开，向里轻推内存卡
• 将老内存卡拿出备用

备份老内存卡

我们将老内存卡先进行备份，防止数据丢失

• 将老内存卡插入高速读卡器，否则等到天荒地老…
• 然后打开内存卡内的文件，里面只有一个 Nintendo 的文件夹
• 右键该文件夹，复制到你的 Mac / PC 的硬盘上
• 等待时间缓缓的流逝…岁月静好。

准备新卡

在等待的过程中，我们先来准备新卡

• 用剪刀剪开新内存卡的包装
• 然后在 Switch 关机状态下插入新内存卡
• 打开 Switch 电源，进入 Switch

Switch 格式化新卡

点击齿轮图标，进入设置。

左边列表向下划最后，进入 System，在System 界面最下面找到初始化（Formatting Option）

在初始化（Formatting Option）里，选择格式化 microSD 卡（Format microSD card）

注意

1. 请再次确认是新卡在机器中
2. 请再次确认老卡在你的桌子上、或读卡器中正在备份

点击 Continue，将新卡格式化。

让 Switch 认可新内存卡

这一步是至关重要的，因为如果 Switch 不认，数据拷贝到老卡上也没用
我估计我上面三种方法失败的原因就出在这一步。

• 首先，将 Switch 关机，将备份好数据的老内存卡放在旁边。
• 然后将新内存卡拔出，放在旁边
• 接着不插任何内存卡开机。
• 然后解锁 Switch ，进入主屏幕
• 将老内存卡插入 Switch，正常会提示如下

• 这里选择later，然后在开机状态下拔出老内存卡，不会有任何提示
• 接着将新内存卡也插入，正常会提示如下

这里同样选择later，然后关闭 Switch，将新内存卡拔出

恢复数据

将执行完上面操作的新内存卡，连接读卡器

打开刚才在PC / Mac 上备份的Nintendo 文件夹，里面是三个文件

将 Album 文件夹中的以年份开头的所有文件，复制到新内存卡的 Album 文件夹中

将 Contents 文件夹中的 private 文件，复制到新内存卡的 Contents 文件夹中

将 Contents 文件夹中的 placehld 和 registered 文件夹中的所有内容都复制到新内存卡对应的文件夹中，切记不要直接复制 placehld 和 registered 这两个文件夹，只操作 placehld 和 registered 文件夹中的文件。

将 save 文件夹中的所有文件，复制到新内存卡的 save 文件夹中

特别注意

1. 只赋值目标文件夹内的文件，不要操作整个文件夹。
2. 如果提示文件重复，直接覆盖文件即可。

Switch 检查

上述文件全部操作完毕后

• 将Switch关闭电源，拔出里面的内存卡
• 然后在不插内存卡状态开机
• 将新内存卡插入已经开机的 Switch 主机中
• 如果有如下提示
  

选择 restart ，重启 Switch，此时

• 开机不会报 Card 不认的提示
• 所有游戏图标的右上角没有云图标
• 进入设置，剩余容量显示正常
• 进入游戏正常，存档显示正常

恭喜你！大功告成！

啰嗦

至于为什么几十字的东西我要说的这么啰嗦，是因为你觉得你会初始化内存卡、你知道该如何备份数据，你很优秀！你可以跳过！如果我不写清楚，不清楚的又要去搜来搜去，会更麻烦！然而他们也很优秀，他们没法不跳过。他们只是想知道这些啰嗦。

引入

上一节，我们试着解决了树在存储时空间浪费和没法找到双亲结点的问题，这一节，我们着重看一下如何用代码实现。这篇难度有一点大，请务必沉住气，认真仔细。

思路拆解

我们一步一步的拆解代码来看看。

创建树结构体

我们首先声明我们重新设计的线索二叉树结点

• char data 存放结点数据
• 左孩子、右孩子这个不用细说了吧，
• Ltag 和 Rtag 主要是判断左孩子和右孩子究竟是指向左右孩子还是前驱后继
• 我们定义结构体的时候，使用了 typedef
• 后面所有的 BiTNode 你可以理解为 struct BiTNode，代表该结构体
• 后面所有的 BiTree 你可以理解为 struct BiTNode *，代表结构体指针
• 注意上面有个星号哈！

#include <stdio.h>
#include <stdlib.h>
#define LEN sizeof(struct BiTNode)

typedef enum{link,thread} NodeState;
typedef struct BiTNode{
    char data;
    struct BiTNode *Lchild;
    struct BiTNode *Rchild;
    NodeState Ltag;
    NodeState Rtag;
}BiTNode,*BiTree;

创建二叉树

我们刚才重新设计了结点，现在开始生成树，首先接收数据

• **重点：**我们这里的形参，是 BiTree *tempTree
• BiTree *tempTree 你可以理解为 struct BiTNode **tempTree
• 就是一个指向二叉树结点的结构体的指针的指针。
• 然后 tempC 是用来存放输入的结点 data 的
• 我们使用 scanf 来接收数据

然后我们判断 scanf 中的数据

• 如果输入的是 # 号，表示结点为空，我们就把结点设置为 NULL
• 这里注意，我们是将*tempTree设置为 NULL，不是** tempTree
• 是1个星号的，1个星号表示的是结点结构体的指针

如果scanf 中接受的不是#号

• 先创建动态存储空间，1个星号表示的是结点结构体的指针
• 所以给1个星号表示的是结点结构体的指针创建动态存储空间
• (*tempTree)这里为什么加括号呢？学过指针都知道！
• *tempTree 表示的是 tempTree 中地址指向的数据
• 既然 tempTree 存储的是指针的指针，所以把 tempTree 加一个星号
• 表示 tempTree 中结点的地址，也就是结点结构体的开始地址
• 我们先给 data 赋值为 tempC
• 然后默认左右 tag 是 Link，也就是链接状态
• 后面如果遇到子树为空，我们会修正 tag 的内容
• 然后利用递归，创建左子树和右子树

void Create(BiTree *tempTree){
    char tempC;
    scanf("%c",&tempC);
    if(tempC=='#'){
        *tempTree=NULL;
    }else{
        *tempTree=(BiTree)malloc(LEN);
        (*tempTree)->data=tempC;
        (*tempTree)->Ltag=link;
        (*tempTree)->Rtag=link;
        Create(&(*tempTree)->Lchild);
        Create(&(*tempTree)->Rchild);
    }
}

给二叉树添加线索

我们生成了一个二叉树，这棵二叉树的每个结点都有 Ltag 和 Rtag，该如何利用呢

• 我们这一步就是给哪些没有前驱、后继的结点，修改 Ltag 和 Rtag 状态。
• pre 是一个结点结构体指针的全局变量，保存根的前驱
• 然后我们传入二叉树，给二叉树添加线索
• 利用中序遍历，左中右的方式，递归遍历这棵树。

判断根节点左子树的情况

• 在根节点时，判断根节点左右子树的状态，记住有右必有左
• 先判断左子树，如果为空，那么这个结点的 Lchild 改为前序的地址
• Ltag 改为 thread，表示这个 Lchild 是线索
• 这里的 Lchild 是 pre，pre 等下会存储每个结点的前驱。

判断根节点右子树的情况

• 怎么判断右子树呢？如果只有左没有右呢？
• 所以判断 pre 的右子树，只要当前结点的前一结点的右子树为空
• 那么就改变 Rtag 状态为线索
• Rchild 右孩子为当前结点
• 也就是当前结点前驱没有右子树，那么前驱的右孩子指向当前结点。
• 记得最后把当前的地址个 pre，这样指针才能向后走，pre 才能保存前驱结点

BiTree pre;

void Inthread(BiTree t){
    if(t){
        Inthread(t->Lchild);
        
        if(!t->Lchild){
            t->Ltag=thread;
            t->Lchild=pre;
        }
        
        if(!pre->Rchild){
            pre->Rtag=thread;
            pre->Rchild=t;
        }
        
        pre=t;
        
        Inthread(t->Rchild);
    }
}

根结点的前驱

我们知道，根结点是没有双亲的，那么怎么获得根结点的前驱呢？

• 创建一个 p ，模拟根的前驱，让根的前驱指向这个 p
• 先创建一个 p，星号的道理和创建树的时候相同，就不解释了。
• Rtag 因为指向自己，所以为 thread 线索
• Ltag 因为等下要指向树本身，所以为 link
• 然后让 Rchild 指向子集
• 判断树是不是空的，如果是空的，那没得玩，左右子树都指向 p 自己
• 如果不是空的，那就让左子树指向树根
• pre 就能获取根的前驱了，就是 p
• 然后从这里调用给二叉树加线索的函数
• 因为给二叉树加线索，需要用到根的前驱。

记得收尾

• 最后，我们让这棵树连成圈
• 让 pre，也就是最后一个结点的前驱的右孩子指向 P，也就是根的前驱
• 让后 p 的右孩子指向 pre
• 这样，就连起来了

void Inorderthread(BiTree t , BiTree *p){
    *p=(BiTree)malloc(LEN);
    (*p)->Rtag=thread;
    (*p)->Ltag=link;
    (*p)->Rchild=*p;
    if(!t){
        (*p)->Lchild=*p;
    }else{
        (*p)->Lchild=t;
        pre=*p;
        Inthread(t);

        pre->Rtag=thread;
        pre->Rchild=*p;
        (*p)->Rchild=pre;
    }
}

两种遍历方式

用递归的时候注意，要在加线索之前使用，否则树都连起来就会出错。

###递归中序遍历，不多说了，需要的话看前面

void Inthreading(BiTree t){
    if(t){
        Inthreading(t->Lchild);
        printf("%c",t->data);
        Inthreading(t->Rchild);
    }
}

迭代中序遍历，就是利用 while 循环遍历

同样是左中右

• 如果 p=t->Lchild,那就证明转了一圈了。
• 然后判断最左边的结点，输出
• 判断右边结点是否是叶子，也输出
• p 向右孩子移动一位
• 直到转完所有的结点

void Inorderthreading(BiTree t){
    BiTree p;
    p=t->Lchild;
    while(p!=t){
        while(p->Ltag==link){
            p=p->Lchild;
        }
        printf("%c",p->data);
        while(p->Rtag==thread && p->Rchild!=t){
            p=p->Rchild;
            printf("%c",p->data);
        }
        p=p->Rchild;
    }
}

主调函数

这个其实没什么好讲的，就是星号和顺序的问题

• 星号请注意，因为传过去的是指针的地址，所以要加&符号
• 顺序请注意，先使用递归输出，再增加线索，最后用迭代循环输出
• 原因是增加线索后，树连起来了，递归没法结束。

int main(){
    BiTree t,p;
    printf("请输入结点：\n");
    Create(&t);
    printf("递归-中序遍历是：");
    Inthreading(t);
    printf("\n");
    printf("迭代-中序遍历是：");
    Inorderthread(t,&p);
    Inorderthreading(p);
    printf("\n");
    return 0;
}

主要问题

这个也绕了我好久，主要问题是

• 指向指针的指针，出了问题！
• 递归增加线索，出了问题！

总代码

#include <stdio.h>
#include <stdlib.h>
#define LEN sizeof(struct BiTNode)

typedef enum{link,thread} NodeState;
typedef struct BiTNode{
    char data;
    struct BiTNode *Lchild;
    struct BiTNode *Rchild;
    NodeState Ltag;
    NodeState Rtag;
}BiTNode,*BiTree;

BiTree pre;

void Create(BiTree *tempTree){
    char tempC;
    scanf("%c",&tempC);
    if(tempC=='#'){
        *tempTree=NULL;
    }else{
        *tempTree=(BiTree)malloc(LEN);
        (*tempTree)->data=tempC;
        (*tempTree)->Ltag=link;
        (*tempTree)->Rtag=link;
        Create(&(*tempTree)->Lchild);
        Create(&(*tempTree)->Rchild);
    }
}

void Inthread(BiTree t){
    if(t){
        Inthread(t->Lchild);
        
        if(!t->Lchild){
            t->Ltag=thread;
            t->Lchild=pre;
        }
        
        if(!pre->Rchild){
            pre->Rtag=thread;
            pre->Rchild=t;
        }
        
        pre=t;
        
        Inthread(t->Rchild);
    }
}

void Inorderthread(BiTree t , BiTree *p){
    *p=(BiTree)malloc(LEN);
    (*p)->Rtag=thread;
    (*p)->Ltag=link;
    (*p)->Rchild=*p;
    if(!t){
        (*p)->Lchild=*p;
    }else{
        (*p)->Lchild=t;
        pre=*p;
        Inthread(t);

        pre->Rtag=thread;
        pre->Rchild=*p;
        (*p)->Rchild=pre;
    }
}

void Inthreading(BiTree t){
    if(t){
        Inthreading(t->Lchild);
        printf("%c",t->data);
        Inthreading(t->Rchild);
    }
}

void Inorderthreading(BiTree t){
    BiTree p;
    p=t->Lchild;
    while(p!=t){
        while(p->Ltag==link){
            p=p->Lchild;
        }
        printf("%c",p->data);
        while(p->Rtag==thread && p->Rchild!=t){
            p=p->Rchild;
            printf("%c",p->data);
        }
        p=p->Rchild;
    }
}

int main(){
    BiTree t,p;
    printf("请输入结点：\n");
    Create(&t);
    printf("递归-中序遍历是：");
    Inthreading(t);
    printf("\n");
    printf("迭代-中序遍历是：");
    Inorderthread(t,&p);
    Inorderthreading(p);
    printf("\n");
    return 0;
}

输出结果：
请输入结点：
ABDH##I##E#J##CF#K##G##
递归-中序遍历是：HDIBEJAFKCG
迭代-中序遍历是：HDIBEJAFKCG

遍历的是上面这棵树。

带注释的总代码

我第二天一早又写了一遍，加了一些注释

#include <stdio.h>
#include <stdlib.h>
#define LEN  sizeof(struct BiTNode)

typedef enum{link,thread} Nodestate;  //着重看一下
typedef struct BiTNode{
    char data;
    struct BiTNode *Lchild;
    struct BiTNode *Rchild;
    Nodestate Ltag;
    Nodestate Rtag;
}BiTNode,*BiTree;

BiTree pre;

void Create(BiTree *tempt){
    char tempc;
    scanf("%c",&tempc);
    
    if(tempc=='#'){
        *tempt=NULL;  //因为 *temp 才是结点
    }else{
        *tempt=(BiTree)malloc(LEN);
        //先赋值
        (*tempt)->data=tempc;
        //左右孩子的默认状态是链接的
        (*tempt)->Ltag=link;
        (*tempt)->Rtag=link;
        //接着用递归的方式先输入左子树再输入右子树，这种前序遍历
        Create(&(*tempt)->Lchild);
        Create(&(*tempt)->Rchild);
    }
}

//给上面的二叉树创建线索
void Inthread(BiTree t){
    if(t){
        //因为是用中序给树增加线索，所以先递归左孩子
        Inthread(t->Lchild);
        
        if(!t->Lchild){
            //如果中间根结点左孩子为空，状态改变
            t->Ltag=thread;
            t->Lchild=pre;  //这里的 pre 记录的是 t 的前驱结点
        }
        
        if(!pre->Rchild){
            //因为没法用该结点判断右孩子，所以用前驱判断，如果右孩子为空
            pre->Rtag=thread;
            pre->Rchild=t;  //如果前驱的右孩子为空，那么前驱的左右都指向当前结点
        }
        
        pre=t;  //让前驱向后移动一位
        
        Inthread(t->Rchild);  //完成左中右的遍历过程
    }
}

//创建根的 pre

void  Inorderthread(BiTree t , BiTree *p){
    *p=(BiTree)malloc(LEN);
    //右孩子等于 thread，并且指向自己
    (*p)->Rchild=*p;
    (*p)->Rtag=thread;
    //左孩子为连通，等下指向树的根
    (*p)->Ltag=link;
    
    if(!t){
        (*p)->Lchild=*p;
    }else{
        //把 p 的左子树指向 t 树的根
        (*p)->Lchild=t;
        pre=*p;  //pre 就是这个指向根的结点
        Inthread(t);  //有了 pre，开始给树增加线索
        
        //收尾，此时 pre 是最后一个结点
        pre->Rtag=thread;
        pre->Rchild=*p;
        (*p)->Rchild=pre;
    }
}

//开始递归中序遍历
void Invisit(BiTree t){
    if(t){
        Invisit(t->Lchild);
        printf("%c",t->data);
        Invisit(t->Rchild);
    }
}

//开始迭代中序遍历
void Inthreading(BiTree t){
    BiTree p;
    p=t->Lchild;
    //如果转到 t，那么证明指回根节点了，转了一圈了
    while(p!=t){
        //如果左边是连通的，那么向下
        while(p->Ltag==link){
            p=p->Lchild;
        }
        
        printf("%c",p->data);
        
        while(p->Rtag==thread && p->Rchild!=t){
            p=p->Rchild;
            printf("%c",p->data);
        }
        
        p=p->Rchild;
    }
}

int main(){
    BiTree t,p;
    printf("请输入结点：\n");
    Create(&t);
    printf("递归-中序遍历：");
    Invisit(t);
    printf("\n");
    printf("迭代-中序遍历：");
    Inorderthread(t,&p);
    Inthreading(p);
    printf("\n");
}

尾巴

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

引入

前面，我们说过，二叉树的遍历方法，以及如何使用代码创建二叉树并将三种遍历顺序都输出出来。如果你还对单链表有印象，我们会发现上节我们树的创建过程其实就是根结点指向左右子树，很像单链表指向唯一后继，对不对？还记得为什么我们要使用双向链表嘛？因为双向链表在找寻唯一前驱的时候方便。因此，二叉树也遇到了相同的问题，左右子树不知道自己的双亲是谁，我们该怎么解决呢？

问题

现在的二叉树

• 一个结点下，数据域和指针域
• 数据域，存放数据
• 指针域，指向该结点下的左右子树

问题一

如果我要找这个结点的双亲该怎么办呢？

• 麻烦了！我们要重新遍历这个棵二叉树
• 直到遇到这个结点，然后记录它得双亲

问题二

我们看上面这张图，发现

• 一个结点的指针域，如果没有左右子树！
• 例如 EFGHI ，它们的指针域会非常的浪费空间！
• 计算下来，一共9个结点，18个指针，10个都被浪费了。

好了，现在的问题是

• 左右子树找到不到双亲结点，孩子找不到爹妈。
• 如果没有左右子树，结点空间又被浪费掉！

思考

那么把剩余的空间利用起来，存放结点的双亲信息不就好了？

• 那我们就把结点的结构改造一下
• 让程序直到，我的左右子树指向的是我的左右子树，还是前驱后继

改造

我们将原有的结点结构体，改造如下

我们发现，增加了左右孩子的状态

• 左孩子状态为0，那么左孩子指向的是左孩子的结点地址。
• 左孩子状态为1，那么左孩子指向的是该结点的前驱地址。
• 右孩子状态为0，那么右孩子指向的是左孩子的结点地址。
• 右孩子状态为1，那么右孩子指向的是该结点的后继地址。

这么说可能有点晕，我们看看这张图，我们看到

• 现在 H 结点的左右子树地址为 NULL
• 那么我们让 H 结点的 Ltag 为 1
• H 结点的左孩子指针域存储的就是H 结点的前驱
• 那么我们让 H 结点的 Rtag 为 1
• H 结点的右孩子指针域存储的就是H 结点的后继
• 因为 H 结点的后继是没有的，所以存储为 NULL。

这样我们就最大限度上利用了存储空间，提高了搜索结点时的效率。即用空间换时间。下节我们主要讲讲线索二叉树的代码。

尾巴

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

引入

上一节，我们详细说明了二叉树的 4 种遍历方式，根据根的位置不同，我们分为前序遍历、中序遍历和后序遍历以及最常用的层序遍历。今天我们就来实战一下， 看看如何建立一棵树，并且按照我们需要的方式遍历树上的结点。

需求

• 根据输入建立一棵二叉树
• 输出其前序遍历、中序遍历和后序遍历结果

代码分析

首先要构建一棵树，因为是二叉树，所以结构体中包含左右两棵子树

• 存放数据的data
• 存放左右子树的指针域

#include <stdio.h>
#include <stdlib.h>
#define LEN sizeof(struct BiTNode)

struct BiTNode{
    char data;   //用于存放结点数据
    struct BiTNode *Lchild;   //存放左孩子地址
    struct BiTNode *Rchild;   //存放右孩子地址
};

接着，我们开始创建树，我们使用的是返回树根节点地址的方式

• 先创建一个临时结点
• 在创建一个临时 char 变量，用于存放用户输入的内容
• scanf 让用户输入内容，将值赋值给 char 变量
• 如果输入的是#号，则表示结点为空
• 如果不为空，则将这个结点看成根，将输入的值赋予根结点
• 接着将这个根的左右子树通过递归获取到
• 将所有的叶子结点都输入为#后，即所有结点都是 NULL ，没有左右子树，树创建完成。

struct BiTNode *Create(void){
    struct BiTNode *tempTree;
    char tempC;
    scanf("%c",&tempC);
    if(tempC=='#'){   //如果结点为空，那么就赋值为 NULL
        tempTree=NULL;
    }else{
    //如果结点不为空，那就生成动态存储空间
        tempTree=(struct BiTNode *)malloc(LEN);
        //我们默认输入的时候按照前序遍历输入，所以先存储结点值，然后左右子树遍历
        tempTree->data=tempC;
        tempTree->Lchild=Create();  //左子树递归
        tempTree->Rchild=Create();  //右子树递归
    }
    return tempTree;  //返回根结点地址
}

树的遍历，我们使用递归的思路，其实很好遍历

• 前序遍历是，根在前面，所以是中左右，所以先输出 data，再递归左右子树
• 中序遍历是，根在中间，所以是左中右，所以先递归左子树，再输出 data，再递归右子树
• 后序遍历是，根在后面，所以是左右中，所以先递归左右子树，再输出 data。
• 我们判断条件也非常简单，只要结点不为 NULL，就执行！

void PreVisitTree(struct BiTNode *Temptree){
    if(Temptree){
        printf("%c",Temptree->data);
        PreVisitTree(Temptree->Lchild);
        PreVisitTree(Temptree->Rchild);
    }
}

void InVisitTree(struct BiTNode *Temptree){
    if(Temptree){
        InVisitTree(Temptree->Lchild);
        printf("%c",Temptree->data);
        InVisitTree(Temptree->Rchild);
    }
}

void PostVisitTree(struct BiTNode *Temptree){
    if(Temptree){
        PostVisitTree(Temptree->Lchild);
        PostVisitTree(Temptree->Rchild);
        printf("%c",Temptree->data);
    }
}

主调 Main 函数

• 首先创建一个树指针，用于存放生成好的树。
• 然后使用前序、中序、后续遍历的函数，分别调用这棵树。
• 输出的结果就是这棵树的前序、中序、后续遍历了。

int main(){
    struct BiTNode * tree;
    printf("请输入结点：\n");
    tree=Create();
    PreVisitTree(tree);
    printf("\n");
    InVisitTree(tree);
    printf("\n");
    PostVisitTree(tree);
    printf("\n");
}

完整代码

#include <stdio.h>
#include <stdlib.h>
#define LEN sizeof(struct BiTNode)

struct BiTNode{
    char data;
    struct BiTNode *Lchild;
    struct BiTNode *Rchild;
};

struct BiTNode *Create(void){
    struct BiTNode *tempTree;
    char tempC;
    scanf("%c",&tempC);
    if(tempC=='#'){
        tempTree=NULL;
    }else{
        tempTree=(struct BiTNode *)malloc(LEN);
        tempTree->data=tempC;
        tempTree->Lchild=Create();
        tempTree->Rchild=Create();
    }
    return tempTree;
}

void PreVisitTree(struct BiTNode *Temptree){
    if(Temptree){
        printf("%c",Temptree->data);
        PreVisitTree(Temptree->Lchild);
        PreVisitTree(Temptree->Rchild);
    }
}

void InVisitTree(struct BiTNode *Temptree){
    if(Temptree){
        InVisitTree(Temptree->Lchild);
        printf("%c",Temptree->data);
        InVisitTree(Temptree->Rchild);
    }
}

void PostVisitTree(struct BiTNode *Temptree){
    if(Temptree){
        PostVisitTree(Temptree->Lchild);
        PostVisitTree(Temptree->Rchild);
        printf("%c",Temptree->data);
    }
}

int main(){
    struct BiTNode * tree;
    printf("请输入前序结点：\n");
    tree=Create();
    PreVisitTree(tree);
    printf("\n");
    InVisitTree(tree);
    printf("\n");
    PostVisitTree(tree);
    printf("\n");
}

输出结果
请输入前序结点：
ABDH##I##E#J##CF#K##G##
ABDHIEJCFKG
HDIBEJAFKCG
HIDJEBKFGCA

尾巴

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

引入

这节课是二叉树的考试重点，通过什么样的方式遍历二叉树，这里需要把内容搞清楚，不要混淆。

二叉树遍历

二叉树遍历(traversing binary tree)，指的是

• 从根结点出发，按照某种次序
• 依次访问二叉树中的所有结点
• 使得每个结点都被访问一次，且仅有一次。

二叉树跟线性结构的不同

线性结构的便利，最多是

• 顺序
• 循环
• 双向
• 都是简单的遍历方式

树就不一样了

• 树的结点之间不存在唯一的前驱和后继这样的关系
• 一个结点后面会跟着左子树和右子树两个结点，不是唯一的
• 所以下一个结点的选择是不同的

二叉树的遍历方式

如果都是从左到右的话，遍历方式分为 4 种

• 前序遍历
• 中序遍历
• 后序遍历
• 层序遍历

前序遍历

如果二叉树为空，则返回，否则

• 先访问根节点
• 然后前序遍历左子树
• 接着前序遍历右子树

遍历的技巧

• 每个结点都看成一个根
• 按照根、左子树、右子树顺序输出
• 然后返回上一层
• 再进行根、左子树、右子树的顺序输出

上面的答案是
ABDHIEJCFKG

超详细解题思路

• A 是 ABC 的根，输出 A，走向左子树 B
• B 是 BDE 的根，输出 B，走向左子树 D
• D 是 DHI 的跟，输出 D，走向左子树 H
• H 本身就是根，没有左右子树
• DHI 的根和左子树输出完了，接着输出右子树 I
• I 本身就是根，没有左右子树
• DHI 的根和左右子树都输出完了，接着输出 BDE
• BDE 的根 B 输出了、D 左子树也输出了，所以输出右子树 E
• E 是 EJ 的根，输出 E，走向左子树，结果没有，走向右子树 J
• J 本身就是根，没有左右子树
• BDE 全部输出完了，ABC 已经输出了根 A，左子树 B，开始输出右子树 C
• C 是 CFG 的根，输出 C，走向左子树 F
• F 是 FK 的根，输出 F，走向左子树，结果没有，走向右子树 K
• K 本身就是跟，没有左右子树
• FK 都输出完了，CFG 的 C 根已经输出了，F 左子树也输出了，开始输出 G
• G 本身就是根，没有左右子树
• 全部输出完毕
• 答案是 ABDHIEJCFKG

中序遍历

如果二叉树为空，则返回，否则

• 从根结点开始，并不是输出根节点，而是从根结点开始，根据一下规则
• 先中序遍历左子树
• 接着访问根节点
• 最后中序遍历右子树

遍历的技巧

• 每个结点都看成一个根
• 先放问左子树，如果坐子树还有左子树
• 那就把它当成根，继续向下
• 按照左子树、根、右子树顺序遍历

上面的答案是
HDIBEJAFKCG

超详细解答

• B 是 ABC 的左子树， 访问 B
• D 是 BDE 的左子树，访问 D
• H 是 DHI 的左子树，本身就是根，直接输出 H，然后访问根 D
• D 是 DHI 的根，已经输出了左子树 H，接着输出根 D，然后访问右子树 I
• I 是 DHI 的右子树，本身就是根，直接输出 I，然后 BDE 的左子树和根都输出了
• E 是 BDE 的右子树，E 是 EJ 的根，EJ 没有左子树，输出 EJ 的根 E
• J 是 EJ 的右子树，左子树没有，根已经输出了，输出右子树 J
• A 是 ABC 的根，左子树 B 已经全部输出，接着输出根 A，访问右子树 C
• F 是 CFG 的左子树，F 是 FK 的根
• F 是 FK 的跟，FK 没有左子树，输出根 F
• K 是 FK 的右子树，FK 没有左子树，根已经输出，输出右子树 K
• C 是 CFG 的根，左子树 F 已经全部输出，输出根 C
• G 是 CFG 的右子树，本身就是根，没有左右子树，直接输出
• 全部输出完毕
  • 答案是 HDIBEJAFKCG

1秒解题小技巧
想想一根垂直的线在树的左侧
从左向右扫描，扫到谁就输出谁

后序遍历

如果二叉树为空，则返回，否则

• 从左到右，先叶子后结点
• 遍历左右子树
• 最后访问根节点

上面的答案是
HIDJEBKFGCA

超详细解答

• 先找到最左侧的叶子 H 输出
• H 是 DHI 的左子树，接着输出右子树 I
• D 是 DHI 的根，左子树、右子树都输出了，接着输出根 D
• D 是 BDE 的左子树，接着找到 E，E 是结点，向下找
• J 是 EJ 的根，EJ 没有左子树，所以输出右子树 J
• E 是 EJ 的根，EJ 没有左子树，右子树 J 已经输出，现在输出根 E
• B 是 BED 的根，D左子树 和 E右子树都已经输出，现在输出根 B
• C 是 ABC 的右子树，右子树 C 是 CFG 的根，左子树是 F
• F 是 FK 的根，FK 没有左子树，输出右子树 K
• F 是 FK 的跟，FK 没有左子树，右子树 K 已经 输出，现在输出根 F
• F 是 CFG 的左子树，开始输出右子树 G
• G 本身就是根，没有左右子树，直接输出 G
• C 是 CFG 的根，左子树 F 已经输出，G 右子树也已经输出，现在输出 C
• A 是 ABC 的根，左子树 B 和右子树 C 都已经输出，现在开始输出根 A
  • 全部输出完毕
  • 答案是 HIDJEBKFGCA

层序便利

如果二叉树为空，则返回，否则

• 从第一层，也就是树的根节点开始
• 从上到下，从左到右
• 按照顺序对结点进行访问

上面的答案是
ABCDEFGHIJK

这个不用讲了，最简单了！

总结

• 前序：根左右
• 中序：左根有
• 后续：左右根

就是根在不同的位置，进行不同的遍历。
遍历的不同方式决定你如何使用树中的各个结点，我们下节课再见。

尾巴

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

引入

前面，我们学习了二叉树的五大特性，那么既然说了这么久的二叉树，是时候讲一讲二叉树的数据结构该如何定义了。

回顾

如果你忘了之前的内容，点击下面的链接回顾：
数据结构之树-树的存储结构（一）-学习笔记-47
数据结构之树-树的存储结构（二）-学习笔记-47

思考

根据我们之前讨论树的存储结构，我们可以直到，树和结点里面包含的元素可以很灵活，我们甚至可以将链式存储结构跟顺序存储结构结合在一起使用。因为这样表达树这个数据结构才方便。但是

• 二叉树是一种特殊的树，由于它的特殊性，使得
• 顺序存储结构和链式存储结构都可以轻松的实现二叉树

二叉树的顺序存储结构

二叉树的顺序存储结构就是利用一维数组

• 数组中存放二叉树的各个结点
• 各个结点的存储位置能体现结点之间的逻辑关系

上面的图中是一棵完全二叉树，我们将它存放进一维数组

我们发现，使用层序法排列的完全二叉树

• 元素是 ABCDEFG
• 下标是 1234567
• 完美！（下标0存储的是结点个数）
• 我们完全可以通过上面的一维数组，使用层序法，重新画出这课二叉树。

我们在看一下这张图，图中并不是完全二叉树，更不是满二叉树

• 如果遇到空结点，我们使用^，代替即可

还记得斜二叉树嘛？

它的存储可能会是

这里我们就发现不对了！

• 数组长度有8个
• 因为是斜树，浪费了一半多的存储空间
• 所以，顺序存储结构之后，链式存储应运而生。

二叉树的链式存储结构

在说明链式存储结构前，我们先想象，如果是链式结构

• 一个存数据，两个存左子树和右子树最棒了
• 我们称这样的链表，叫做二叉链表。

struct BTNode{
int data;  //存放数据
struct BTNode *Lchild;  //存放左子树结点位置
struct BTNode *Rchild;  //存放右子树结点位置
};

如图所示，我们就可以使用链表构建一棵树了，非常简单！
我们之后基本上都是用链式存储结构构建二叉树。

尾巴

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

引入

我们上节课我们讲了三条性质，从层数、层节点数、深度、总结点数、以及度的概念了解了二叉树的一些有趣的性质，今天我们继续看看，二叉树还有什么有趣的特性。

从节点数判断深度，从深度判断节点数

预习一下取整符号：

• $\left \lfloor 这是向下取整符号 \right \rfloor$
• $\left \lfloor 2.4 \right \rfloor=2$ 向下取整到2
• $\left \lceil 2.4 \right \rceil=3$ 向上取整到3

具有 n 个结点的完全二叉树的深度 K 为$\left \lfloor \log_{2}n \right \rfloor+1$

• n 表示完全二叉数的结点数，上面的图中 n=5
• 上图的完全二叉树的深度为：$\left \lfloor \log_{2}5 \right \rfloor+1$
• $2^n=5$然后 n 再加 1。
• $n \approx 2.3$，再加上向下取整$\left \lfloor 2.3 \right \rfloor=2$
• 得到$2+1=3$，这棵完全二叉树有 3 层

我们再看看满二叉树如何通过结点数判断深度

• 之前我们直到深度为 k 的满二叉树的节点数为$n=2^{k}-1$个。
• 我们倒推一下$n=2^{k}-1$，得到满二叉树的深度为 $k=\log_2(n+1)$。

还记得完全二叉树的叶子吗？只会出现在最下面两层，所以我们可以推出

• 完全二叉树的倒数第二层一定是满二叉树，就像上面的图。
• 如果完全二叉树的倒数第二层没有满，就开始最后一层的内容，肯定就不是完全二叉树了，所以
• 完全二叉树的倒数第二层一定是满二叉树，完全二叉树倒数第二层的满二叉树的结点数为$n=2^{(k-1)}-1$。上图的计算就是
• $n=2^{3-1}-1=3$，所以倒数第二层的回推总点数为 3

综上，我们知道了

• 完全二叉树倒数第二层满二叉树的最大节点数，$n=2^{(k-1)}-1$
• 完全二叉树深度为 k 的最大结点树为$n=2^{k}-1$
• 所以，完全二叉树结点 n 的取值范围是：$2^{(k-1)}-1 < n \leq 2^{k}-1$
• 所以，$2^{(k-1)} < n \leq 2^{k}$
• 左右取对数，$k-1 \leq log_2n < k$
• k 也要取整，具有 n 个结点的完全二叉树的深度 K 为$\left \lfloor \log_{2}n \right \rfloor+1$

按层序编号的完全二叉树的一些性质

如果有一个 n 个结点的完全二叉树

• 深度为 $\left \lfloor \log_{2}n \right \rfloor+1$ 的结点按层序编号
• 对于任一结点 i ($1 \leq i \leq n$)
• 对于上面的这棵完全二叉树，都有一下性质成立

结点 i 的序号

• 如果 i=1 , 则结点 i 是二叉树的根，根无双亲。
• 如果 i>1，则双亲是结点$\left \lfloor\frac{i}{2} \right \rfloor $
• 例如 i=4，双亲结点是$\left \lfloor\frac{4}{2} \right \rfloor =2$
• 例如 i=3，双亲结点是$\left \lfloor\frac{3}{2} \right \rfloor =\left \lfloor 1.5 \right \rfloor=1$
• 如果2i>n，并且结点 i 为叶子结点，则结点 i 没有左孩子
• 例如i=3，$ 2 \times 3=6 > 5$，结点 3 并有左孩子
• 结点 i 的左孩子是 2i
• 例如i=2，$ 2 \times 2=4 $，结点 2 左孩子为4
• 如果2i+1>n，则结点 i 没有右孩子
• 例如i=3，$ 2 \times 3=6 $，结点 3 没有右孩子
• 结点 i 的右孩子都是 2i+1

尾巴

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

引入

我们介绍了树，介绍了树中使用最多的二叉树，以及一些特殊的二叉树。今天我们就来看看二叉树为什么很好的体现了树的特性，二叉树有哪些有趣的特点呢？

每一层最大的节点数

• 在二叉树的第 i 层，至多有$2^{i-1} (i \geq 1)$ 个结点
• 上面这张图中
• 第一层$2^0=1$个结点
• 第二层$2^1=2$个结点
• 第三层$2^2=4$个结点
• 第四层$2^3=8$个结点

从深度判断节点数

• 深度为 k 的二叉树，至多有$2^{k}-1 (k \geq 1)$ 个结点。
• 也就是 K 层二叉树，满了也就是$2^{k}-1 (k \geq 1)$ 个结点。
• 一层$2^1-1=1$个结点
• 二层$2^2-1=3$个结点
• 三层$2^3-1=7$个结点
• 四层$2^4-1=15$个结点

树中度的关系

我们先回顾一下度的概念

• 度是每个结点包含的孩子数
• 度为2表示这个结点既有左子树，也有右子树
• 度为1表示这个结点可能只有左子树、或者只有右子树
• 度为0表示这个结点没有孩子，也称之为终端结点

上面的二叉树中

• 度为2：A、C 和 D，共3个，记作 n2
• 度为1：B、H 、E，共3个，记作 n1
• 度为0：G、J、I、F，共4个，记作 n0
• 结点的总数就是n2+n1+n0=3+3+4=10个结点

我们又发现

• 结点和结点之间的连接数，也就是那条黑线，总是为总节点数-1
• 并且这个总节点数-1总是等于 $n1+2\times n^{2}$
• 所以$n-1=n1+2\times n2$
• 所以$n0+n1+n2-1=n1+n2+n2$
• 所以$n0=n2+1$
• 所以，度为0的结点数等于度为2的结点数+1

尾巴

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

引入

我们介绍了什么是二叉树、以及二叉树一些与众不同的特点，例如只能有两个孩子，两个孩子还分为左子树和右子树，那么今天我们来看看特殊的二叉树。

斜树

¡¡™
顾名思义，斜树一定要倾斜。也就是说，一棵树

• 只有左子树
• 只有右子树

这样就不是斜树了。

满二叉树

如果有一棵树

• 所有分支的结点
• 都存在左子树和右子树
• 并且所有叶子都在同一层上
• 我们就称之为满二叉树

满二叉树的特点

• 叶子只能出现在最下一层，如果最下一层不是叶子，那证明所有叶子并不是在同一层上，不符合满二叉树条件
• 非叶子结点的度一定是 2，度是每个结点的子树数量，既然是二叉树，不是叶子结点度一定是2
• 在同样深度的二叉树中，满二叉树的结点一定最多，这基本是废话，层数相同，满二叉树的每个结点都有左子树和右子树，结点一定是满二叉树最多。

完全二叉树

如果存在一棵树

• 具有 n 个结点的二叉树按层序编号。
• 编号为 i ($1 \leq i \leq n$) 的结点，与同样深度的满二叉树中的 i 结点
• 如果 i 和 i 位置完全相同，我们就称这棵二叉树为完全二叉树

我们来看看

你可以这么理解

• 完全二叉树的结点可能不如满二叉树多
• 但是完全二叉树的所有结点序号一定能在满二叉树中找到
• 完全二叉树是即将完成的满二叉树…中间『停止施工』了而已…

完全二叉树的特点

• 叶子结点只能出现在最下两层，因为每个结点的编号是一层一层的写，要满足完全二叉树的所有编号跟满二叉树编号相同，必然不能突破两层，因为超过两层，第三层的哪几个结点的序号，肯定就找不到了。
• 最下层的叶子一定集中在左侧连续位置，必须的啊，因为新的一层是从左向右编号，也在一定是在左侧连续位置啊，右边还没编号呢…
• 倒数第二层，如果有叶子结点，一定都在右部连续位置，也是必须的啊，倒数第二层的叶子，肯定是最后一层叶子没占的那些地方啊！
• 如果结点的度为1，那该结点只有左孩子，也是废话，从左向右编号，结点只有1个孩子，那肯定是左孩子啊….
• 同样结点的二叉树，完全二叉树深度最小，必须的啊，深度是层数，完全二叉树必须补完一层再来下一层，肯定是完全二叉树深度最小。

**注意：**满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。

一些反例

尾巴

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