努力的clz

王道数据结构课代表 - 考研数据结构第六章图究极精华总结笔记

本篇博客是考研期间学习王道课程 传送门 的笔记，以及一整年里对数据结构知识点的理解的总结。希望对新一届的计算机考研人提供帮助！！！

关于对 图 章节知识点总结的十分全面，涵括了《王道数据结构》课程里的全部要点（本人来来回回过了三遍视频），其中还陆陆续续补充了许多内容，所以读者可以相信本篇博客对于考研数据结构“图”章节知识点的正确性与全面性；
但如果还有自主命题的学校，还需额外读者自行再观看对应学校的自主命题材料。

数据结构与算法 笔记导航

第一章绪论(无)

第二章线性表

第三章栈和队列

第四章串-KMP(看毛片算法)

第五章树和二叉树

第六章图 ⇦当前位置

第七章查找(B树、散列表)

第八章排序 (内部排序：八大排序动图演示与实现 + 外部排序)

数据结构与算法复试精简笔记 (未完成)

408 全套初复试笔记汇总传送门 ‍‍‍

如果本篇文章对大家起到帮助的话，跪求各位帅哥美女们，求赞、求收藏、求关注！
你必考上研究生！我说的，耶稣来了也拦不住！

精准控时：
如果不实际操作代码，只是粗略过一下知识点，需花费 80 分钟左右过一遍
这个80分钟是我在后期冲刺复习多次尝试的时间，可以让我很好的在后期时间紧张的阶段下，合理分配复习时间；
但是刚开始看这份博客的读者也许会因为知识点陌生、笔记结构不太了解，花费许多时间，这都是正常的。
重点！！！学习一定要多总结多复习！重复、重复、再重复！！！

食用说明书：
第一遍学习王道课程时，我的笔记只有标题和截图，后来复习发现看只看图片，并不能很快的了解截图中要重点表达的知识点。
所以再第二遍复习中，我给每一张截图中标记了重点，以及每张图片上方总结了该图片对应的知识点以及自己的思考。
最后第三遍，查漏补缺。
所以，我把目录放在博客的前面，就是希望读者可以结合目录结构去更好的学习知识点，之后冲刺复习阶段脑海里可以浮现出该知识结构，做到对每一个知识点熟稔于心！
请读者放心！目录展示的知识点结构是十分合理的，可以放心使用该结构去记忆学习！
注意(⊙o⊙)！，每张图片上面的文字，都是该图对应的知识点总结，方便读者更快理解图片内容。

第6章图

文章目录

第6章图

@[toc]

6.1 图的基本概念

6.1.1 基本概念

1.无向图和有向图

2.简单图、多重图

3.顶点的度、入度、出度

4.顶点-顶点的关系描述

5.连通图、强连通图

6.子图、生成子图

7.连通分量、强连通分量 - 极大连通

8.生成树、生成森林 - 极小连通

9.边的权、带权图/网

6.1.2 几种特殊的图

1.无向完全图和有向完全图

2.稀疏图和稠密图

3.树

6.1.3 小结

6.2 图的存储以及基本操作 P218

6.2.1 邻接矩阵(Adjacency Matrix)

1.算法思想

2.代码实现

3.性能分析 - 优缺点

4.邻接矩阵的性质

5.小结

6.2.2 邻接表(Adjacency List)

1.算法思想

2.代码实现

3.性能分析 - 优缺点

4.邻接矩阵对比邻接表

5.小结

6.2.3 十字链表(Orthogonal List)

1.算法思想

2.代码实现

3.性能分析

6.2.4 邻接多重表

1.算法思想

2.性能分析

3.代码实现

4.十字链表和邻接多重表小结

6.2.5 图的基本操作

1.Adjacent

2.Neighbors

3.InsertVertex

4.DeleteVertex

5.AddEdge

6.RemoveEdge

7.FirstNeighbor

8.NextNeighbor

9.其它

10.小结

6.3 图的遍历

6.3.1 广度优先搜索

1.算法思想

2.代码实现

3.性能分析

4.广度优先生成树

5.小结

6.3.2 深度优先搜索

1.算法思想

2.代码实现

3.性能分析

4.练习

5.深度优先生成树、生成森林

6.小结

6.3.3 图的遍历和图的连通性

1.无向图情况

2.有向图情况

6.4 图的应用

6.4.1 最小生成树

1.定义

2.Prim算法

1）算法思想

2）性能分析

3）代码实现

3.Kruskal算法

1）算法实现

2）性能分析

3）代码实现

4.Prim和Kruskal小结

6.4.2 最短路径

1.概念

2.BFS算法

1）算法思想

2）代码实现

3）小结

3.Dijkstra算法

1）算法思想

2）性能分析

4.Floyd算法

1）算法思想

2）性能分析

3）代码实现

4）举例练习

5）小结

6.4.3 有向无环图描述表达式

1.有向无环图（DAG）

2.DAG描述表达式

3.构造DAG有向无环图

4.练习

6.4.4 拓扑排序

1.AOV网

2.拓扑排序

3.求拓扑排序算法思想

4.代码实现

5.性能分析

6.逆拓扑序列

7.小结

6.4.5 关键路径

1.AOE网

2.事件最早发生时间ve(k)

3、事件最迟发生时间vl(k)

4、活动最早开始时间e(i)

5、活动最迟开始时间l(i)

6、差额——时间余量

7.求关键路径算法思想

8.关键活动、关键路径的特性

9.具体代码实现（未全部实现）

10.小结

6.1 图的基本概念

6.1.1 基本概念

图G就是由 点集V 和 边集E 组成的。
点集不可以为空，边集可以为空。（一条边的两个点不能有一个为空）
图不可以是空图

1.无向图和有向图

弧尾、弧头
有向边，无向边(A, B)

2.简单图、多重图

简单图：不存在重复的边
多重图：存在重复的边

3.顶点的度、入度、出度

无向图
- 顶点的度
有向图
- 入度
- 出度
- 顶点的度 = 入度 + 出度

4.顶点-顶点的关系描述

路径：p --> … --> q
回路（环）：特殊的路径（p --> … --> p）
简单路径：顶点不重复出现
简单回路：除了头顶点和尾顶点，其余顶点里不出现重复的顶点
路径长度：边的数目
点到点的距离：点到点的最短路径
连通性：无向图中，v — …— w （v，w之间是连通的）
强连通性：有向图中，既有v --> … --> w ，又有v <-- … <-- w，（v，w之间是强连通的）

5.连通图、强连通图

连通图：在无向图中，任意两个点连通
强连通图：在有向图中，任意两个点强连通
注意！强连通是指路径，并不是两点之间有直接相连来、回的箭头

注意！！！

无向图中，连通图的最少边数，非连通图的最多边数
有向图中，强连通的最少边数
下面图里非连通图的最多便没有-1，写错了！！！

6.子图、生成子图

注意！子图虽然是 部分点集+部分边集，但是这些边、点都不是随便选的，一定要保证边的两个点存在
生成子图：子图包含原图的所有顶点，可以去掉一些边

