DS博客作业04--图
| 这个作业属于哪个班级 | 数据结构 |
| ---- | ---- | ---- |
| 这个作业的地址 | DS博客作业04--图 |
| 这个作业的目标 | 学习图结构设计及运算操作 |
| 姓名 | 曹卉潼 |
0.PTA得分截图
1.本周学习总结（6分）
1.1 图的存储结构
1.1.1 邻接矩阵（不用PPT上的图）
造一个图，展示其对应邻接矩阵
用一个二维数组edges[][]保存两个顶点之间的关系。edges[i][j]表示从第i个顶点到第j个顶点的边信息。我们可以根据该二维数组每一行的数据判断每个顶点的入度，根据每一列的数据判断每个顶点的出度。每个顶点的其他信息(例如：顶点名称，顶点编号等)用一个一维数组去vexs[]保存；
结构体定义
typedef struct
{
int **edges;//保存边关系，定义为二级指针的原因：可以根据结点个数申请相对的空间，提高空间的利用效率；
int n,e;//n保存顶点个数，e保存图中边的条数；
VertexType *vexs;//保存顶点其他信息；VertexType是顶点其他信息的类型，可以是int，char，或者自定义结构体等；
}
无向图
对于无向图来说，两个顶点之间存在一条边(i,j)，那么这两个顶点互为邻接点，不仅可以从顶点i到顶点j，也可以从顶点j到顶点i。于是在建立邻接矩阵时，不仅要对edges[i][j]赋值，也要对edges[j][i]赋值(无权值，如果存在边就赋值为1，否则赋为0)；于是我们可以看出，最后得到无向图的邻接矩阵一定是沿对角线对称的
有向图
对于有向图来说，若存在一条边(i,j)，则此边只表示为从顶点i到顶点j，不可以由边(i,j)得到可以从顶点j到顶点i的信息。所以在建有向图的邻接矩阵时，只对edges[i][j]赋值(无权值，如果存在边就赋值为1，否则赋为0)；和无向图不一样的是，最后得到的邻接矩阵不一定是一个对称图形。
创建领接矩阵函数
1.1.2 邻接表
造一个图，展示其对应邻接表（不用PPT上的图）
邻接表是数组和链表的结合。对于每个顶点都建立一个单链表存储该顶点所有的邻接点。然后将定义一个结构体VNode，里面保存顶点邻接点的链表和顶点其他信息。设置VNode类型的结构体数组AdjGraph[]就可以保存图中所有顶点的邻接点,达到保存图中所有边的目的。结构体数组AdjGraph[]即为邻接表。
邻接表的结构体定义
typedef struct ANode //边结点；
{
int adjvex;//指向该边的终点编号；
struct ANode*nextarc;//指向下一个邻接点；
INfoType info;//保存该边的权值等信息；
}ArcNode;
typedef struct //头结点
{
int data;//顶点；
ArcNode *firstarc;//指向第一个邻接点；
}VNode;
typedef struct
{
VNode adjlist[MAX];//邻接表；
int n,e;//图中顶点数n和边数e；
}AdjGraph;
无向图
对于无向图，输入边(a,b)，那么就代表可以从顶点a到顶点b，也可以从顶点b到顶点a，所以我们不仅要在顶点a的邻接点链表中插入结点b，还要在顶点b的邻接点链表中插入结点a。
有向图
对于有向图，输入边(a,b)，只需在顶点a的邻接点链表中插入b就行。
创建邻接表函数
1.1.3 邻接矩阵和邻接表表示图的区别
（1）邻接矩阵：
- 因为邻接矩阵需要申请一个二维数组，空间复杂度为O(n2)，邻接矩阵的初始化需要初始化整个二维数组，所以时间复杂度为O(n2)；
- 好处：方便我们提取，修改边的信息；
- 劣势：占用空间较大，如果图中边条数较少(稀疏图)的话，需要我们保存的边信息就比较少，用邻接矩阵就会有多余的空间被闲置，空间利用效率不高；不利于顶点的插入和删除。
（2）邻接表：
- 因为共有e条边和n个结点，需要开辟n个空间来保存结点，e个空间来保存e条边信息，所以，创建邻接表的空间复杂度为O(n+e);因为对n个结点的单链表进行初始化，处理了n次，还要对e条边信息进行保存，故时间复杂度为O(n+e);
- 优势：占用空间相对邻接矩阵来说较小。
- 劣势：不方便我们提取两个顶点之间边的信息。
1.2 图遍历
1.2.1 深度优先遍历
DFS遍历
深度优先遍历图的方法是，从图中某顶点v出发：
（1）访问顶点v；
（2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；
（3）若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。
深度遍历代码
深度遍历适用哪些问题的求解。（可百度搜索）
1.2.2 广度优先遍历
选上述的图，继续介绍广度优先遍历结果
BFS遍历
从给定的任意结点v(初始顶点)开始，访问v所有的未被访问过的邻接点，然后按照一定次序访问每一个顶点的所有未被访问过的邻接点，直到图中和初始顶点邻接的所有顶点都被访问过为止。BFS遍历我们在用队列求解迷宫问题时接触过，是不可回溯的，逐渐向外扩散的过程。
建一个访问队列q；
访问v节点，进队；
while(队列不为空)
出队一个节点w；
遍历节点w的邻接点
取邻接点j，如果j未被访问则入队列q，然后把j标记为已访问；
end while
广度遍历代码
广度遍历适用哪些问题的求解。（可百度搜索）
1.3 最小生成树
一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。
对于带权值的图，其中权值之和最小的生成树称为图的最小生成树。
1.3.1 Prim算法求最小生成树
基于上述图结构求Prim算法生成的最小生成树的边序列
实现Prim算法的2个辅助数组是什么？其作用是什么？
设置2个辅助数组:
1.closest[i]：最小生成树的边依附在U中顶点编号。
2.lowcost[i]表示顶点i（i ∈ V－U）到U中顶点的边权重，取最小权重的顶点k加入U。
并规定lowcost[k]=0表示这个顶点在U中
每次选出顶点k后，要队lowcost[]和closest[]数组进行修正
Prim算法代码
void Prim(MGraph g, int v)
{
int lowcost[MAXV], closest[MAXV];//lowcost表示到该点最短距离，closest
int i, j, k, min ;// k记录最近顶点的编号
lowcost[1] = 1;//起点最近点为它本身
for (i = 1; i <= g.n; i++) //顶点从1开始，给lowcost[]和closest[]置初值
{
lowcost[i] = g.edges[v][i];//建图时未有直接相连的边，lowcost=edges为无穷大INF
closest[i] = v;
}
for (i = 1; i < g.n; i++) //找(n-1)次剩下的顶点
{
min = INF;
for (j = 1; j <= g.n; j++) // 在(V-U)中找出离U最近的顶点k
if (lowcost[j] != 0 && lowcost[j] < min)
{
min = lowcost[j]; k = j; //
}
lowcost[k] = 0; //遍历所有点后找到距离最近点，标记k已经加入
for (j = 1; j <= g.n; j++) //修改数组lowcost和closest
if (lowcost[j] != 0 && g.edges[k][j] < lowcost[j])
{
lowcost[j] = g.edges[k][j];
closest[j] = k;
}
}
}
分析Prim算法时间复杂度
Prim()算法中有两重for循环，时间复杂度为O(n^2),n为图的顶点个数。其执行时间与图中边数e无关，所以适合用稠密图求最小生成树。
1.3.2 Kruskal算法求解最小生成树
克鲁斯卡尔算法过程：
（1）置U的初值等于V（即包含有G中的全部顶点），TE（最小生成树的边集）的初值为空集（即图T中每一个顶点都构成一个连通分量）。
（2）将图G中的边按权值从小到大的顺序依次选取：
若选取的边未使生成树T形成回路，则加入TE；
否则舍弃，直到TE中包含(n-1)条边为止。
实现Kruskal算法的辅助数据结构
由于克鲁斯卡尔算法过程是对边的权重排序选边，因此我们需要另外一个存储结构来存储边的权重信息
typedef struct
{ int u; //边的起始顶点
int v; //边的终止顶点
int w; //边的权值
} Edge;
Edge E[MAXV];
Kruskal算法代码
分析Kruskal算法时间复杂度
连通图G有n个顶点、e条边，其时间复杂度为O(e^2)。该算法的执行时间只与图的边数有关，与顶点数无关，适用于稀疏图求最小生成树。
1.4 最短路径
1.4.1 Dijkstra算法求解最短路径
基于上述图结构，求解某个顶点到其他顶点最短路径。（结合dist数组、path数组求解）
最短路径与最小生成树不同：
最小生成树需要包含所有顶点， 而最短路径只考虑路径最短
1.从T中选取一个其距离值为最小的顶点W, 加入S
2.S中加入顶点w后，对T中顶点的距离值进行修改：
若加进W作中间顶点，从V0到Vj的距离值比不加W的路径要短，则修改此距离值；
3.重复上述步骤1，直到S中包含所有顶点，即S=V为止。
Dijkstra算法代码
void Dijkstra(MGraph g, int v)//源点v到其他顶点最短路径
{
int dist[MAXV], path[MAXV],s[MAXV];
int mindistance,u;//u为每次所选最短路径点
for (int i = 0; i < g.n; i++)//初始化各数组
{
s[i] = 0;//初始已选入点置空
dist[i] = g.edges[v][i];//初始化最短路径
if (dist[i] < INF) path[i] = v;
else path[i] = -1;//即无直接到源点V的边，因此初始化为-1
}
s[v] = 1;//源点入表示已选
for (int j = 0; j < g.n; j++)//要将所有点都选入需循环n-1次
{
mindistance = INF;//每次选之前重置最短路径
for (int i = 1; i < g.n; i++)//每次都遍历源点以外其他点来选入点
{
if (s[i] == 0 && dist[i] < mindistance)//在未选的点中找到最短路径
{
mindistance = dist[i];
u = i;//u记录选入点
}
}
s[u] = 1;//最后记录的u才为最后选入点
for (int i = 1; i < g.n; i++)//修正数组值
{
if (s[i] == 0)//！！仅需修改未被选入点的，已选入的既定
{
if (g.edges[u][i] < INF && dist[u] + g.edges[u][i] < dist[i])//先判断选入点到与该点存在时再比较判断
{
dist[i] = dist[u] + g.edges[u][i];
path[i] = u;
}
}
}
}
Dispath(dist, path, s, g.n, v);
}
Dijkstra算法的时间复杂度
1.时间复杂度为O(n^2）。
2.不适用带负权值的带权图求单源最短路径。
3. 不适用求最长路径长度：
最短路径长度是递增
顶点u加入S后，不会再修改源点v到u的最短路径长度
(按Dijkstra算法，找第一个距离源点S最远的点A，这个距离在以后就不会改变。但A与S的最远距离一般不是直连。)
1.4.2 Floyd算法求解最短路径
算法思路
有向图G=(V，E)采用邻接矩阵存储
二维数组A用于存放当前顶点之间的最短路径长度，分量A[i][j]表示当前顶点i到顶点j的最短路径长度。
递推产生一个矩阵序列A0，A1，…，Ak，…，An-1
Ak+1[i][j]表示从顶点i到顶点j的路径上所经过的顶点编号k+1的最短路径长度。
Floyd算法代码
void Floyd(MatGraph g) //求每对顶点之间的最短路径
{
int A[MAXVEX][MAXVEX]; //建立A数组
int path[MAXVEX][MAXVEX]; //建立path数组
int i, j, k;
for (i = 0; i < g.n; i++)
for (j = 0; j < g.n; j++)
{
A[i][j] = g.edges[i][j];
if (i != j && g.edges[i][j] < INF)
path[i][j] = i; //i和j顶点之间有一条边时
else //i和j顶点之间没有一条边时
path[i][j] = -1;
}
for (k = 0; k < g.n; k++) //求Ak[i][j]
{
for (i = 0; i < g.n; i++)
for (j = 0; j < g.n; j++)
if (A[i][j] > A[i][k] + A[k][j]) //找到更短路径
{
A[i][j] = A[i][k] + A[k][j]; //修改路径长度
path[i][j] = k; //修改经过顶点k
}
}
}
Floyd算法优势
1.弗洛伊德算法可以解决负权值的带权图，也可以解决求最长路径长度问题。
2.弗洛伊德算法是一种动态规划的算法，在规划的同时又对之前的内容进行调整修改。
1.5 拓扑排序
在一个有向图中，如果我们需要访问一个节点，要先把这个节点的所有前驱节点都访问过后，才能访问该节点。按照这样的顺序访问所有节点得到的序列叫做拓扑序列。在一个有向图中求一个拓扑序列的过程叫做拓扑排序。
拓扑排序思路
1.选择一个没有前驱结点的顶点，输出该顶点编号；
2.从有向图中删去此顶点，以及以他为起点的弧。这里的删除并不是在图结构中对该顶点的删除(物理删除)，我们还是最好保留原来的图结构，这里我们可以借用顶点的入度实现模拟删除。当我们要'删除'某个顶点及以他为起点的弧时，我们可以直接将该顶点所有邻接点的入度-1；
重复上述两步，直到找不到没有前驱的顶点。
伪代码
遍历邻接表
计算每个顶点的入度，存入头结点count成员中；
遍历图顶点
找到一个入度为0的顶点，入栈/队列/数组；
while(栈不为空)
出栈结点v，访问；
遍历v的所有邻接点
{
所有邻接点的入度-1；
若有邻接点入度为0，入栈/队列/数组；
}
拓扑排序代码
void TopSort(AdjGraph* G)//邻接表拓扑排序
{
ArcNode* p;
int stack[MAXV], top=-1;//顺序栈结构
int visitedcout = 0;//记录已得到的拓扑序列长度
int sequence[MAXV];//用于保存拓扑序列
for (int i = 0; i < G->n; i++)
{
G->adjlist[i].count = 0;
}
for (int i = 0; i < G->n; i++)//遍历每条链，记录每个节点的入度
{
p = G->adjlist[i].firstarc;
while (p)
{
G->adjlist[p->adjvex].count++;
p = p->nextarc;
}
}
for (int i = 0; i < G->n; i++)//先遍历图顶点，找出入度为0的点入栈
{
if (G->adjlist[i].count == 0)
{
top++; stack[top] = i;
}
}
int i = 0;
while (top!=-1)//接下来通过不断出栈过程中同时判断是否有点要入栈
{
sequence[i] = stack[top]; visitedcout++;//保存拓扑序列，并且记录已遍历点
p = G->adjlist[stack[top]].firstarc;//则该点的后继点入度都要减一
top--;//出栈
while (p)
{
G->adjlist[p->adjvex].count--;
if (G->adjlist[p->adjvex].count == 0)
{
top++; stack[top] = p->adjvex;
}
p = p->nextarc;
}
i++;
}
if (visitedcout == G->n)//则无环路得到拓扑序列，
{
cout << sequence[0];
for (int i = 1; i < G->n; i++)
{
cout << " " << sequence[i];
}
}
else cout << "error!";
}
用拓扑排序代码检查是否有环路
由上图可知，在一个环路中，我们是没办法找到入度为0的顶点。
同样的全局图来说，即使利用拓扑排序可以得到一定的拓扑序列，但只要存在环路，就不可能得到完整的拓扑序列
因此判断是否存在有环，只需记录一下得到的序列长度，与图的顶点数相比即可知，序列是否完整，是否就是拓扑序列
具体实现也已经在上述具体代码中体现
1.6 关键路径
什么叫AOE-网？
AOE-网（Activity ON Edge Network）：
用顶点表示事件，用有向边e表示活动，边的权c(e)表示活动持续时间。是带权的有向无环图
整个工程完成的时间为：从有向图的源点到汇点的最长路径。又叫关键路径
求关键路径
1.对有向图拓扑排序
2.根据拓扑序列计算事件(顶点)的ve, vl数组
3.计算关键活动的e[],l[[]。即边的最早、最迟时间
4.找e=l边即为关键活动
5.关键活动连接起来就是关键路径
2.PTA实验作业（4分）
2.1 六度空间（2分）
2.1.1 伪代码
定义结点数n和边数e；
定义顶点访问标记数组visited[MAXV]；
定义一个充当邻接矩阵的二维数组edgex[MAXV][MAXV]；
int main()
输入n和e
for i=1 to e do
输入边的关系；
将edgex[][]对应的点的值改为1；
end for
for i=1 to n do
初始化visited数组 ；
调用BFS函数，返回距离不超过5的结点数；
计算并输出百分比；
end for
int BFS(int v)
定义一个队列qu；
将v入队；
visited[v]=1；
while 队不空且距离小于6 do
取队首做临时调用点temp；
循环遍历与该结点相连接的点
if 结点未遍历 then
结点数++;
入队;
visited[i]=1;
记录位置tail=i;
end if
if temp==last then
记录当前层数的最后一个元素的位置 ;
结点层数加一;
end if
end while
return count;
- 代码
2.1.2 提交列表
2.1.3 本题知识点
- 创建图函数运用了头插法
- 运用BFS遍历（引入队列）
- 不仅要用广度遍历BFS，还要和递归相结合，分层运算。
2.2 村村通
2.2.1 伪代码
main（）函数
{
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
{
用二维数组代表邻接矩阵，并进行初始化。
}
for (i = 1; i <= e; i++)
{
给邻接矩阵赋值
}
调用普里姆算法；
}
Prim() 函数
{
for (i = 1; i <= n; i++)
{
给lowcost[]和closest[]置初值；
}
for (i = 1; i <n; i++)
{
给min赋初值（表示无穷）；
for (j = 1; j <= n; j++)
{
在（V-U）中找出离U最近的顶点k
k记录最近顶点的编号
}
for (j = 1; j <= n; j++)
{
对（V-U）中的顶点j 进行调整；
修改数组lowcost[]和closest[]；
}
}
输出num;
}
- 代码
2.2.2 提交列表
2.2.3 本题知识点
- main函数中运用二维数组代表邻接矩阵
- 运用Prim()算法
