1. 图的定义
一种多对多的数据关系，线性表和树是图的一种特殊的情况
图的分类：无向图、有向图
2.建立图
两种方案：
- 邻接矩阵法，使用一个二维数组表示一个图，对于一个无向图怎么节省空间。使用一个一位数组（只存储下三角的信息），利用其数字关系查找，
优点：直观、简单、好理解；
方便检查顶点之间是否存在边
方便找邻接点
方便计算度
缺点：对于稀疏图会浪费空间
typedef struct GNode *PtrToGNode;
struct GNode{
int Nv; /* 顶点数 */
int Ne; /* 边数 */
WeightType G[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */
};
typedef PtrToGNode MGraph; /* 以邻接矩阵存储的图类型 */
- 邻接表。对于每一个顶点，使用链表存储与其存在边的顶点。
对每一个节点开一个指针，数组的元素是一个头指针，对于每个节点
/* 邻接点的定义 */
typedef struct AdjVNode *PtrToAdjVNode;
struct AdjVNode{
Vertex AdjV; /* 邻接点下标 */
PtrToAdjVNode Next; /* 指向下一个邻接点的指针 */
};
/* 顶点表头结点的定义 */
typedef struct Vnode{
PtrToAdjVNode FirstEdge; /* 边表头指针 */
} AdjList[MaxVertexNum]; /* AdjList是邻接表类型 */
/* 图结点的定义 */
typedef struct GNode *PtrToGNode;
struct GNode{
int Nv; /* 顶点数 */
int Ne; /* 边数 */
AdjList G; /* 邻接表 */
};
typedef PtrToGNode LGraph; /* 以邻接表方式存储的图类型 */
图的初始化：
初始化一个有顶点但是没有边的图。
typedef int Vertex;//为了和整形区分开来，方便阅读代码，可以清楚的知道哪些数据是顶点。
MGraph CreatGraph(int VertexNum)
{
Vertex V, W;
MGraph Graph;
Graph = (MGraph)malloc(sizeof(struct GNode));
Graph->Nv = VertexNum;
Graph->Ne = 0;
for(V=0; V<Graph->Nv; V++)
for(W=0; W<Graph->Nv;W++)
Graph->G[V][W] = 0;//0表示不联通，或者是无穷大的数字
}
向图中插入边：
typedef struct ENode *PtrToENode;
struct ENode{
Vertex V1, V2;//有向边<V1, V2>；
WeightType Weight;
};
typedef PtrToENode Edge;
void InsertEdge(MGraph Graph, Edge E)
{
Graph->G[E->V1][E->V2] = E->Weight;
//如果是无向图还要插入对称位置的信息
}
优点：对于稀疏图节省空间
方便找任意顶点的邻接点
方便计算出度
不方便计算入度（用逆邻接表）
缺点： 查找两顶点间是否有边比较码麻烦
3. 图的遍历（DFS，BFS）
广度优先遍历
先将一个顶点的所有邻接点全部遍历；
再对其邻接点继续进行广度优先便利；
邻接表：时间复杂度 O（N+E）
邻接矩阵：时间复杂度O（N^2)
{
int queue[1010];
int l=0,r=0;//l是队头，r是队尾
queue[r++]=S;//插入到队尾
Visit (S);
Visited[S]=true;
PtrToAdjVNode tmp;//边表结点指向下一个临界点的指针，其实就是next
while(l!=r)//就是队不空
{
tmp=Graph->G[queue[l++]].FirstEdge;//找到当前顶点边表链表头指针,queue[l++]就是每次循环队头都要出队
while(tmp)
{
Vertex pos=tmp->AdjV;//pos为邻接点下标
if(!Visited[pos])//没访问就访问它
{
Visit(pos);
Visited[pos]=true;
queue[r++]=pos;//插入到队尾
}
tmp=tmp->Next;//指针指向下一个邻接点
}
}
}
深度优先遍历
从一个邻接点一直向邻接点的下一个邻接点进行深度优先遍历。
连通分量
- 无向图的极大连通子图
- 极大的顶点数，再增加一个顶点就不联通了
- 极大边数： 包含子图中所有顶点相连的所有边。
强连通：有向图中两个顶点之间存在双向路径（不一定是同一条路径，但是都能相互到达）这就是强联通
强联通图 任意两点都是强连通的，
弱连通图 将方向去掉后图可以变为强连通的，就是弱连通图。
六度空间
给定社交网络图，对每个节点计算符合六度空间理论的节点占节点总数的百分比，
- 对每个节点进行广度优先搜索。
- 累计访问的节点树
- 需要记录层数，只计算六层以内的节点数（关键点）
1、给每一个节点都增加一个layer记录其层数。
2、level记录当前节点的层数，last当前这一层访问的最后一个节点；在进行循环时，将当前节点的邻接点一个一个压入队列中，当最后一个元素进队时候，然后更新时将last更新成7，也就是相当于访问到这一个元素时候就要进入下一层了，然后这个时候7的所有元素都进入队列以后，last也就可以进行更新了，增加一个tail变量它指向下一层进队列的最后一个节点，
图的最短路
在网络中求两个不同顶点之间所有路径中m
1. 单源最短路径问题
无权图
按照递增的顺序找出到各个顶点的最短路，
- 从源点出发，将距离为1 的顶点收录进来
- 这一步可以直接在上一步的基础上向外走一步，将顶点收录进来，
- 直到所有节点都已经被访问过了，
定义一个dist[w]记录从源点到w的最短路经大小，通过这个值来判断是否已经被访问过。（所以在初始化时候，要将这个值定义为很明显的数字，可以是负数、无穷大）
另一个数组path[]记录路径
path[i]的数据是i的上一个顶点（也就是访问i 必须经过的顶点）
void Unweighted(Vertex S)
{
Enqueue(S,Q);
while(!IsEmpty(Q))
{
V = DeQueue(Q);
for(V的每个邻接点W)
{
if（dist[W]!=-1)
{
dist[W] = dist[V]+1;
path[W] = V;
Enqueue(W,Q);
}
}
}
}
将源点压入队列，然后访问邻接点，如果邻接点没有被访问，就将
有权图
有权图的最短路，不一定是经过顶点数最少的路径；
Dijkstra算法
- 令S= {源点S+已经确定了最短路径的顶点V）
- 对没有收录的顶点v，定义
dist[v]为s到v的最短路径长度，但该路径只经过s中的顶点（就是只经过已经收录进来的最短的顶点。
第一步：对于顶点v，初始化dist和path；
第二部：进入dijkstra算法：判断此时是否顶点已经全部收录；如果是则退出函数
第三步：从未收录的顶点中选择dist最小的；
第四步：对当前顶点的每个邻接点W进行访问：如果其被收录，就访问下一个邻接点，如果没有就进行下一个判断
第五步：判断dist[v]+v->w的距离是否小于dist[w]的距离，如果小于，就更新dist[w];并且更新path[w]=v；(意思就是经过v到w的距离更短，所以就要更新最短路）
第六步：继续下一个循环
void Dijkstra(Vertex S)
{
while(1)
{
V = 未收录顶点中dist最小的
if（这样的V不存在）
break;
collect[V] = true;
for(V的每一个邻接点W)
if(collect[w]== false)
if(dist[v]+E<v,w> < dist[w])
dist[w] = dist[v]+E<v,w>;
path[w] = v;
}
}
2. 多源最短路
Floyd算法
方法一：对每一个节点都调用一次单源最短路算法：时间复杂度O（V^3 +E×V)
方法二：Floyd算法：
void Floyd()
{
for(i=0;i<N;i++)
for(j=0;j<N;j++)
{
D[i][j] = G[i][j];
path[i][j] = -1;
}
for(k=0;k<N;k++)
for(i=0;i<N;i++)
for(j=0;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] = k;
}
}
}
图的生成树
最小生成树
- 是一棵树，：没有回路，顶点个数比边的个数多1
- 生成树：包含全部顶点，v-1条边都在图里
- 边的权重和最小
贪心算法：
每一步只要眼前最小的；
什么是好 ：权重最小边
需要约束；只能用图中有的边；正好用掉v-1条边；不能有回路
Prim算法 对稠密图比较合适
让一颗小树长大。
1、先选择一个点
2、在和树相关的边中选择一个最小的边，且其不会行成回路。
3、这时将相连的顶点收进；继续生长，
很多实际问题在用图来描述时候，需要给图的边加上权值，
/* 邻接矩阵存储 - Prim最小生成树算法 */
Vertex FindMinDist( MGraph Graph, WeightType dist[] )
{ /* 返回未被收录顶点中dist最小者 */
Vertex MinV, V;
WeightType MinDist = INFINITY;
for (V=0; V<Graph->Nv; V++) {
if ( dist[V]!=0 && dist[V]<MinDist) {
/* 若V未被收录，且dist[V]更小 */
MinDist = dist[V]; /* 更新最小距离 */
MinV = V; /* 更新对应顶点 */
}
}
if (MinDist < INFINITY) /* 若找到最小dist */
return MinV; /* 返回对应的顶点下标 */
else return ERROR; /* 若这样的顶点不存在，返回-1作为标记 */
}
int Prim( MGraph Graph, LGraph MST )
{ /* 将最小生成树保存为邻接表存储的图MST，返回最小权重和 */
WeightType dist[MaxVertexNum], TotalWeight;
Vertex parent[MaxVertexNum], V, W;
int VCount;
Edge E;
/* 初始化。默认初始点下标是0 */
for (V=0; V<Graph->Nv; V++) {
/* 这里假设若V到W没有直接的边，则Graph->G[V][W]定义为INFINITY */
dist[V] = Graph->G[0][V];
parent[V] = 0; /* 暂且定义所有顶点的父结点都是初始点0 */
}
TotalWeight = 0; /* 初始化权重和 */
VCount = 0; /* 初始化收录的顶点数 */
/* 创建包含所有顶点但没有边的图。注意用邻接表版本 */
MST = CreateGraph(Graph->Nv);
E = (Edge)malloc( sizeof(struct ENode) ); /* 建立空的边结点 */
/* 将初始点0收录进MST */
dist[0] = 0;
VCount ++;
parent[0] = -1; /* 当前树根是0 */
while (1) {
V = FindMinDist( Graph, dist );
/* V = 未被收录顶点中dist最小者 */
if ( V==ERROR ) /* 若这样的V不存在 */
break; /* 算法结束 */
/* 将V及相应的边<parent[V], V>收录进MST */
E->V1 = parent[V];
E->V2 = V;
E->Weight = dist[V];
InsertEdge( MST, E );
TotalWeight += dist[V];
dist[V] = 0;
VCount++;
for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
if ( dist[W]!=0 && Graph->G[V][W]<INFINITY ) {
/* 若W是V的邻接点并且未被收录 */
if ( Graph->G[V][W] < dist[W] ) {
/* 若收录V使得dist[W]变小 */
dist[W] = Graph->G[V][W]; /* 更新dist[W] */
parent[W] = V; /* 更新树 */
}
}
} /* while结束*/
if ( VCount < Graph->Nv ) /* MST中收的顶点不到|V|个 */
TotalWeight = ERROR;
return TotalWeight; /* 算法执行完毕，返回最小权重和或错误标记 */
}
Kruskal算法 将森林合并成树
初始状态下认为每一个节点都是一棵树
贪心的收录最小的边；
从边集合中将这个边删掉；
检查这个边是否构成回路，
如果构成回路就不收录（依然将其删除）
如果不构成就收录
检查是否完成
/* 邻接表存储 - Kruskal最小生成树算法 */
/*-------------------- 顶点并查集定义 --------------------*/
typedef Vertex ElementType; /* 默认元素可以用非负整数表示 */
typedef Vertex SetName; /* 默认用根结点的下标作为集合名称 */
typedef ElementType SetType[MaxVertexNum]; /* 假设集合元素下标从0开始 */
void InitializeVSet( SetType S, int N )
{ /* 初始化并查集 */
ElementType X;
for ( X=0; X<N; X++ ) S[X] = -1;
}
void Union( SetType S, SetName Root1, SetName Root2 )
{ /* 这里默认Root1和Root2是不同集合的根结点 */
/* 保证小集合并入大集合 */
if ( S[Root2] < S[Root1] ) { /* 如果集合2比较大 */
S[Root2] += S[Root1]; /* 集合1并入集合2 */
S[Root1] = Root2;
}
else { /* 如果集合1比较大 */
S[Root1] += S[Root2]; /* 集合2并入集合1 */
S[Root2] = Root1;
}
}
SetName Find( SetType S, ElementType X )
{ /* 默认集合元素全部初始化为-1 */
if ( S[X] < 0 ) /* 找到集合的根 */
return X;
else
return S[X] = Find( S, S[X] ); /* 路径压缩 */
}
bool CheckCycle( SetType VSet, Vertex V1, Vertex V2 )
{ /* 检查连接V1和V2的边是否在现有的最小生成树子集中构成回路 */
Vertex Root1, Root2;
Root1 = Find( VSet, V1 ); /* 得到V1所属的连通集名称 */
Root2 = Find( VSet, V2 ); /* 得到V2所属的连通集名称 */
if( Root1==Root2 ) /* 若V1和V2已经连通，则该边不能要 */
return false;
else { /* 否则该边可以被收集，同时将V1和V2并入同一连通集 */
Union( VSet, Root1, Root2 );
return true;
}
}
/*-------------------- 并查集定义结束 --------------------*/
/*-------------------- 边的最小堆定义 --------------------*/
void PercDown( Edge ESet, int p, int N )
{ /* 改编代码4.24的PercDown( MaxHeap H, int p ) */
/* 将N个元素的边数组中以ESet[p]为根的子堆调整为关于Weight的最小堆 */
int Parent, Child;
struct ENode X;
X = ESet[p]; /* 取出根结点存放的值 */
for( Parent=p; (Parent*2+1)<N; Parent=Child ) {
Child = Parent * 2 + 1;
if( (Child!=N-1) && (ESet[Child].Weight>ESet[Child+1].Weight) )
Child++; /* Child指向左右子结点的较小者 */
if( X.Weight <= ESet[Child].Weight ) break; /* 找到了合适位置 */
else /* 下滤X */
ESet[Parent] = ESet[Child];
}
ESet[Parent] = X;
}
void InitializeESet( LGraph Graph, Edge ESet )
{ /* 将图的边存入数组ESet，并且初始化为最小堆 */
Vertex V;
PtrToAdjVNode W;
int ECount;
/* 将图的边存入数组ESet */
ECount = 0;
for ( V=0; V<Graph->Nv; V++ )
for ( W=Graph->G[V].FirstEdge; W; W=W->Next )
if ( V < W->AdjV ) { /* 避免重复录入无向图的边，只收V1<V2的边 */
ESet[ECount].V1 = V;
ESet[ECount].V2 = W->AdjV;
ESet[ECount++].Weight = W->Weight;
}
/* 初始化为最小堆 */
for ( ECount=Graph->Ne/2; ECount>=0; ECount-- )
PercDown( ESet, ECount, Graph->Ne );
}
int GetEdge( Edge ESet, int CurrentSize )
{ /* 给定当前堆的大小CurrentSize，将当前最小边位置弹出并调整堆 */
/* 将最小边与当前堆的最后一个位置的边交换 */
Swap( &ESet[0], &ESet[CurrentSize-1]);
/* 将剩下的边继续调整成最小堆 */
PercDown( ESet, 0, CurrentSize-1 );
return CurrentSize-1; /* 返回最小边所在位置 */
}
/*-------------------- 最小堆定义结束 --------------------*/
int Kruskal( LGraph Graph, LGraph MST )
{ /* 将最小生成树保存为邻接表存储的图MST，返回最小权重和 */
WeightType TotalWeight;
int ECount, NextEdge;
SetType VSet; /* 顶点数组 */
Edge ESet; /* 边数组 */
InitializeVSet( VSet, Graph->Nv ); /* 初始化顶点并查集 */
ESet = (Edge)malloc( sizeof(struct ENode)*Graph->Ne );
InitializeESet( Graph, ESet ); /* 初始化边的最小堆 */
/* 创建包含所有顶点但没有边的图。注意用邻接表版本 */
MST = CreateGraph(Graph->Nv);
TotalWeight = 0; /* 初始化权重和 */
ECount = 0; /* 初始化收录的边数 */
NextEdge = Graph->Ne; /* 原始边集的规模 */
while ( ECount < Graph->Nv-1 ) { /* 当收集的边不足以构成树时 */
NextEdge = GetEdge( ESet, NextEdge ); /* 从边集中得到最小边的位置 */
if (NextEdge < 0) /* 边集已空 */
break;
/* 如果该边的加入不构成回路，即两端结点不属于同一连通集 */
if ( CheckCycle( VSet, ESet[NextEdge].V1, ESet[NextEdge].V2 )==true ) {
/* 将该边插入MST */
InsertEdge( MST, ESet+NextEdge );
TotalWeight += ESet[NextEdge].Weight; /* 累计权重 */
ECount++; /* 生成树中边数加1 */
}
}
if ( ECount < Graph->Nv-1 )
TotalWeight = -1; /* 设置错误标记，表示生成树不存在 */
return TotalWeight;
}
时间复杂度：E×logE
拓扑排序
解决类似排课问题；
AOV网络，活动表现在顶点上；合理的一定的有向并且无环（DAG）
/* 邻接表存储 - 拓扑排序算法 */
bool TopSort( LGraph Graph, Vertex TopOrder[] )
{ /* 对Graph进行拓扑排序, TopOrder[]顺序存储排序后的顶点下标 */
int Indegree[MaxVertexNum], cnt;
Vertex V;
PtrToAdjVNode W;
Queue Q = CreateQueue( Graph->Nv );
/* 初始化Indegree[] */
for (V=0; V<Graph->Nv; V++)
Indegree[V] = 0;
/* 遍历图，得到Indegree[] */
for (V=0; V<Graph->Nv; V++)
for (W=Graph->G[V].FirstEdge; W; W=W->Next)
Indegree[W->AdjV]++; /* 对有向边<V, W->AdjV>累计终点的入度 */
/* 将所有入度为0的顶点入列 */
for (V=0; V<Graph->Nv; V++)
if ( Indegree[V]==0 )
AddQ(Q, V);
/* 下面进入拓扑排序 */
cnt = 0;
while( !IsEmpty(Q) ){
V = DeleteQ(Q); /* 弹出一个入度为0的顶点 */
TopOrder[cnt++] = V; /* 将之存为结果序列的下一个元素 */
/* 对V的每个邻接点W->AdjV */
for ( W=Graph->G[V].FirstEdge; W; W=W->Next )
if ( --Indegree[W->AdjV] == 0 )/* 若删除V使得W->AdjV入度为0 */
AddQ(Q, W->AdjV); /* 则该顶点入列 */
} /* while结束*/
if ( cnt != Graph->Nv )
return false; /* 说明图中有回路, 返回不成功标志 */
else
return true;
}
关键路径问题
AOE网络每一条边代表一个网络
一般用于安排项目的工序
关键路径由绝对不允许延误的活动组成的路径。
旅游规划
城市为节点，公路作为边
权重1：距离
权重2：收费
首先在距离上找最短路，如果这个路不止一条就找收费最小的路。
首先运用单源最短路，
等距离时按收费进行更新，
其他的推广：
要求最短路径有多少条
加入count[s]
如果找到更短路，count[w] = count[v]
如果找到了等长的路径时 count[w] = count[v]+count[w]
要求边数最少的最短路
将cost[s] = 0
如果找到更短路时，
扫一扫
644
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