无向图的子图

7.连通分量、强连通分量 - 极大连通

连通分量：在无向图中，极大的连通子图
- 1、子图
- 2、子图是连通的
- 3、极大：包含尽可能多的边和点

强连通分量：在有向图中，极大的强连通子图
注意对极大概念的体会

8.生成树、生成森林 - 极小连通

生成树：对于连通图，包含图中所有顶点的极小连通子图
- 1、针对于连通图，没有强连通图
- 2、所有顶点
- 3、极小连通子图（目前理解，保证在所有顶点和连通的前提之下，尽可能少边）
- 注意和生成子图做区别，生成子图只需要有全部顶点，而生成树还需要极小边
对于一个连通图的生成树不唯一

生成森林：对于非连通图，各连通分量的生成树组成了生成森林

9.边的权、带权图/网

权值：边的权
带权路径长度：路径上所有边的权值之和

6.1.2 几种特殊的图

1.无向完全图和有向完全图

完全图：任意两个点之间存在直接连通的边
无向完全图：有n(n-1)/2条边
有向完全图：有n(n-1)条边

2.稀疏图和稠密图

稀疏图

e < nlogn
稠密图

3.树

树：极小连通图，极大无环图。少一条边就不连通，多一条边就出现环
n个顶点的树，其边数是n-1
所以，连通图要想存在回路，边的数目要大于n-1
注意！！！树是连通图，有向树不保证是强连通图

6.1.3 小结

6.2 图的存储以及基本操作 P218

6.2.1 邻接矩阵(Adjacency Matrix)

1.算法思想

思考
1）计算顶点的度、入度、出度？
2）查找与顶点相连的边？

当使用邻接矩阵存储带权图时，需要注意的点！

2.代码实现

1）王道代码

// 邻接矩阵法
#define MAX_VERTEX_NUMBER 100 // 顶点数目的最大值

typedef struct
{
  char vexter[MAX_VERTEX_NUMBER];         // 顶点表
  int edge[MAX_VERTEX_NUMBER][MAX_VERTEX_NUMBER]; // 边表
  int vexNum, arcNum;               // 图的当前 顶点数 和 边数
} MGraph;

2）严蔚敏代码

#define VERTEX_MAX_SIZE 100 // 最大顶点数
#define MAXINIT 1024        // 表示最大值

typedef char VertexType; // 顶点的数据类型，假设为char
typedef int ArcType;     // 边的数据类型，假设为int(权值)

typedef struct
{
    VertexType vers[VERTEX_MAX_SIZE];               // 顶点表
    ArcType arcs[VERTEX_MAX_SIZE][VERTEX_MAX_SIZE]; // 邻接矩阵
    int verNum, arcNum;                             // 图当前的顶点数和边数
} AMGraph;

// 确定顶点ver在图G的顶点表中的位置
int LocateVex(AMGraph G, VertexType ver)
{
    for (int i = 0; i < G.verNum; i++)
    {
        if (G.vers[i] == ver)
        {
            return i;
        }
    }
    return -1; // ver不存在，返回-1
}

// 采用邻接矩阵创建图，该算法时间复杂度O(n^2)
bool CreateUDN(AMGraph &G)
{
    int i, j, info, rows, columns;
    VertexType v1, v2;
    cin >> G.verNum >> G.arcNum; // 输入总顶点数、总边数
    for (i = 0; i < G.verNum; i++)
    {
        cin >> G.vers[i]; // 依次输入顶点的信息
    }
    memset(G.arcs, MAXINIT, sizeof(G.arcs));
    for (j = 0; j < G.arcNum; j++) // 构造邻接矩阵
    {
        cin >> v1 >> v2 >> info; // 输入一条边依附的顶点以及权值
        rows = LocateVex(G, v1); // 确定v1、v2的位置
        columns = LocateVex(G, v2);
        G.arcs[rows][columns] = info;
        G.arcs[columns][rows] = info;
    }
    return true;
}

以上两个版本，大差不差。严蔚敏的版本多了创建的操作。

3.性能分析 - 优缺点

空间复杂度：O（n）顶点表 + O（n^2）边表 = O（n^2）

邻接矩阵	优点	缺点
1	判断两个顶点之间是否有边很方便	增加、删除顶点不方便
2	计算各点的度很方便	统计边的数量不方便
3		空间复杂度高，导致只适合存储稠密图

4.邻接矩阵的性质

分析下图红框的式子：
a[1] [2] * a[2] [4] :
- ① a[1] [2]等于1，说明A到B存在边
- ② a[2] [4]等于1，说明B到D存在边
- ③ 所以乘积等于1，说明A到D之间存在路径，A–>B–>D
- 注意A^n里的n的含义，代表路径长度

5.小结

6.2.2 邻接表(Adjacency List)

上一节提到的邻接矩阵法，空间复杂度高，不适合存储稀疏图
邻接表是图的一种链式存储结构，适用存储稀疏图

1.算法思想

顺序存储点，链式存储边（顺点链边）
**易混淆点！**虽然说是链式存储边，但是上面的边结构体里，只设置了一个顶点（端点），并不能很好的表示一条边
所以才和下面提到 “树的孩子表示法” 相似
这也造就了邻接表法存储无向图时，存储了冗余数据的缺陷，因为边结点不能很好的表示一条完整的边，故只能是私有的，无法共享（这几句话看不懂的话，等学习完邻接多重表再回来对比，就明白了）

2.代码实现

1）王道代码

// ? 邻接表法
#define MAX_VERTEX_NUMBER 100

// ! 弧
typedef struct ArcNode
{
  int adjvex;      // 弧指向哪个结点
  struct ArcNode *next; // 指向下一条弧的指针
} ArcNode;

// ! 邻接表的顶点
typedef struct VNode
{
  char data;   // 顶点的信息
  ArcNode *first; // 第一条弧
} VNode, AdjList[MAX_VERTEX_NUMBER];

// ! 使用邻接表存储的图
typedef struct
{
  AdjList vertices;
  int verNum, arcNum;
} ALGraph;

2）严蔚敏代码

CreateUDN()函数的时间复杂度O(n^2)

3.性能分析 - 优缺点

正是上面提到的边结构体里只有一个点属性，所以在存储无向图时，多存储了一份边的数据（缺点1）
无向图：
- ① 空间复杂度：O（|V| + 2|E|）
- ② 找顶点的度：遍历该顶点的边链即可
有向图：
- ① 空间复杂度：O（|V| + |E|）
- ② 出度：遍历该顶点的边链即可
- ③ 入度（很麻烦）：遍历所有结点的边链（缺点2）

邻接表法里的边链的结点顺序不是唯一的（缺点3）

4.邻接矩阵对比邻接表

邻接矩阵	优点	缺点
1	判断两个顶点之间是否有边很方便	增加、删除顶点不方便
2	计算各点的度很方便	统计边的数量不方便O(n^2)
3		空间复杂度高，导致只适合存储稠密图O(n^2)

