DS博客作业04--图
| 这个作业属于哪个班级 | 数据结构--网络2011/2012 |
|---|---|
| 这个作业的地址 | DS博客作业04--图 |
| 这个作业的目标 | 学习图结构设计及相关算法 |
| 姓名 | 王历 |
0.PTA得分截图
1.本周学习总结（6分）
1.1 图的存储结构
图的存储主要分两种，一种邻接矩阵，另一种邻接表
用不同的方式存储图的信息
1.1.1 邻接矩阵
- 邻接矩阵的结构体定义
#define MAXV<最大顶点数>
typedef struct {
int no;//顶点编号
INfoType info;//顶点其他信息
}VertcxRype;
typedef struct {
int edges[MAXV][MAXV];//邻接矩阵
int n, e;//顶点数,边数
VertcxRype vexs[MAXV];//存放顶点信息
}MatGraph;
- 建图函数
void CreateMGraph(MGraph &g, int n, int e)//建图
{
//n顶点,e弧数
g.n = n;
g.e = e;
int i, j;
int a, b;//下标
for (i = 1; i <= n; i++)//先进行初始化
{
for (j = 1; j <= n; j++)
{
g.edges[i][j] = 0;
}
}
for (i = 1; i <= e; i++)//无向图
{
cin >> a >> b;
g.edges[a][b] = 1;
g.edges[b][a] = 1;
}
}
1.1.2 邻接表
- 邻接表的结构体定义
typedef struct ANode
{ int adjvex; //该边的终点编号
struct ANode *nextarc; //指向下一条边的指针
int info; //该边的相关信息，如权重
} ArcNode; //边表节点类型
typedef int Vertex;
typedef struct Vnode
{ Vertex data; //顶点信息
ArcNode *firstarc; //指向第一条边
} VNode; //邻接表头节点类型
typedef VNode AdjList[MAXV];
typedef struct
{ AdjList adjlist; //邻接表
int n,e; //图中顶点数n和边数e
} AdjGraph;
- 建图函数
void CreateAdj(AdjGraph *&G, int n, int e)//创建图邻接表
{
int i, j, a, b;
G = new AdjGraph;
for (i = 1; i <= n; i++)//邻接表头结点置零
{
G->adjlist[i].firstarc = NULL;
}
for (j = 1; j <= e; j++)//无向图
{
cin >> a >> b;
ArcNode *p,*q;
p = new ArcNode;
q = new ArcNode;
p->adjvex = b;//用头插法进行插入
q->adjvex = a;
p->nextarc = G->adjlist[a].firstarc;
G->adjlist[a].firstarc = p;
q->nextarc = G->adjlist[b].firstarc;
G->adjlist[b].firstarc = q;
}
G->n = n;
G->e = e;
}
1.1.3 邻接矩阵和邻接表表示图的区别
- 邻接矩阵的空间复杂度为0（n2），而邻接表的空间复杂度为0（n＋e）。
- 如果图中边的数目远远小于n2称作稀疏图，这时用邻接表表示比用邻接矩阵表示节省空间;
如果图中边的数目接近于n2,对于无向图接近于n*(n-1)称作稠密图,考虑到邻接表中要附加链域，采用邻接矩阵表示法为宜。因此当数据的边关系较为复杂时用邻接矩阵，稀疏时用领接表，内存空间不会浪费。
1.2 图遍历
1.2.1 深度优先遍历
对上无向图进行深度优先遍历，从A开始：
第1步：访问A。
第2步：访问B(A的邻接点，由储存结构决定的)。
第3步：访问G(B的邻接点)。 和B相连只有"G"(A已经访问过了)
第4步：访问E(G的邻接点)。 在第3步访问了B的邻接点G之后，接下来应该访问G的邻接点，即"E和H"中一个(B已经被访问过，就不算在内)。而由于E在H之前，先访问E。
第5步：访问C(E的邻接点)。 和E相连只有"C"(G已经访问过了)。
第6步：访问D(C的邻接点)。
第7步：访问H。因为D没有未被访问的邻接点；因此，一直回溯到访问G的另一个邻接点H。
第8步：访问(H的邻接点)F。
因此访问顺序是：A -> B -> G -> E -> C -> D -> H -> F
- 深度遍历代码
邻接矩阵
void DFS(MGraph g, int v)//邻接矩阵深度遍历
{
if (flag == 0)
{
cout << v;
flag = 1;
}
else
cout << " " << v; //输出顶点
visited[v] = 1;//标记已访问该节点
for (int i = 1; i <= g.n; i++)
{
if(g.edges[v][i] == 1 && visited[i] == 0)
{
DFS(g, i); //当前顶点与 i 顶点邻接且未被访问，递归搜索
}
}
}
邻接表
void DFS(AdjGraph *G, int v)//v节点开始深度遍历
{
visited[v] = 1;
ArcNode *p;//新建结点储存当前信息
if (flag == 0)
{
cout << v;
flag = 1;
}
else
{
cout << " " << v;
}
p = G->adjlist[v].firstarc;
while (p != NULL)//遍历当前链
{
if (visited[p->adjvex] == 0)//判断未访问过
{
DFS(G, p->adjvex);
}
p = p->nextarc;
}
}
- 深度遍历适用哪些问题的求解
可以找到两点之间的全部路径，以此可以找到迷宫问题
1.2.2 广度优先遍历
- 广度遍历代码
邻接矩阵
void BFS(MGraph g, int v)//广度遍历
{
int front;
queue<int>q;
q.push(v);
visited[v] = 1;
cout << v;
while (!q.empty())
{
front = q.front();
q.pop();
for (int i = 0; i < g.n; i++)
{
if (g.edges[front][i] == 1 && visited[i] == 0)
{
q.push(i);
visited[i] = 1;
cout << " " << i +;
}
}
}
}
邻接表
void BFS(AdjGraph* G, int v) //v节点开始广度遍历
{
int i, j;
int front;
queue<int>q;
ArcNode* p;
q.push(v);
visited[v] = 1;
cout << v;
while (!q.empty())
{
front = q.front();
q.pop();
p = G->adjlist[front].firstarc;
do
{
if (p != NULL&&visited[p->adjvex]==0)
{
q.push(p->adjvex);
visited[p->adjvex ] = 1;
cout << " " << p->adjvex ;
}
p = p->nextarc;
}while (p != NULL);
}
}
- 广度遍历适用哪些问题的求解。
最短路径
最远顶点
最短单词路径等
1.3 最小生成树
有n个顶点的连通网可以建立不同的生成树，每一颗生成树都可以作为一个连通网，当构造这个连通网所花的权值最小时，搭建该连通网的生成树，就称为最小生成树。
1.3.1 Prim算法求最小生成树
如图所示prim来生成最小数：
- 使用Prim算法要借助两个数组做工具，一个是lowcost[]//存放候选边，每个顶点到u中最小边。
另一个是closet[]//U中顶点的邻边顶点
代码
#define INF 32767
void Peim(MGraph g, int v)
{
int lowcost[MAXV];
int min;
int closest[MAXV];
int i, j, k;
for (i = 0; i < g.n; i++)
{
lowcost[i] = g.edges[v][i];//置初值，放入顶点v和所有顶带你的权值
closest[i] = v;
}
for (i = 1; i < g.n; i++)//n-1条边，进行n-1次
{
min = INF;
for (j = 0; j < g.n; j++)//遍历找到权值最小的
{
if (lowcost[j] != 0 && lowcost[j] < min)
{
min = lowcost[j];
k = j;//记录下标
}
}
lowcost[k] = 0;//lowcost为0表示该顶点已使用
for (j = 0; i < g.n; j++)//遍历所有顶点，比较找到的顶点与其他顶点的权值是否比原来小
{
if (lowcsost[j] != 0 && g.edges[k][j] < lowcost[j])
{
lowcost[j] = g.edges[k][j];
closest[j] = k;//改变权值和相邻的顶点
}
}
}
}
时间复杂的为O(n的平方)，其适用于边数较多的稠密图，其是通过比较边来找顶点，每次遍历找到一个顶点，
与顶点个数无关。适用于邻接矩阵，需要调用到权值，找到特定顶点间的权值。
1.3.2 Kruskal算法求解最小生成树
- 实现Kruskal算法的辅助数据结构是什么？其作用是什么？
vset[MAXV]集合辅助数组，2个顶点集合编号不同，加入边不会形成回路。
代码：
typedef struct {
int u; //边的起始顶点
int v; //边的终止顶点
int w; //边的权值
}Edge;
//改进的克鲁斯卡尔算法（使用了堆排序，并查集）
void Kruskal(AdjGraph* g)
{
int i,j,k,u1,v1,sn1,sn2;
UFSTree t[MAXSize]; //并查集，树结构
ArcNode* p;
Edge E[MAXSize];
k=1; // E数组的下标从1开始计
for(i = 0; i < g.n; i++)
{
p=g->adjlist[i].firstarc;
while(p!=NULL)
{
E[k].u=i;
E[k].v=p->adjvex;
E[k].w=p->weight;
k++;
p=p->nextarc;
}
}
HeapSort(E,g.e); //采用堆排序对E数组按权值递增排序
MAKE_SET(t,g.n); //初始化并查集树t
k=1; //k表示当前构造生成树的第几条边，初值为1
j=1; //E中边的下标，初值为1
while(k<g.n) //生成的边数为n-1
{
u1=E[j].u;
v1=E[j].v; //取一条边的头尾顶点编号u1和v1
sn1=FIND_SET(t,u1);
sn2=FIND_SET(t,v1); //分别得到两个顶点所属的集合编号
if(sn1!=sn2) //两顶点属不同集合
{
k++; //生成边数增1
UNION(t, u1, v1); //将u1和v1两个顶点合并
}
j++; //下一条边
}
}
- 分析Kruskal算法时间复杂度，适用什么图结构，为什么？
克鲁斯卡尔算法：按权值的递增顺序选择合适的边来构造最小生成树，选取的边不能使生成树形成回路。
克鲁斯卡尔算法的时间复杂度为O(elog2e)。由于它只与边的条数e有关，所以克鲁斯卡尔算法适合于稀疏图，图的存储结构为邻接表。
1.4 最短路径
1.4.1 Dijkstra算法求解最短路径
其解法如下：
- Dijkstra算法需要哪些辅助数据结构？
1）用一个一维数组dist[]存放最短路径长度，如dist[j]表示从源点 v->j的最短路径长度，其源点v是默认的。
2）从源点到其他点的最短路径有n-1条，一条最短路径用一个一维数组path表示。
- Dijkstra算法如何解决贪心算法无法求最优解问题？展示算法中解决的代码
void Dijkstra(MatGraph g, int v)
{
int dist[MAXV]，path[MAXV];
int s[MAXV];//判断是否访问
int mindis, i, j, u;
for (i = 0; i < g.n; i++)
{
dist[i] = g.edges[v][i];//初始化距离
s[i] = 0;
if (g.edges[v]]i] < INF)//v到i有边，初始化前继结点
{
path[i] = v;
}
else
{
path[i] = -1;
}
}
s[v] = 1;
for (i = 0; i < g.n; i++)//进行n-1次
{
mindis = INF;
for (j = 0; j < g.n; j++)//找到最小路径的长度
{
if (s[j] == 0 && dist[j] < mindis)
{
u = j;
mindis = dist[j];
}
}
s[u] = 1;
for (j = 0; j < g.n; j++)//修改改变结点后的路径长度
{
if (s[j] == 0)
{
if (g.edges[u][j] < INF&&dist[u] + g.edges[u][j] < dist[j])//修改此处可得到各种多种解法
{
dist[j] = dist[u] + g.edges[u][j];
path[j] = u;
}
}
}
}
}
- Dijkstra算法的时间复杂度
算法中涉及到要循环n次（顶点个数）直到所有顶点的最短路径都求出来，且在循环中又要循环n次以来选取不在S中（即在U中）
的顶点且具有求小最短路径长度的顶点，这里用了两层循环，考虑最坏情况，时间复杂度为O(n^2).
1.4.2 Floyd算法求解最短路径
- Floyed算法:
Floyd算法求解最短路径是每个顶点之间的，也可以Dijkstra调用n次，可能达到求解得出每个顶点之间的最短路径。两个时间的复杂性都是O(n^3)，不过Floyd形式上更简单点。
Floyd用一个二维数组A存放当前顶点最短路径长度，如：A[i][j]代表低你干点i到j之间的最短路径。
还有一个path二维数组，和之前Dijkstra算法中的path的用途一致，用来回溯寻找路径进过的顶点，Floyd中的是每个顶点的集合成二维数组。
- Floyd算法需要哪些辅助数据结构
二维数组A用于存放当前顶点之间的最短路径长度，即分量A[i][j]表示当前i->j的最短路径长度。 - Floyd算法优势，举例说明
Floyd算法的优势：它能一次求得任何两个节点之间的最短路径，而Dijkstra算法只能求得以特定节点开始的最短路径。
算法代码:
#include<stdio.h>
#include<stdlib.h>
#define max 1000000000
int d[1000][1000],path[1000][1000];
int main()
{
int i,j,k,m,n;
int x,y,z;
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++){
d[i][j]=max;
path[i][j]=j;
}
for(i=1;i<=m;i++) {
scanf("%d%d%d",&x,&y,&z);
d[x][y]=z;
d[y][x]=z;
}
for(k=1;k<=n;k++)
for(i=1;i<=n;i++)
for(j=1;j<=n;j++) {
if(d[i][k]+d[k][j]<d[i][j]) {
d[i][j]=d[i][k]+d[k][j];
path[i][j]=path[i][k];
}
}
for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
if (i!=j) printf("%d->%d:%d\n",i,j,d[i][j]);
int f, en;
scanf("%d%d",&f,&en);
while (f!=en) {
printf("%d->",f);
f=path[f][en];
}
printf("%d\n",en);
return 0;
}
1.5 拓扑排序
- 找一个有向图，并求其对要的拓扑排序序列
上有向图的一种拓扑序列1->2->4->3->5； - 实现拓扑排序代码，结构体如何设计？
结构体定义:
typedef struct
{
Vertex data;
int count;
ArcNode *firstarc;
}VNode;
代码:
void TopSort(AdjGraph *G)
{
int i，j;
int St[MAXV]，top=-1;
ArcNode *p;
for (i=0;i<G->n;i++)
G->adjlist[i].count=0;
for (i=0;i<G->n;i++)
{
p=G->adjlist[i].firstarc;
while (p!=NULL)
{
G->adjlist[p->adjvex].count++;
p=p->nextarc;
}
}
for (i=0;i<G->n;i++)
if (G->adjlist[i].count==0)
{
top++;
St[top]=i;
}
while (top>-1)
{
i=St[top];top--;
printf("%d ",i);
p=G->adjlist[i].firstarc;
while (p!=NULL)
{
j=p->adjvex;
G->adjlist[j].count--;
if (G->adjlist[j].count==0)
{
top++;
St[top]=j;
}
p=p->nextarc;
}
}
}
1.6 关键路径
- AOE网:带权的有向无环图，图中入度为0的顶点表示工程的开始事件，出度为0的顶点表示工程的结束事件，称这样的有向图为边表示活动的网(AOE网)。
通常每个工程都只有一个开始事件和结束事件，工程的AOE网都只有入度为0的顶点，称为源点，和一个出度为0的顶点，称为汇点。
-
关键路径:在AOE网中从源点到汇点的所有路径中最大路径长度的路径。
-
AOE网中一条关键路径各活动持续时间的总和，把关键路径上的活动称为关键活动。
2.PTA实验作业
2.1 六度空间
2.1.1 伪代码
int BFS(MGraph g,int v)//广搜
{
int w;
int tail,last;
int count=0,level=0;
int visited[MAXV]={0};
queue<int> q;
源点v入队列，同时标记v已访问过;
用last标记顶点v;
空间加一;
while(q不空) do
int j;
对头元素出队，w=q.front()，队列长度减一;
for j=1 to g.n do
if visit[j]==0&&g.edges[w][j] then
顶点j入队列，且标记已访问;
用tail标记顶点v，记录当前圈的最后一个顶点编号;
空间加一;
end if
end for
if 遍历一圈即 last == temp then
层数加一，并记录当前层的最后一个顶点;
if 遍历6层即level=6 then
break;
end while
}
2.1.2 提交列表
2.1.3 本题知识点
知识点：利用邻接矩阵进行广度遍历，通过广度遍历进行层数的判断，需要引入last和tail进行结点访问的层数判断以及结点层数的改变，通过比较last可以判断层数是否需要改变，并及时返回数量。
