图的定义
· 图(Graph)是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示
为:G(V,E)。其中G表示一个图，V是图G中顶点的集合，E是图G中边的集合。
-在图中数据元素称之为顶点（Vertex）。
-顶点集合要有穷非空。
-任意两个顶点之间都可能有关系，顶点之间的逻辑关系用边来表示，边集可以空。
· 无向边：若顶点Vi到Vj之间的边没有方向，则称这条边为无向边（Egde），
用无序偶（Vi，Vj）来表示。
· 上图G1是一个无向图，G1={V1，E1}，其中
-V1={A,B,C,D},
-E1={(A,B)，(B,C)，(C,D)，(D,A)，(A,C)}
· 有向边：若从顶点Vi到Vj的边有方向，则称这条边为有向边，也成为弧(Arc)，
用有序偶<Vi，Vj>来表示，Vi称为弧尾，Vj称为弧头。
· 上图G2是一个有向图，G2={V2，E2}，其中
-V2={A,B,C,D}
-E2={<B,A>，<B,C>，<C,A>，<A,D>}
· 简单图：在图结构中，若不存在顶点到其自身的边，且同一条边不重复
出现 ，则称这样的图为简单图。
· 以下两个则不属于简单图：
· 无向完全图：在无向完全图中，如果任意两个顶点之间都存在边，则称
该图为无向完全图。含有n个顶点的无向完全图有n*(n-1)/2条边。
· 有向完全图：在有向图中，如果任意两个顶点之间都存在方向互为相反的
两天弧，则称该图为有向完全图。含有n个顶点的有向完全图有n*(n-1)条边。
· 稀疏图和稠密图：这里的稀疏和稠密是模糊的概念，都是相对而言，通常认为边或
弧数小于n*logn（n是顶点的个数）的图称为稀疏图，反之称为稠密图。
· 有些图的边或弧带有与它相关的数字，这种与图的边或弧相关的数叫做权(Weight),
带权的图通常称为网(Network)。
· 假设有两个图G1=(V1,E1)和G2=(V2,E2),如果V2属于V1，E2属于E1，则
称G2为G1的子图(Subgraph)。
图的顶点与边之间的关系
· 对于无向图G=(V,E),如果边(V1,V2)属于E，则称顶点V1和V2互为邻接点(Adjacent),即V1和V2相
邻接。边(V1,V2)依附(incident)于顶点V1和V2，或者说(V1,V2)与顶点V1和V2相关联。
· 顶点V的度(Degree)是和V相关联的边的数目，记为TD(V),如下图，顶点A与B互为邻接点，
边(A,B)依附于顶点A与B上，顶点A的度为3。
· 对于有向图G=(V,E),如果有<V1,V2>属于E，则称顶点V1邻接到顶点V2，顶点V2邻接自顶点V1。
· 以顶点V为头的弧的数目称为V的入度(InDegree),记为ID(V),以V为尾的弧的数目称为
V的出度(OutDegree),记为OD(V),因此顶点V的度为TD(V)=ID(V)+OD(V)
· 下图顶点A的入度是2，出度是1，所以顶点A的度是3。
路径
· 无向图G=(V,E)中从顶点V1到顶点V2的路径。
· 下图用红线列举了从顶点B到顶点D的四种不同路径：
· 如果G是有向图，则路径也是有向的。
· 下图用红线列举顶点B到顶点D的两种路径，而顶点A到顶点B就不存在路径：
· 路径的长度是路径上的边或弧的数目。
· 第一个顶点到最后一个顶点相同的路径称为回路或者环(Cycle)。
· 序列中顶点不重复出现的路径称为 简单路径，除了第一个顶点和最后一个顶点
之外，其余顶点不重复出现的回路，称为简单回炉或简单环。
· 下图左侧是简单环，右侧 不是简单环：
连通图
· 在无向图G中，如果匆匆顶点V1到顶点V2有路径，则称V1和V2是联通的，如果
对于图中任意两个顶点Vi和Vj都是连通的，则称G是连通图。
· 无向图中的极大连通子图称为连通分量。
· 注意以下概念：
-首先要是子图，并且子图是要连通的。
-连通子图含有极大顶点数。
-具有极大顶点数的连通子图包含依附于这些顶点的所有边。
· 在有向图G中，如果对于每一队Vi到Vj都存在路径，则称G是强连通图。
· 有向图中的极大强连通子图称为有向图的强连通分量。
· 下图左侧并不是强连通图，右侧是。并且右侧是左侧的极大强连通子图，
也是左侧的强连通分量。
· 最后我们再来看连通图的生成树定义。
· 所谓的一个连通图的生成树是一个极小的连通子图，它含有图中全部的n个
顶点，但只有足以构成一棵树的n-1条边。
· 如果一个有向图恰有一个顶点入度为0，其余顶点入度均为1，则是一棵有向树。
左边的有向图，能拆分成右边两棵有向树。
图的存储结构
· 因为任意两个顶点之间都可能村长联系，因此无法以数据元素在内存中的物理
位置来表示元素之间的关系(内存物理位置是线性的，图的元素关系是平面的)。
· 如果用多重链表来描述倒是可以做到，但是纯粹用多重链表导致的浪费是无法
想象的(如果各个顶点的度数相差太大，就会造成巨大的浪费)。
邻接矩阵(无向图)
· 考虑到图是由顶点和边或弧两部分组成，自然会用到两个结构体来存储。
· 顶点因为不区分大小、主次，所以用一个一维数组来存储。
· 边或弧由于是顶点与顶点之间的关系，可以考虑二维数组来存储。
· 图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点
信息，一个二维数组(称为邻接矩阵)存储图中的边或弧的信息。
· vertex[4]={v0,v1,v2,v3},边数组arc[4][4]为对称矩阵(由于无向图不分先后)
0表示不存在顶点间的边，1表示顶点间存在边。
· 对称矩阵：所谓对称矩阵就是n阶矩阵的元满足a[i][j]=a[j][i](0<=i,j<=n)。
· 有了这个二维数组组成的对称矩阵，可以很容易地知道图中的信息：
-要判定任意两顶点是否有边无边就非常容易。
-某个顶点的度就为这个顶点Vi在邻接矩阵中第i行(列)的元素之和。
-顶点Vi的所有邻接点就是矩阵中第i行元素扫描一遍，为1就是邻接点。
邻接矩阵(有向图)
· 可见顶点数组vertex[4]={V0,V1,V2,V3},弧树组arc[4][4]也是一个矩阵，但因为是有
向图，所以这个矩阵并不对称，例如由V1到V0有弧，得到arc[1][0]=1,而V0到V1
没有弧，因此arc[0][1]=0。
· 关于入度和出度，顶点V1的入度为1，整合是第V1列各数之和，
顶点V1的出度为2，正好是第V1行的各数之和。
邻接矩阵(网)
· 当i=j时书上是用∞表示，有的地方用0表示
· 这里“∞”表示一个计算机允许的，大于所有边上权值的值（int最大值65535）。
图的数组表示法，结构体：
#define INFINITY 65535 //表示无穷大-->在带权的图中用到，即网
#define MAX_VERTEX_NUM 20 //图的最大顶点数
#define MAX_INFO 20 //最大信息数
typedef char InfoType; //附加信息类型
typedef int VRType; //顶点关系类型
typedef int VertexType; //顶点数据类型
//图的种类：有向图，有向网，无向图，无向网
typedef enum {
DG, DN, UDG, UDN
} GraphKind;
typedef struct ArcCell {
VRType adj; //顶点关系类型，对无权图用1或0表示是否相邻
//对带权图，则为权值类型
InfoType *info; //附加信息指针
} ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct {
VertexType vexs[MAX_VERTEX_NUM];//顶点向量
AdjMatrix arcs; //邻接矩阵
int vexnum, arcnum; //当前顶点数和弧数
GraphKind kind; //图的种类
} MGraph;
邻接表(无向图)
· 我们可以发现，对于边数相对较少的图，上面的邻接矩阵是存在巨大浪费的。如下图
· 因此可以采用数组和链表组合起来存储，这里称为邻接表。
· 邻接表的处理方法是这样的：
-图中顶点用一个一维数组存储。
-图中每个顶点Vi的所有邻接点构成一个线性表，由于个数不确定，所以用单链表存储。
邻接表（有向图）
· 类似地，下面是把顶点当弧尾建立的邻接表，这样容易得到每个顶点的出度。
· 有时为了确定顶点的入度或以顶点为弧头的弧，可以建立一个有向图的逆邻接表。
邻接表（网）
· 对于带权值的网图，可以在边表结点定义中再增加一个数据域来存储权值即可。
图的邻接表存储，结构体：
#define MAX_VERTEX_NUM 20
typedef char InfoType; //附加信息类型
typedef int VertexType; //顶点数据类型
typedef struct ArcNode{
int adjvex; //该弧所指向的顶点位置
struct ArcNode *nextarc;//下个结点
InfoType *info; //当前结点（弧）的信息
}ArcNode;
typedef struct VNode{
VertexType data;//顶点信息
ArcNode *firstarc;//指向第一个依附于该顶点弧的指针
}VNode,*AdjList[MAX_VERTEX_NUM];
typedef struct {
AdjList vertices;
int vexnum,arcnum;//图的当前顶点数和弧数
int kind; //图的种类标志
}ALGraph;
十字链表（是对于有向图来说的，关心出入度问题，所以把两个邻接表结合一起）
· 邻接表固然优秀，但也有不足，例如对有向图的处理上，有时需要再建立一个逆邻接表。
· 这时候就出现了十字链表。
· 为此重新定义顶点表结构结点结构：
· 接着重新定义边表结点结构：
· 可以发现，蓝线是邻接表的指向，红线是逆邻接表的指向，是把他们合起来了。
· 十字链表的好处就是因为把邻接表和逆邻接表整合在了一起，这样既容易找到Vi为
尾的弧，也容易找到以Vi为头的弧，因而容易求得顶点的出度和入度。
· 十字链表除了结构复杂一点外，其实创建图算法的时间复杂度是和邻接表相同的。
因此，在有向图的应用中，十字链表也是非常好的数据结构模型。
//十字链表
#define MAX_VERTEX_NUM 20
typedef char InfoType; //附加信息类型
typedef int VertexType; //顶点数据类型
typedef struct ArcBox{
int tailvex,headvex; //该弧的尾和头顶点的位置
struct ArcBox *hlink,*tlink;//分别为弧头相同回合弧尾相同的弧的链域
InfoType *info; //该弧相关信息的指针
}ArcBox;
typedef struct VexNode{
VertexType data;
ArcBox *firstin,*firstout;//分别指向该顶点第一条弧和出弧
}VexNode;
typedef struct {
VexNode xlist[MAX_VERTEX_NUM];//表头向量
int vexnum,arcnum; //有向图的当前顶点数和弧数
}OLGraph;
邻接多重表（对无向图而言）
· 如果在无向图的应用中，关注的重点是顶点的话，那么邻接表是不错的选择，但如果更挂关注的是边的操作，
比如对已经访问过的边做标记，或者删除某一条边等操作，邻接表就显得不方便了（如下图）
· 因此，这里仿造十字链表的方式，对边表结构进行改装，重新定义的边表结构如下：
· 其中iVex和jVex是与某条边依附的两个顶点在顶点表中的下标。
iLink指向依附点iVex的下一条边，jLink指向依附顶点jVex的下一条边。
· 也就是说在邻接多重表里边，边表存放的是一条边，而不是一个顶点。
//无向图的邻接多重表存储结构
#define MAX_VERTEX_NUM 20
typedef char InfoType; //附加信息类型
typedef int VertexType; //顶点数据类型
typedef enum {unvisited,visited}VisitIf;
typedef struct EBox{
VisitIf mark; //访问标记
int ivex,jvex; //该边依附的两个顶点的位置
struct EBox *ilink,*jlink;//分别指向依附这两个顶点的下一条边
InfoType *info; //该边信息指针
}EBox;
typedef struct VexBox{
VertexType data;
EBox *firstedge;//指向第一条依附该顶点的边
}VexBox;
typedef struct {
VexBox adjmulist[MAX_VERTEX_NUM];
int vexnum,edgenum;//无向图的当前顶点数和边数
}AMLGraph;
图的遍历（这里以邻接矩阵表示）
· 对于图的遍历，因为它的任一顶点都可以和其余的所有顶点相邻接，
因此极有可能村长重复走过某个顶点或漏了某个顶点的遍历过程。
· 如果要避免这种情况，就需要合理科学地遍历，常见的有两种遍历：
深度优先遍历和广度优先遍历。
深度优先遍历
· 也称为深度优先搜索，简称为DFS。
· 从图的某一点按照某个原则进行深度遍历，把遍历过的点作一个标记，在一个分支上
遍历到底后，逐个顶点退回，遍历其他分支，直到退回到原点，遍历完毕。
· 类似于树的先根遍历，是树的先根遍历的推广。
假设先从A遍历
代码实现：
int FirstAdjVex(MGraph G, int v) {
//返回v(序号)的第一个相邻节点（序号）
if (v > G.vexnum || v < 0)
return -1;
int i, j;
j = 0;
//如果是网
if (G.kind == DN || G.kind == UDN)
j = INFINITY;
for (i = 0; i < G.vexnum; i++)
if (G.arcs[v][i].adj != j)
return i;
return -1;
}
int NextAdjVex(MGraph G, int v, int w) {
//w是v的相邻节点，返回v相对w的下一个节点的序号，否则返回-1
int i, j;
j = 0;
//如果为网
if (G.kind == DN || G.kind == UDN)
j = INFINITY;
//两顶点不相邻
if (G.arcs[v][w].adj == j)
return -1;
//从w之后的结点开始
for (i = w + 1; i < G.vexnum; i++)
if (G.arcs[v][i].adj != j)
return i;
return -1;
}
int visited[MAX_VERTEX_NUM];//访问标记数组
void DFS(MGraph G, int v) {
//从第v个顶点出发递归地深度优先遍历图G
visited[v] = 1;
printf("%d", G.vexs[v]);//访问第v个顶点
for (int w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w))
if (!visited[w])//对未访问的邻接顶点w递归调用DFS
DFS(G, w);
}
void DFSTraverse(MGraph G) {
for (int i = 0; i < G.vexnum; ++i) {
visited[i] = 0; //访问标志数组初始化
}
for (int j = 0; j < G.vexnum; ++j) {
if (!visited[j])
DFS(G, j); //对未访问的顶点调用DFS
}
}
int main() {
MGraph G;
CreateGraph(G);
DFSTraverse(G);
return 0;
}
广度优先遍历
· 又称为广度优先搜索，简称BFS。
· 要实现广度优先遍历，可以利用队列来实现。
· 访问A后，把与A相邻的结点入队列，A标记已入过列。访问B，把B相邻的C,I,G入列
并标记已入列。访问F，把F相邻的G,E入列，因为G已被标记，所以只要E入列，依次类推。
代码实现：
void BFSTraverse(MGraph G) {
//按广度优先非递归遍历图G，使用辅助队列Q和访问标志数组visited
int v, w;
VertexType u;
LinkQueue Q;
for (v = 0; v < G.vexnum; ++v)//标志数组初始化
visited[v] = 0;
IniteQueue(Q); //生成队列
for (v = 0; v < G.vexnum; ++v)
if (!visited[v]) {
visited[v] = 1;
printf("%d", G.vexs[v]);
EnQueue(Q, v); //v入队列
while (!QueueEmpty(Q)) {
DeQueue(Q, u); //队头元素出队并至为u
for (w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w))
if (!visited[w]) { //w为u的尚未访问的邻接点
visited[w] = 1;
printf("%d", G.vexs[w]);
EnQueue(Q, w);
}
}
}
}
最小生成树
· 普里姆算法：寻找起始顶点邻接的最短边，并入集合，再寻找邻接的最短边 ，不能有环。
· 克鲁斯卡尔算法，寻找最短边，不能有环。
直接上两种算法的代码：
//普里姆算法
struct {
VertexType adjvex;
VRType lowcost;
}closedge[MAX_VERTEX_NUM];
int minmum(MGraph G){
int min=INFINITY;
int index=-1;
for (int i = 0; i < G.vexnum; ++i) {
//最小值大于 该边的权值 且 该边的权值不为 0
if(min>closedge[i].lowcost&&closedge[i].lowcost!=0){
min=closedge[i].lowcost;
index=i;
}
}
return index;
}
void MiniSpanTree_PRIM(MGraph G,VertexType u){
//书本P174表格
int k=LocateVex(G,u);//该顶点位置 k=0
for (int j = 0; j < G.vexnum; ++j)//辅助数组初始化
if(j!=k)//相当于u顶点 边的信息
closedge[j]={u,G.arcs[k][j].adj};//{adjvex,lowcost}
closedge[k].lowcost=0;//初始，U={u}，把u并入集合
for (int i = 1; i < G.vexnum; ++i) {//选择其余G.vexnum-1个顶点
k=minmum(G); //求出T的下一个结点，第k顶点
printf("%d-->%d\n",closedge[k].adjvex,G.vexs[k]);//输出 生成树边
closedge[k].lowcost=0;//第k顶点并入U集
for(int j=0;j<G.vexnum;++j)
if(G.arcs[k][j].adj<closedge[j].lowcost)
//新顶点并入U后重新选择最小边
closedge[j]={G.vexs[k],G.arcs[k][j].adj};
}
}
//克鲁斯卡尔算法，自己写的
typedef struct {
int beginNum; //存放顶点下标
int endNum;
VertexType begin;//顶点名称
VertexType end;
VRType weight;//权重
}Edge[MAX_EDGE_NUM];//边集数组
void MiniSpanTree_Kruskal(MGraph G){
Edge edge[G.arcnum];
int set[G.vexnum];
//初始化辅助数组
for (int i = 0; i < G.vexnum; ++i) {
set[i]=i;//{0,1,2,3,4,5,....}
}
int k=0;
//得到边集数组
for (int i = 0; i < G.vexnum; ++i)
for (int j = 1; j < G.vexnum; ++j)
if (i<j&&G.arcs[i][j].adj!=INFINITY){
edge[k]->beginNum=i;
edge[k]->endNum=j;
edge[k]->begin=G.vexs[i];
edge[k]->end=G.vexs[j];
edge[k]->weight=G.arcs[i][j].adj;
k++;
}
VertexType temp;
VRType adj;
//边集数组，按权重从小到大
for (int i = 0; i < G.arcnum; ++i)
for (int j = i+1; j < G.arcnum; ++j)
if(edge[i]->weight>edge[j]->weight){
temp=edge[i]->begin;
edge[i]->begin=edge[j]->begin;
edge[j]->begin=temp;
temp=edge[i]->end;
edge[i]->end=edge[j]->end;
edge[j]->end=temp;
adj=edge[i]->weight;
edge[i]->weight=edge[j]->weight;
edge[j]->weight=adj;
k=edge[i]->beginNum;
edge[i]->beginNum=edge[j]->beginNum;
edge[j]->beginNum=k;
k=edge[i]->endNum;
edge[i]->endNum=edge[j]->endNum;
edge[j]->endNum=k;
}
int a,b;
for (int i = 0; i < G.arcnum; ++i) {
if(set[edge[i]->beginNum]!=set[edge[i]->endNum]){
//如果辅助数组中，对应数字不同
//输出该边，修改辅助数组中数字
//如果set[edge[i]->beginNum]为a
//set[edge[i]->endNum]为b
//那么把辅助数组中所有为b的改为a
printf("%d->%d weight:%d\n",edge[i]->begin,edge[i]->end,edge[i]->weight);
a=set[edge[i]->beginNum];
b=set[edge[i]->endNum];
for (int j = 0; j < G.vexnum; ++j)
if(set[j]==b)
set[j]=a;
}
}
}
· 普里姆算法的时间复杂度为O(n^2)，与网中的边数无关，适用于求边稠密的最小生成树。
· 库鲁斯卡尔的时间复杂度为O(eloge)，e为网中边的数目，适合于求边稀疏的最小生成树。
拓扑排序
· 一个无环的有向图称为无环图(Directed Acyclic Graph)，简称DAG图。
· 所有的工程或者某种流程都可以分为若干个小的工程或者阶段，
称这些小的工程或阶段为"活动"。
· 在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，
这样的有向图为顶点表示活动的网，称之为AOV网。
· AOV网中的弧表示活动之间存在某种制约关系，且不能存在回路。
· 拓扑序列：设G=(V,E)是一个具有n个顶点的有向图，V中的顶点序列V1,V2,...,Vn
满足若从顶点Vi到Vj有一条路径，则在顶点序列中顶点Vi必在顶点Vj之前。则称
这样的顶点序列为拓扑序列。
· 拓扑排序：就是对一个有向图构造拓扑序列的过程。
· 拓扑序列(其中一种)：
1，13，4，8，15，5，2，3，10，11，12，7，6，9
注：前面的必须指向后面的。
· 对AOV网进行拓扑排序的方法和步骤如下：
-从AOV网中选择一个没有前驱的顶点(入度为0)并输出他。
-从网中删去该顶点，并且删去从该顶点发出的全部有向边。
-重复上述两步，直到剩余网中不再存在没有前驱的顶点为止。
· 由刚才我们那幅AOV网图，我们可以用邻接表(因为需要删除顶点，所以
选择邻接表会更加方便)数据结构表示：
代码实现：
int TopologicalSort(ALGraph G){
//有向图G采用邻接表存储结构
//若G无回路，则输出G的顶点的一个拓扑序列并返回1，否则0
SqStack S;
ArcNode *p;
int i,k;
InitStack(S);
for ( i = 0; i < G.vexnum; ++i) {
if(G.vertices[i]->in==0)
Push(S,i); //入度为0的顶点下标入栈
}
int count=0; //对输出顶点计数
while (!StackEmpty(S)){
Pop(S,i); //输出i号顶点，并计数
printf("%d,%d\n",i,G.vertices[i]->data);
++count;
for(p=G.vertices[i]->firstarc;p;p=p->nextarc){
k=p->adjvex; //对i号顶点的每个邻接点的入度减1
if(!(--G.vertices[k]->in)) //若入度为0，则入栈
Push(S,k);
}
}
if(count<G.vexnum)
return 0;
else
return 1;
}
算法时间复杂度：
-对一个具有n个 顶点，e条边的网来说，初始建立入度为零的顶点栈，
要检查所有顶点一次，执行时间为O(n)。
-排序中，若AOV网无回路，则每个顶点入出栈各一次次，每个表结点
被检查一次，因而执行时间是O(n+e)。
-所以整个算法时间复杂度是O(n+e)。
关键路径
· AOE网：在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，
用边上的权值表示活动的持续时间，这种有向图的边表示活动的网称为AOE网。
· 把AOE网中入度为零的顶点称为始点或源点，出度为零的顶点称为终点或汇点。
· 路径长度最长的路径叫做关键路径。
-etv(Earliest Time Of Vertex):事件最早发生时间，就是顶点的最早发生时间。
-ltv(Latest Time Of Vertex):事件最晚发生时间，就是每个顶点对应的事件最晚
需要开始的时间，如果超出此时间将会延误整个工期。
从后面往前看，减去这个工时就为最晚发生时间
例如：C8的etv为12，C6的ltv为12-4=8
-ete(Earliest Time Of Edge):活动的最早开工时间，就是弧的最早发生时间。
-lte(Latest Time Of Edge):活动的最晚发生时间，就是不推迟工期的最晚开工时间。
类似ltv算法，也要倒着过来。
代码实现：
//拓扑排序
int TopologicalSort(ALGraph G) {
//有向图G采用邻接表存储结构
//若G无回路，则输出G的顶点的一个拓扑序列并返回1，否则0
SqStack S;
ArcNode *p;
int i, k;
InitStack(S);
for (i = 0; i < G.vexnum; ++i) {
if (G.vertices[i]->in == 0)
Push(S, i); //入度为0的顶点下标入栈
}
int count = 0; //对输出顶点计数
while (!StackEmpty(S)) {
Pop(S, i); //输出i号顶点，并计数
printf("%d,%d\n", i, G.vertices[i]->data);
++count;
for (p = G.vertices[i]->firstarc; p; p = p->nextarc) {
k = p->adjvex; //对i号顶点的每个邻接点的入度减1
if (!(--G.vertices[k]->in)) //若入度为0，则入栈
Push(S, k);
}
}
if (count < G.vexnum)
return 0;
else
return 1;
}
//关键路径
int ve[];//顶点最早开始时间
int vl[];//顶点最晚开始时间
int TopologicalOrder(ALGraph G, SqStack &T) {
//有向网G采用邻接表存储结构，求各顶点事件的最早发生时间ve(全局变量)
//T为拓扑序列顶点栈，S为零入度顶点栈
//若G无回路，则用栈T返回G的一个拓扑序列，返回1，否则0
SqStack S;
ArcNode *p;
int i, k, j;
InitStack(S);
InitStack(T);
for (i = 0; i < G.vexnum; ++i) {
if (G.vertices[i]->in == 0)
Push(S, i); //入度为0的顶点下标入栈
ve[i] = 0; //初始化
}
int count = 0;
while (!StackEmpty(S)) {
Pop(S, j); //j号顶点入T栈并计数
Push(T, j);
++count;
for (p = G.vertices[j]->firstarc; p; p = p->nextarc) {
k = p->adjvex; //对j号顶点的每个邻接点的入度减1
if (!(--G.vertices[k]->in)) //若入度减为0，则入栈
Push(S, k);
//当前出栈j号顶点的 最早发生时间+ 当前循环连接k号顶点的权值 >k号顶点最早 发生时间
if (ve[j] + *(p->info) > ve[k])
//k号顶点的最早发生时间=出栈顶点号的最早发生时间+与之相连边的权值
ve[k] = ve[j] + *(p->info);
}
}
if (count < G.vexnum) //该有向网有回路
return 0;
else
return 1;
}
int CriticalPath(ALGraph G) {
//G为有向网，输出G的各项关键活动
int j, k, dut, ee, el;
char tag;
SqStack T;
ArcNode *p;
if (!TopologicalOrder(G, T))
return 0;
for (int i = 0; i < G.vexnum; ++i) //初始化顶点事件的最迟发生时间
vl[i] = ve[G.vexnum - 1];
while (!StackEmpty(T)) //按拓扑逆序求各顶点的vl值
//依附于j号顶点的第一条边（包含边权重和指向的顶点）
for (Pop(T, j), p = G.vertices[j]->firstarc; p; p = p->nextarc) {
//该弧指向顶点的位置k
k = p->adjvex;
//该弧权重
dut = *(p->info);
//k的最迟发生时间-该弧权重<初始顶点最迟发生时间
if (vl[k] - dut < vl[j])
vl[j] = vl[k] - dut;
}
for (j = 0; j < G.vexnum; ++j)
for (p = G.vertices[j]->firstarc; p; p = p->nextarc) {
k = p->adjvex;
dut = *(p->info);
//注意ve，vl是顶点的最早和最晚发生时间
//ee，el才是弧的最早和最晚发生时间
//关键路径是对弧而言
ee = ve[j];//该弧最早发生时间=该弧起始顶点最早发生时间
el = vl[k] - dut;//该弧最晚发生时间=该弧结束顶点最晚发生时间-权重
//带* 为关键
tag = (ee == el) ? '*' : '';
printf("起始顶点：%d 结束顶点：%d 该弧权重：%d 最早开始时间：%d 最晚开始时间：%d 是否关键：%c", j, k, dut, ee, el, tag);
}
}
· 这两种算法的时间复杂度均为O(n+e)，前一种算法的常数因子要小些。由于计算弧的活动
最早开始时间和最迟开始时间的复杂度为O(e)，所以总的求关键路径的时间复杂度O(n+e)
最短路径
· 在网图和非网图中，最短路径的含义是不同的。
-网图是两顶点经过的边上权值之和最少的路径。
-非网图是两顶点之间经过的边数最少的路径。可以看成网图，权值都为1。
· 把路径起始的第一个顶点称为源点，最后一个顶点称为终点。
· 关于最短路径，分为两种算法：
迪杰斯特拉算法
git图演示
-初始所有顶点路径长为∞，设源点为0。
-搜索该源顶点的路径，依次标上花费路径长度，然后归入S集(表示已遍历)
-逐个搜索除S集合外所有已经标有花费路径长度的顶点，无需遍历归入S集顶点
遍历到其他顶点，若花费小于其标值，则修改之，遍历完成后，并入S集。
-重复上步步骤。
//最短路径，迪杰斯特拉算法
typedef int Patharc[MAX_VERTEX_NUM];//用于存储最短路径下标的数组
typedef int ShortPathTable[MAX_VERTEX_NUM];//用于存储到各点最短路径的权值和
void ShortestPath_DIJ(MGraph G, int V0, Patharc &P, ShortPathTable &D) {
int v, w, min, k = NULL;
int final[MAX_VERTEX_NUM]; //final[w]=1 表示已经求得顶点V0到Vw的最短路径
//初始化数据
for (v = 0; v < G.vexnum; v++) {
final[v] = 0; //全部顶点初始化为未找到最短路径
D[v] = G.arcs[V0][v].adj; //将与V0点有连线的顶点加上权值
P[v] = 0; //初始化路径数组P为0
}
D[V0] = 0; //V0至V0路径为0
final[V0] = 1;//V0至V0不需要求路径
//开始主循环，每次求得V0到某个v顶点的最短路径
for (v = 1; v < G.vexnum; v++) {
min = INFINITY;
//循环后得到一个已知最短路径的顶点，作为发散修正的顶点
for (w = 0; w < G.vexnum; w++)
if (!final[w] && D[w] < min) {
k = w;
min = D[w];
}
final[k] = 1; //将目前找到的最近的顶点置1
//修正当前最短路径 及距离
//从该顶点发散出去的各个顶点距离修正
for (w = 0; w < G.vexnum; w++)
//如果经过v顶点的路径比现在这条路径的长度短的话，更新
if (!final[w] && (min + G.arcs[k][w].adj < D[w])) {
D[w] = min + G.arcs[k][w].adj;//修改当前路径长度
P[w] = k; //存放前驱顶点
}
}
}
· 第一个FOR循环的时间复杂度是O(n)，第二个FOR循环共进行n-1次，
每次执行时间是O(n)，所以总的时间复杂度是O(n^2)。
· 如果用带权的邻接表作为有向图的存储结构，则虽然修改D的时间可以减少，
但由于在D向量中选择最小分量的时间不变，所以总时间仍为O(n^2)。
· 如果只希望找到源点到某一个特定终点的最短路径，这个问题和求
源点到其他所有顶点的最短路径一样复杂，其时间复杂度也是O(n^2)。
佛洛依德算法
· 从任意阶段i到任意节点j的最短路径只有2种可能，一种是直接从i到j另一种是
从i经过若干个节点k到j。所以，假设Dis(i,j)为节点u到节点v的最短路径的距离，
对于每一个节点k，我们检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，
证明从i到k再到j的路径比i直接到j的路径短，我们便设置Dis(i,j) = Dis(i,k) + Dis(k,j)，
这样一来，当我们遍历完所有节点k，Dis(i,j)中记录的便是i到j的最短路径的距离。
· 从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。
· 对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比己知的路径更短。如果是更新它。
十字交叉法
方法：两条线，从左上角开始计算一直到右下角如图所示
给出矩阵，其中矩阵A是邻接矩阵，而矩阵Path记录u,v两点之间最短路径所必须经过的点。
算法实现：
//最短路径，佛洛依德算法
typedef int PathMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef int DistancMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
void ShortestPath_FLOYD(MGraph G, PathMatrix &P, DistancMatrix &D) {
int v, w, k;
//初始化D和P
for (v = 0; v < G.vexnum; v++)
for (w = 0; w < G.vexnum; w++) {
D[v][w] = G.arcs[v][w].adj;
P[v][w] = -1;
}
//算法核心
for (k = 0; k < G.vexnum; k++)
for (v = 0; v < G.vexnum; v++)
for (w = 0; w < G.vexnum; w++)
if (D[v][w] > D[v][k] + D[k][w]) {
D[v][w] = D[v][k] + D[k][w];
P[v][w] = P[v][k];
}
}· 此算法时间复杂度为O(n^3)。