邻接表法	缺点	优点
1	判断顶点之间是否有边不方便	增加、删除顶点很方便
2	计算点的入度不方便	统计边的数目方便O(n+e)
3	结点的链表顺序不唯一	空间效率高，适用于稀疏图O(n+e)
4	无向图多了一份边的冗余数据

5.小结

6.2.3 十字链表(Orthogonal List)

1.算法思想

1）之前两种存储方法的不足

2）十字链表法能够解决计算入度麻烦的不足
十字链表是有向图的另一种链式存储结构。可以看成是将有向图的邻接表和逆邻接表结合起来得到的一种链表

上图看不懂，可以看下代码，核心就是十字链表法的 “顶点和弧” 的结构都有了改变
顶点有了对入边和出边的分类
弧不仅设置两个顶点（两顶点不同）表示边，而且表示的是有向边。还有两个不同的弧结点指针
这样的设计就使得边达到了共享的效果，多个顶点可以指向同一条边，消除了邻接表里冗余数据的问题
所以，正是由于这样的点和弧的结构设计，使得十字链表法只适用于有向图

2.代码实现

1）王道代码

// ? 十字链表法
#define MAX_VERTEX_NUMBER 100

// ! 弧结点
typedef struct OLNode
{
  int headVex;     // 弧头顶点编号
  int tailVex;     // 弧尾顶点编号
  int info;        // 权值
  struct OLNode *hLink; // 弧头顶点相同的下一条弧
  struct OLNode *tLink; // 弧尾顶点相同的下一条弧
} OLNode;

// ! 十字链表的顶点
typedef struct VexNode
{
  char data;		// 顶点的信息
  OLNode *firstIn;	// 第一条以该顶点为弧头的弧
  OLNode *firstOut;	// 第一条以该顶点为弧尾的弧
} VexNode, CrossList[MAX_VERTEX_NUMBER];

// ! 使用邻接表存储的图
typedef struct
{
  CrossList vertices;
  int verNum, arcNum;
} OLGraph;

2）严蔚敏代码

建立十字链表的时间复杂度和建立邻接表的时间复杂度相同

3.性能分析

空间复杂度：顶点表 + 弧结点链，O（|V| + |E|）
邻接表法的入度问题：遍历hLink指针即可

6.2.4 邻接多重表

1.算法思想

1）对无向图的存储是否有更优的方案呢？

如果使用上面的三种方式存储无向图，会出现一下这些问题：
1、邻接矩阵法：空间复杂度高
2、邻接表法：
- 存储了冗余数据（两份边）
- 删除顶点、边等操作，时间复杂度高（有冗余数据）
3、十字链表法：只适用于有向图

2）邻接多重表存储无向图

邻接多重表是无向图的另一种链式存储结构
看了代码和下面截图，你会发现邻接多重表不就是十字链表的盗版吗？直接把有向图版本改成无向图版本就是了
顶点结点：不分入边和出边了，就一个弧结点
弧结点：不分头结点和尾结点了，倒是两个弧结点指针还在
下图中的弧（0, 1），因为是无向图，所以用（1, 0）表示也是可以的

删除一条边

2.性能分析

邻接多重表只适用于存储无向图
空间夫复杂度：O（|V| + |E|），没有冗余数据了
删除边、点变得很方便了

3.代码实现

1）王道代码

// ? 邻接多重表
#define MAX_VERTEX_NUMBER 100

// ! 弧结点
typedef struct ArcNode
{
  int iVex, jVex;        // 弧的两个点
  int info;           // 权值
  struct ArcNode *iLink, *jLink; // 依附各自顶点的下一条边
} ArcNode;

// ! 邻接多重表的顶点
typedef struct VexNode
{
  char data;     // 顶点的信息
  ArcNode *firstEdge; // 与该顶点相连的第一条边
} VexNode, AdjList[MAX_VERTEX_NUMBER];

// ! 使用邻接表存储的图
typedef struct
{
  AdjList vertices; // 存储图中顶点的数组
  int verNum, arcNum;
} AMLGraph;

4.十字链表和邻接多重表小结

十字链表和邻接多重表考察代码频率较低

6.2.5 图的基本操作

因为考研中基本是考察邻接矩阵和邻接表两种存储结构，所以在本小节中也是讨论这两种结构的情况

1.Adjacent

// 判断图G是否存在边或(x,y)
bool Adjacent(Graph g, int x, int y)

// 邻接矩阵：O(1)
return (a[x][y]!=0);	// 不为空，存在边

// 邻接表法
// 最好情况：遍历第一条边就找到了
故时间复杂度：O(1) 

// 最坏情况，遍历到最后一条边也没找到，因为顶点只能连接n-1条边，也就是|V|-1条边
故时间复杂度：O(|V|)

2.Neighbors

// 列出图G中与结点x邻接的边
int Neighbors(Graph g, int x)

// 邻接矩阵
遍历 x行 或者 x列，总数之和
    
// 邻接矩阵
// 出边情况
	O(1): 0或者O(1)条边
	o(|V|): 连接了|V|-1条边
// 入边情况
    O(|E|): 遍历所有的边结点

3.InsertVertex

// 在图G中插入顶点x
bool InsertVertex(Graph g, char x)
    
// 邻接矩阵
	二维数组的赋0操作在初始化数组的时候就已经完成
    故只需要对顶点数组的相应位置进行赋值操作即可 O(1)

// 邻接表
    在顶点数组的相应位置进行赋值操作即可 O(1)

4.DeleteVertex

// 在图G中删除顶点x
bool DeleteVertex(Graph g, int x)

// 邻接矩阵 O(|V|)
    1、看下图中标红的0，在删除顶点表、边表之后，如果把后面元素前移，那么就会有大量的元素移动，开销太大
    2、所以直接将两个表的对应位置赋0，在在顶点结构体里设置一个bool的变量，判断此处是否为空位置
    
// 邻接表法
// 无向图
    1、该结点的first指针为空，不存在与它向连的边 O(1)
    2、遍历x结点的结点链发现有|V|-1条，就是说和每一个顶点它都相连了，这时就需要遍历所有结点的结点链（去删除冗余边）
    最坏的情况：在遍历所有顶点的结点链的过程，和x相连的弧结点每次都在最后被找到，时间复杂度 O(|E|)
// 有向图
// 出边
    遍历x顶点的弧结点链即可 O(1)~O(|V|)，x最多连接|V|-1条边
// 入边
    遍历所有边 O(|E|)

5.AddEdge

修改矩阵对应位置的值即可 O（1）
弧结点链采用头插法即可O（1），无向边插入两次（冗余数据）

6.RemoveEdge

7.FirstNeighbor

邻接表 - 找出边邻接点
遍历第一个结点的第一个弧结点就找到了 O（1）
遍历完所有边 O（|E|）

8.NextNeighbor

9.其它

10.小结

6.3 图的遍历

6.3.1 广度优先搜索

1.算法思想

2.代码实现

因为邻接表法的表示法不唯一，这就造成了遍历序列可能也不唯一

存在问题：如果是非连通图，就无法一次遍历完所有结点。图中存在几个连通分量，就需要调用几次BFS算法
下图中红框标出的代码区就是改进： 加一个循环for
下图的代码是王道书里的版本，从0开始遍历，图中的例子又是从1开始，注意别错了

3.性能分析

1）空间复杂度源于辅助队列的大小

2）算法时间的主要开销主要来自于：
1、访问各个顶点
2、探索各条边
邻接矩阵法的时间复杂度：O（|V|）+ O（|V|^2）= O（|V|^2）

4.广度优先生成树

邻接表存储的图，对应的广度优先生成树不唯一

5.小结

6.3.2 深度优先搜索

1.算法思想

1）对比树的深度优先遍历

2）图的遍历，新找到的相邻结点不能保证没有被访问过，所以需要设置一个辅助数组visited[]

3）算法存在的问题

2.代码实现

3.性能分析

1）题目没明确要求，空间复杂度默认采用最坏情况

2）深度优先和广度优先情况类似，自己回顾

4.练习

邻接矩阵不唯一，深度优先遍历序列也不唯一

5.深度优先生成树、生成森林

1）深度优先生成树

2）深度优先生成森林

6.小结

6.3.3 图的遍历和图的连通性

1.无向图情况

2.有向图情况

6.4 图的应用

6.4.1 最小生成树

1.定义

最小生成树：对于一个带权连通无向图，在其所有的生成树中，边的权值之和最小的生成树 = 最小代价生成树

最小生成树不唯一（形态不同，权值和相同）
最小生成树 = 最大连通无环图，边数 = 顶点数 - 1；多一条回路，少一条不连通

连通图 --> 生成树
非连通图 --> 生成森林

2.Prim算法

Prim算法的执行过程十分类似于寻找图的最短路径的Dijkstra算法（见下节）

1）算法思想

举例介绍

得到两个生成树，都符合条件，故生成树不唯一

下面开始正式介绍算法的思想过程

需要使用到的数组数组：isJoin标记数组、lowCost最小代价数组
并不要求从v0开始，只是从v0开始方便介绍算法过程

加入新顶点，更新辅助数组
① 第一轮

② 第二轮

③ 第三轮

④ 第四轮

⑤ 第五轮

2）性能分析

下图中对时间复杂度的解释十分清楚，结合下面的代码应该能理解
Prim的时间复杂度为O(n^2)，不依赖于|E|
由上面时间复杂度可知它适用于求解边稠密的图的最小生成树

3）代码实现

先总结下代码关键：（牢牢记住三步）

1、加入点

isJoin[i] = true;

2、更新最低代价数组

for (j = 1; j < verNum; j++) // 本循环使用来更新isJoin[],lowCost[]数组信息
{
    if (!isJoin[j])
    {
        if (edge[i][j] < lowCost[j])
        {
            lowCost[j] = edge[i][j];
        }
    }
}

3、查找下一个要加入的点

// 本循环用来选择加入的新结点
temp = 100;
for (k = 1; k < verNum; k++)
{
    if (!isJoin[k])
    {
        if (lowCost[k] < temp)
        {
            temp = lowCost[k];
            i = k; // ! 这一步就很妙，下一轮更新数据全靠i
            // i记录下一个要加入的新结点
        }
    }
}
cout << lowCost[i] << " "; // 每轮循环输出加入的边的代价
flag++;	// 每轮循环结束，代表有一个新结点加入

完整代码（王道）

#include 
using namespace std;

#define MAX_SIZE 16
int ver, arc;         // 输入的点数、边数
int edge[MAX_SIZE][MAX_SIZE]; // 邻接矩阵法

void PrimAlgorithm(int edge[MAX_SIZE][MAX_SIZE], int verNum)
{
  bool isJoin[MAX_SIZE]; // ! 记录各结点是否已加入
  int lowCost[MAX_SIZE]; // ! 记录 未加入结点 加入 结点集 的最小代价
  
  memset(isJoin, false, sizeof(isJoin));
  memset(lowCost, 100, sizeof(lowCost)); // 将这些数组初始化

  int flag = 1; // 记录已经加入几个点，默认为1，就是初始加入的结点
  int i = 0, j, k, temp;
  lowCost[i] = 0; // ! 可省略
    
  while (flag < verNum)	// (flag == verNum)还循环个头！ 
  {
     isJoin[i] = true;
     for (j = 1; j < verNum; j++) // 本循环使用来更新isJoin[],lowCost[]数组信息
     {
    	if (!isJoin[j])
      	{
	       	 if (edge[i][j] < lowCost[j])
        	{
          		lowCost[j] = edge[i][j];
        	}
       	}
     }

     // 本循环用来选择加入的新结点
     temp = 100;
     for (k = 1; k < verNum; k++)
     {
       if (!isJoin[k])
       {
         if (lowCost[k] < temp)
         {
           temp = lowCost[k];
           i = k; // ! 这一步就很妙，下一轮更新数据全靠i
         }
       }
     }
     cout << lowCost[i] << " "; // 每轮循环输出加入的边的代价
     flag++;
  }
}


int main()
{
  cin >> ver >> arc;
  for (int i = 0; i < ver; i++)
  {
     for (int j = 0; j < ver; j++)
     {
       cin >> edge[i][j];
     }
  }
  PrimAlgorithm(edge, ver);
}

3.Kruskal算法

1）算法实现

举例

下面开始正式介绍算法思想过程

① 各边权值排序

② 第一轮
关于并查集的解释在 3）代码实现 里

③ 第二轮

④ 第三轮

⑤ 第四轮

⑥ 第五轮

⑦ 第六轮

2）性能分析

时间复杂度为O(|E|log|E|)，因此，Kruskal算法适用于边稀疏而顶点较多的图

3）代码实现

并查集是用来判断结点之间是否属于同一个集合

// 实现并查集其实很简单，不需要实现操作，等到加入新边的时候调用就行
FindRoot(int parent[],int s){
   int x = s;
   while(parent[x]>0)
     x = parent[x];
   return x;
}

void kruskal(){
    int num = 1,i,vex1,vex2;
    int parent[520];	// 并查集数组
    memset(parent, 0 , sizeof(parent));	// 初始化parent数组

    for(num = 1,i = 1; num < vertexNum; i++){	// vertexNum已经按权值从小到大排序好了
        vex1 = FindRoot(parent,edge[i].from);
        vex2 = FindRoot(parent,edge[i].to);		// 查找边的两个的老大 
        if(vex1!=vex2){	// 两个老大不同，表示不属于一个集合，说明可以加入新边
            cout<

 
   
  4.Prim和Kruskal小结 
   
   
  6.4.2 最短路径 
  1.概念 
   
   最短路径问题有两大分类： 
   1、单源最短路径 
     
     ① BFS 
     ② Dijkstra 
    
  
   2、各顶点间的最短路径 
     
     ① Floyd 
    
  
   
   
   
  2.BFS算法 
  1）算法思想 
   
   
   对图的广度优先遍历即可得到root顶点到各结点的最短路径长度，树最宽也就导致树最矮 
   path[]数组是为了记录最短路径经过的结点 
   
   
  2）代码实现 
   
   
  3）小结 
   
   
  3.Dijkstra算法 
   
   BFS算法计算最短路径的缺陷：不适用于带权图的计算 
   
   
  1）算法思想 
   
   Dijkstra 
   
   
   
   ① 初始化 
   
   
   
   ② 第一轮 
   
   
   
   ③ 第二轮 
   
   
   
   ④ 第三轮 
   
   
   
   ⑤ 第四轮 
   
   
   
   ⑥ 输出结果 
   
   
   
  2）性能分析 
   
   Dijkstra算法是基于贪心策略 
   邻接矩阵和邻接表的时间复杂度都是O(|V|^2) 
   下面是伪代码 
   n-1轮处理，处理n-1各结点 
   
   
   
   
   Dijkstra算法不适用有负权值的带权图 
   
   
   
  4.Floyd算法 
   
  1）算法思想 
   
   关键思想：每次循环，容许一个新的结点当作中转点；这样各顶点间的最短路径就又更新了 
   
   
   
    ① 初始，中转{}
 
  
    ② 中转{v0}
  
   
   
   
   
   ③ 中转{v0、v1} 
   
   
   
   ④ 中转{v0、v1、v2} 
   
   
   
   
  2）性能分析 
   
   时间复杂度：3层嵌套for循环，O(|V|^3) 
   也可以轮流将每个顶点作为原点，并且在所有边权值均非负时，运行依次Dijkstra算法，O(|V|^2)*|V|=O(|V|3) 
   空间复杂度：两个辅助数组 
   
  3）代码实现 
   
   
  4）举例练习 
  问题 
   
  解 
   
   
   
   
   
   
   
   考试可能让你手写A数组 
   
   
   
  5）小结 
   
   
   
   
  6.4.3 有向无环图描述表达式 
  1.有向无环图（DAG） 
   
   有向无环图（Directed Acyclic Graph）：有向图 + 不存在环 
   
   
   
  2.DAG描述表达式 
   
   出现重复部分，可压缩 
   
   
   
   
   
   最终结果 
   
   
   
  3.构造DAG有向无环图 
   
   
   咸鱼算法 —— 用于构造有向无环图 
   
   
   
   ① 初始构造 
   
   
   
   ② 标明顺序 
   
   
   
   ③ 顺序加入运算符（分层） 
   
   
   
   ④ 检测是否存在重复，合体 
   
   
   
   
   ⑤ 最终结果 
   
   
   
  4.练习 
   
   
   
   由于第二步里设置的运算符顺序不唯一，导致最后的结果图也不同 
   
   
  无小结 
   
  6.4.4 拓扑排序 
  1.AOV网 
   
   AOV：顶点表示活动的网（Activity On Vertex Network） 
   DAG表示一个工程（工程就是活动的顺序序列集合） 
   
   
   
   举个反例 
   
   
   
  2.拓扑排序 
   
   针对有向图，具体定义看下图 
   每个AOV网的拓扑排序序列不唯一 
   
   
   
   
  3.求拓扑排序算法思想 
  步骤总结： 
   
   1、找点入栈（入度为0的点） 
   2、栈顶出栈，对出栈元素操作 
     
     ① 删除该结点和所有以它为起点的有向边 
     ② 修改入度数组、拓扑路线数组 
    
  
   
   
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NVRP89o7-1642514497431)(第6章 图_img/image- 
   
  4.代码实现 
   
   本代码是基于邻接表的实现 
   
   
   
   王道书上代码 
   
   
  #include 
using namespace std;
// ? 已经成功实现 —— 基于邻接表实现
#define MAX_VERTEX_NUM 100
int verNum, arcNum; // 图的顶点数和边数
int x, y;
int inDegree[MAX_VERTEX_NUM]; // 记录顶点入度
int print[MAX_VERTEX_NUM];    // 记录拓扑序列

typedef struct ArcNode // 边链表结点
{
    int adjvex;
    // int info; // 边的权值
    struct ArcNode *nextArc;
} ArcNode;
typedef struct VNode // 顶点表结点
{
    int data;
    ArcNode *firstArc;
} VNode, AdjList[MAX_VERTEX_NUM];
typedef struct
{
    AdjList vertices;   // 邻接表
    int verNum, arcNum; // 图的顶点数和弧数
} Graph;                // Graph是以邻接表存储的图类型

bool TopologicalSort(Graph g)
{
    stack s;                      // 声明辅助栈，用于存储入度为0的顶点
    for (int i = g.verNum; i > 0; i--) // 为了让编号比较小的顶点先出栈 (晚进栈)
    {
        if (inDegree[i] == 0)
        {
            s.push(i); // 将初始所有入度为0的顶点入栈
        }
    }
    int count = 0;     // 计数，记录当前已经输出的顶点数
    while (!s.empty()) // 栈非空，表示还存在入度为0的顶点
    {
        int flag;
        int v;
        ArcNode *p;
        flag = s.top();
        s.pop();               // 栈顶元素出栈
        print[count++] = flag; // 记录输出的顶点
        // 本段循环的目的：由于输出栈顶元素这个操作，所以需要对与栈顶顶点相连的顶点的入度减一
        for (p = g.vertices[flag].firstArc; p != NULL; p = p->nextArc)
        {
            v = p->adjvex;
            if (!(--inDegree[v]))
            {
                s.push(v); // 入度为0，入栈
            }
        }
    }
    if (count < g.verNum)
    {
        return false; // 拓扑排序失败，存在回路
    }
    return true; // 拓扑排序成功
}

int main()
{
    cin >> verNum >> arcNum;
    Graph graph;
    graph.verNum = verNum;
    graph.arcNum = arcNum;
    memset(inDegree, 0, sizeof(inDegree));
    memset(print, -1, sizeof(print));
    for (int i = 1; i <= verNum; i++)
    {
        graph.vertices[i].firstArc = NULL;
    }
    for (int i = 1; i <= arcNum; i++)
    {
        cin >> x >> y;
        inDegree[y]++;
        ArcNode *arc = (ArcNode *)malloc(sizeof(ArcNode));
        arc->adjvex = y;
        arc->nextArc = graph.vertices[x].firstArc;
        graph.vertices[x].firstArc = arc;
    }
    if (TopologicalSort(graph))
    {
        for (int i = 0; i < verNum; i++)
        {
            cout << "v" << print[i] << " ";
        }
    }
    return 0;
}
 
   
  5.性能分析 
   
   邻接表情况的时间复杂度：每个顶点都被处理一次；每条边都被处理一次 O（|V|+|E|） 
   邻接矩阵：O（|V|^2） 
   
   
   
  6.逆拓扑序列 
   
   
   
   还可以借助DFS算法去输出逆拓扑排序序列 
   综合题第九题 
   
   
   
   
  7.小结 
   
   
  6.4.5 关键路径 
  1.AOE网 
   
   Activity On Edge Network，还是有向无环图 
   边代表活动，是一个持续的过程；点代表事件，是瞬间发生的 
   AOE网的两个性质 
   
   
   
   在AOE网中只能有一个开始顶点和结束顶点 
   
   
   
   关键路径：最大路径长度的路径（完成工程最少需要的时间） 
   
   
   
  2.事件最早发生时间ve(k) 
   
   注意！！！是事件，不是活动 
   
   
   
  3、事件最迟发生时间vl(k) 
   
   
  4、活动最早开始时间e(i) 
  5、活动最迟开始时间l(i) 
   
   如果e(i)和l(i)看不懂定义，看下面例子就懂了 
   
  6、差额——时间余量 
   
   时间余量：活动的最早开始时间 - 最迟开始时间 = 该活动最多能拖多久 
   关键活动 = 时间余量为0，不能拖延的活动。所以可以通过时间余量来判断是否为关键活动 
   
   
   
  7.求关键路径算法思想 
   
   
   ① 先得到拓扑序列，在按照拓扑序列顺序求ve() 
   
   
   
   ② 先得到逆拓扑排序序列 
   每个点看出边，比如v2，就看和；v3就看和 
   
   
   
   ③ 活动的最早发生时间取决于弧尾的那个事件的最早开始时间 
   注意！！！活动数不一定等于事件数（点数不一定等于边数） 
   
   
   
   ④ 活动的最迟发生时间与活动最早发生时间e()原理差不多，看看上面的笔记 
   
   
   
   ⑤ 根据活动余量得到关键路径 
   
   
   
  8.关键活动、关键路径的特性 
   
   下面对关键活动、关键路径的一些特性的分析 
   时刻记住，关键活动就是时间余量为0的活动，也就是不能拖延的活动 
   
   
   
   在AOE网中的关键路径不一定唯一 
   
   
   
  9.具体代码实现（未全部实现） 
  #include 
using namespace std;
#define MAX_VERTEX_NUM 16
#define MAX_ARC_NUM 128
int verNum, arcNum; // 图的顶点数和边数
int x, y, z;
int inDegree[MAX_VERTEX_NUM]; // 记录顶点入度
int print[MAX_VERTEX_NUM];    // 记录拓扑序列
int ve[MAX_VERTEX_NUM];       // 事件的最早发生时间
int vl[MAX_VERTEX_NUM];       // 事件的最迟发生时间
int e[MAX_ARC_NUM];           // 活动的最早发生时间
int l[MAX_ARC_NUM];           // 活动的最迟发生时间
int d[MAX_ARC_NUM];           // 活动的时间余量
typedef struct ArcNode // 边链表结点
{
    int adjvex;
    int info; // 边的权值
    struct ArcNode *nextArc;
} ArcNode;
typedef struct VNode // 顶点表结点
{
    int data;
    ArcNode *firstArc;
} VNode, AdjList[MAX_VERTEX_NUM];
typedef struct {
    AdjList vertices;   // 邻接表
    int verNum, arcNum; // 图的顶点数和弧数
} Graph;                // Graph是以邻接表存储的图类型

// !!! 第一步：先求拓扑序列
bool TopologicalSort(Graph g) {
    stack s; // 声明辅助栈，用于存储入度为0的顶点
    for (int i = 1; i <= g.verNum; i++)
    {
        if (inDegree[i] == 0)
        {
            s.push(i); // 将初始所有入度为0的顶点入栈
        }
    }
    int count = 0;     // 计数，记录当前已经输出的顶点数
    while (!s.empty()) // 栈非空，表示还存在入度为0的顶点
    {
        int flag;
        int v;
        ArcNode *p;
        flag = s.top();
        s.pop();               // 栈顶元素出栈
        print[count++] = flag; // 记录输出的顶点
        // 本段循环的目的，因为输出栈顶元素，与栈顶顶点相连的顶点的入度减一
        for (p = g.vertices[flag].firstArc; p != NULL; p = p->nextArc) {
            v = p->adjvex;
            if (!(--inDegree[v]))
            {
                s.push(v); // 入度为0，入栈
            }
        }
    }
    if (count < g.verNum) {
        return false; // 拓扑排序失败，存在回路
    }
    return true; // 拓扑排序成功
}

// !!! 第二步：
void EarlistTimeOfVertex(Graph graph, int veList[])
{
    for (int i = 0; i < graph.verNum; i++) // 一共有verNum个事件
    {
        int flag = print[i];
        for (int j = 1; j <= graph.verNum; j++)
        {
            ArcNode *tempArc = graph.vertices[i].firstArc;
            while (tempArc != NULL)
            {
                if (tempArc->adjvex == flag)
                {
                    ve[flag] = max(ve[flag], ve[j] + tempArc->info);
                }
                tempArc = tempArc->nextArc;
            }
        }
    }
}
void LatestTimeOfVertex(int vlList[])
{
}
void EarlistTimeOfEdge(int eList[])
{
}
void LatestTimeOfEdge(int lList[])
{
}
void CriticalPath(Graph g)
{
}

int main()
{
    cin >> verNum >> arcNum;
    Graph graph;
    graph.verNum = verNum;
    graph.arcNum = arcNum;
    memset(inDegree, 0, sizeof(inDegree));
    memset(print, -1, sizeof(print));
    for (int i = 1; i <= verNum; i++)
    {
        graph.vertices[i].firstArc = NULL;
    }
    for (int i = 1; i <= arcNum; i++)
    {
        cin >> x >> y >> z;
        inDegree[y]++;
        ArcNode *arc = (ArcNode *)malloc(sizeof(ArcNode));
        arc->adjvex = y;
        arc->info = z;
        arc->nextArc = graph.vertices[x].firstArc;
        graph.vertices[x].firstArc = arc;
    }
    if (TopologicalSort(graph))
    {
        for (int i = 0; i < verNum; i++)
        {
            cout << "v" << print[i] << " ";
        }
    }
    if (TopologicalSort(graph))
    {
        EarlistTimeOfVertex(graph, ve);
        for (int i = 1; i <= verNum; i++)
        {
            cout << ve[i] << " ， ";
        }
    }
    return 0;
}
 
   
  10.小结 
   
   
   
  不实际操作代码，只是粗略过一下知识点，只需 75 分钟左右过一遍

android系统selinux中添加新属性property 辉色投像
1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
数组去重好奇的猫猫猫
整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
数据仓库——维度表一致性墨染丶eye 背诵数据仓库
数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redis bootstrap 数据库
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
ARM驱动学习之基础小知识 JT灬新一 ARM 嵌入式 arm开发学习
ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
展现思维导图魅力，不断挖掘人生宝藏思维导图讲师Mandy
第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
2019-11-04复盘——飞来山上千寻塔，闻说鸡鸣见日升。那一叶秋
1、大盘篇先上老图，看习惯了，也就知道走势了图1上证指数日线图还是那张老图，自己可以在自己的相关软件上画出来，快变盘了。2、个股篇未加仓、未减仓。分析量能的时候，突然发现这么一个东西：“放量突破年线，缩量回调。”合众科技日线图其实，最近的N只个股，在技术分析上，都到了变盘的临界时候。结合这么久的走势，特别是ZJH不断放开IPO的申请，本质上说是融资难度变大，或者说是为企业的融资开创便利。但现在市场
数据结构之哈希表 X同学的开始数据结构数据结构散列表
哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
父母教育孩子的方式，将影响孩子一生树英教育
为什么有些孩子总是充满自信与快乐？独立、有主见又坚强？而有些孩子却自卑、胆怯，软弱又过度依赖父母？为什么有些孩子总是健康、阳光又富于创造力？而有些孩子却悲观、孤僻又思想空乏？一个孩子的行为取决于孩子的思想，思想取决于环境和自己的认知，认知取决于教育。父母是孩子人生中的第一位教育者，父母养育孩子的方式，将决定他们人生的高度，影响他们的一生。网络图，侵权即删优秀的父母就像园丁，既要浇水施肥，又要修剪杂
数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列 C语言
文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
系统架构设计师需求分析篇二 AmHardy 软件架构设计师系统架构需求分析面向对象分析分析模型 UML和SysML
面向对象分析方法1.用例模型构建用例模型一般需要经历4个阶段：识别参与者：识别与系统交互的所有事物。合并需求获得用例：将需求分配给予其相关的参与者。细化用例描述：详细描述每个用例的功能。调整用例模型：优化用例之间的关系和结构，前三个阶段是必需的。2.用例图的三元素参与者：使用系统的用户或其他外部系统和设备。用例：系统所提供的服务。通信关联：参与者和用例之间的关系，或用例与用例之间的关系。3.识别参
[Python] 数据结构详解及代码 AIAdvocate 算法 python 数据结构链表
今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
4.C_数据结构_队列荣世蓥数据结构数据结构
概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
黄景瑜工作人员怒怼营销号！肖战事件就是他的前车之鉴板凳吃瓜小分队
无论社会怎样浮躁，我们自己也不可以浮躁。战胜浮躁的关键是明白自己真正的需要，保持一颗平常心，不要盲目攀比，不要羡慕别人，更不要唯利是图。一辈子很短，我们不能总是望着别人的精彩，羡慕着别人的人生，而忘记了经营自己生活，要知道，通过努力，你也能成为让人仰望的明星。如今，随着娱乐产业越来越成熟，每年的新星也是扎堆冒出。在我看来，与前几年不同的是，如今的新生代质量明显好过从前。“更专业了，更有礼貌了”也是
2023-06-19【感恩日记】第246篇 o泡沫o
思想日记：坚持下去，相信自己一定可以的【感恩日记】第246篇1.我真是太幸福啦！感恩孩子早起阅读，放学到学生之家完成作业，平安度过美好的一天。感恩！感恩！感恩！❤️2.我真是太幸福啦！感恩自己早起给孩子煮早餐，完成计划的工作，晚上学习。感恩！感恩！感恩！❤️3.我真是太幸福啦！感恩为我设计效果图的老师。感恩！感恩！感恩！❤️4.我真是太幸福啦！感恩父母养育了我，有妈的孩子真幸福。感恩！感恩！感恩！
摄影小白，怎么才能拍出高大上产品图片？是波妞唉
很多人以为文案只要会码字，会排版就OK了！说实话，没接触到这一行的时候，我的想法更简单，以为只要会写字就行！可是真做了文案才发现，码字只是入门级的基本功。一篇文章离不开排版、配图，说起来很简单！从头做到尾你就会发现，写文章用两个小时，找合适的配图居然要花掉半天的时间，甚至更久！图片能找到合适的就不怕，还有找不到的，比如产品图，只能亲自拍。拿着摆弄了半天，就是拍不出想要的效果，光线不好、搭出来丑破天
【Bugs】Python：“ModuleNotFoundError: No module named ‘XXX‘” 系'辞工具箱 python bug anaconda
问题描述Python使用库的前提是必须已安装了相应的库，往往利用“命令行指令”实现安装，一般安装解法类似。但，还是具有延伸问题，本博客对此作记录。【1】Nomodulenamed‘seaborn’(1.1):情况1：为Anaconda安装【图1-2】.定位Anaconda路径【图3】.Anaconda路径加入Path>&
3286、穿越网格图的安全路径 Lenyiin 题解 c++算法 leetcode
3286、[中等]穿越网格图的安全路径1、题目描述给你一个mxn的二进制矩形grid和一个整数health表示你的健康值。你开始于矩形的左上角(0,0)，你的目标是矩形的右下角(m-1,n-1)。你可以在矩形中往上下左右相邻格子移动，但前提是你的健康值始终是正数。对于格子(i,j)，如果grid[i][j]=1，那么这个格子视为不安全的，会使你的健康值减少1。如果你可以到达最终的格子，请你返回tr
阅读《别说你懂思维导图》21～23章day27 Ling宝尔
合理期待——思维导图的应用效果很多人问我，思维导图真的有用么？我常常回答，如果你觉得是它“没用”，一定是因为你没“用”，有“用”才“有用”。实际上，学习思维导图和学习木工、驾驶等技能型学习一样，都要经历从了解到应用、从应用到受益的过程。在使用前，我们很多人的思维处于“无意识的低效”状态，经过一段时间的学习，虽然掌握了思维导图的基本使用方法，但可能并没有太好的效果，这个阶段可称为“有意识的低效”状态
C++八股 Petrichorzncu 八股总结 c++开发语言
这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
GenVisR 基因组数据可视化实战(三) 11的雾
3.genCov画每个突变位点附件的coverage，跟igv有点相似。这个操作起来很复杂，但是图还是挺有用的。可以考虑。由于我的referencegenomebuild是hg38BiocManager::install(c("TxDb.Hsapiens.UCSC.hg38.knownGene","BSgenome.Hsapiens.UCSC.hg38"))library(TxDb.Hsapien
小西妈双语工程打卡2018-1-18 慢蜗牛Erica
这是送给妈妈的，还有一张是爸爸的，现在看着这张小图，觉得好温暖。早上看到了我把它折上了，还好一顿不高兴。妈妈这个是爸爸。爸爸希望之星，Herewecome.复赛通知书这是送给妈妈的小鹿，栩栩如生吧，不过妈妈不确定这是他一个人完成的。还送了妈妈一个小蝴蝶发卡，很暖心哦。小鹿上完课回家就很晚了，自己看了好几本书，没有录阅读打卡。听peppa第一季3集。
【树一线性代数】005入门 Owlet_woodBird 算法
Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构 leetcode 算法
给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 java UI PHP android linux
╔-----------------------------------╗┆
各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 bozch .net .net mvc
在.net mvc5中，在执行某一操作的时候，出现了如下错误：各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。回想过去：在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。 &
Java 对象大小的计算 e200702084 java
Java对象的大小如何计算一个对象的大小呢？
Mybatis Spring 171815164 mybatis
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); CustomerService userService = (CustomerService) ac.getBean("customerService"); Customer cust
JVM 不稳定参数 g21121 jvm
-XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。可以说“不稳定参数”
用户自动登录网站永夜-极光用户
1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码 2.思路:将用户的信息保存为cookie 每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
centos7 安装后失去win7的引导记录程序员是怎么炼成的操作系统
1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ### 在后面添加 menuentry "Windows 7 (loader) (on /dev/sda1)" {
Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载 aijuans oracle
Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
JavaEE开源快速开发平台G4Studio_V3.2发布了無為子 AOP oracle mysql javaee G4Studio
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。访问G4Studio网站 http://www.g4it.org G4Studio_V3.2版本变更日志功能新增 (1).新增了系统右下角滑出提示窗口功能。 (2).新增了文件资源的Zip压缩和解压缩
Oracle常用的单行函数应用技巧总结百合不是茶日期函数转换函数(核心)数字函数通用函数(核心)字符函数
单行函数; 字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心) 一:字符函数: .UPPER(字符串) 将字符串转为大写 .LOWER (字符串) 将字符串转为小写 .INITCAP(字符串) 将首字母大写 .LENGTH (字符串) 字符串的长度 .REPLACE(字符串,'A','_') 将字符串字符A转换成_
Mockito异常测试实例 bijian1013 java 单元测试 mockito
Mockito异常测试实例： package com.bijian.study; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import org.junit.Assert; import org.junit.Test; import org.mockito.
GA与量子恒道统计 Bill_chen JavaScript 浏览器百度 Google 防火墙
前一阵子，统计**网址时，Google Analytics（GA）和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下：为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
【Linux命令三】Top命令 bit1129 linux命令
Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果： top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99 Tasks: 202 total, 4 running, 198 sl
spring四种依赖注入方式白糖_ spring
平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
angular.injector boyitech AngularJS AngularJS API
angular.injector 描述: 创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入. 使用方法: angular.injector(modules, [strictDi]) 参数详解: Param Type Details mod
java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待 bylijinnan Integer
public class PC { /** * 题目：生产者-消费者。 * 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。 */ private static final Integer[] val=new Integer[10]; private static
使用Struts2.2.1配置 Chen.H apache spring Web xml struts
Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar struts2-core-2.2.1.jar struts2-sp
[职业与教育]青春之歌 comsci 教育
每个人都有自己的青春之歌............但是我要说的却不是青春... 大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的.... &nbs
oracle连接(join)中使用using关键字 daizj JOIN oracle sql using
在oracle连接(join)中使用using关键字 34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables. Evaluate the following SQL statement: SELECT oi.order_id, product_id, order_date FRO
NIO示例 daysinsun nio
NIO服务端代码： public class NIOServer { private Selector selector; public void startServer(int port) throws IOException { ServerSocketChannel serverChannel = ServerSocketChannel.open(
C语言学习homework1 dcj3sjt126com c homework
0、课堂练习做完 1、使用sizeof计算出你所知道的所有的类型占用的空间。 int x; sizeof(x); sizeof(int); # include <stdio.h> int main(void) { int x1; char x2; double x3; float x4; printf(&quo
select in order by , mysql排序 dcj3sjt126com mysql
If i select like this: SELECT id FROM users WHERE id IN(3,4,8,1); This by default will select users in this order 1,3,4,8, I would like to select them in the same order that i put IN() values so:
页面校验-新建项目 fanxiaolong 页面校验
$(document).ready( function() { var flag = true; $('#changeform').submit(function() { var projectScValNull = true; var s =""; var parent_id = $("#parent_id").v
Ehcache（02）——ehcache.xml简介 234390216 ehcache ehcache.xml 简介
ehcache.xml简介 ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
junit 4.11中三个新功能 jackyrong java
junit 4.11中两个新增的功能，首先是注解中可以参数化，比如 import static org.junit.Assert.assertEquals; import java.util.Arrays; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runn
国外程序员爱用苹果Mac电脑的10大理由 php教程分享 windows PHP unix Microsoft perl
Mac 在国外很受欢迎，尤其是在设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因： 1、Mac OS X 是基于 Unix 的这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
位运算、异或的实际应用 wenjinglian 位运算
一．位操作基础，用一张表描述位操作符的应用规则并详细解释。二．常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。三．位操作与空间压缩，针对筛素数进行空间压缩。 &n
weblogic部署项目出现的一些问题（持续补充中……） Everyday都不同 weblogic部署失败
好吧，weblogic的问题确实…… 问题一： org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
tomcat7性能调优（01） toknowme tomcat7
Tomcat优化： 1、最大连接数最大线程等设置 <Connector port="8082" protocol="HTTP/1.1" useBodyEncodingForURI="t
PO VO DAO DTO BO TO概念与区别 xp9802 java DAO 设计模式 bean 领域模型
O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持

王道数据结构课代表 - 考研数据结构 第六章 图 究极精华总结笔记

第6章 图

文章目录

6.1 图的基本概念

6.1.1 基本概念

1.无向图和有向图

2.简单图、多重图

3.顶点的度、入度、出度

4.顶点-顶点的关系描述

5.连通图、强连通图

6.子图、生成子图

7.连通分量、强连通分量 - 极大连通

8.生成树、生成森林 - 极小连通

9.边的权、带权图/网

6.1.2 几种特殊的图

1.无向完全图和有向完全图

2.稀疏图和稠密图

3.树

6.1.3 小结

6.2 图的存储以及基本操作 P218

6.2.1 邻接矩阵(Adjacency Matrix)

1.算法思想

2.代码实现

3.性能分析 - 优缺点

4.邻接矩阵的性质

5.小结

6.2.2 邻接表(Adjacency List)

1.算法思想

2.代码实现

3.性能分析 - 优缺点

4.邻接矩阵对比邻接表

5.小结

6.2.3 十字链表(Orthogonal List)

1.算法思想

2.代码实现

3.性能分析

6.2.4 邻接多重表

1.算法思想

2.性能分析

3.代码实现

4.十字链表和邻接多重表小结

6.2.5 图的基本操作

1.Adjacent

2.Neighbors

3.InsertVertex

4.DeleteVertex

5.AddEdge

6.RemoveEdge

7.FirstNeighbor

8.NextNeighbor

9.其它

10.小结

6.3 图的遍历

6.3.1 广度优先搜索

1.算法思想

2.代码实现

3.性能分析

4.广度优先生成树

5.小结

6.3.2 深度优先搜索

1.算法思想

2.代码实现

3.性能分析

4.练习

5.深度优先生成树、生成森林

6.小结

6.3.3 图的遍历和图的连通性

1.无向图情况

2.有向图情况

6.4 图的应用

6.4.1 最小生成树

1.定义

2.Prim算法

1）算法思想

2）性能分析

3）代码实现

3.Kruskal算法

1）算法实现

2）性能分析

3）代码实现

王道数据结构课代表 - 考研数据结构第六章图究极精华总结笔记

第6章图