【数据结构】3.图

最新推荐文章于 2022-01-03 16:18:58 发布

心是蓝图

最新推荐文章于 2022-01-03 16:18:58 发布

阅读量247

点赞数

分类专栏： # 数据结构

本文链接：https://blog.csdn.net/qq_42505705/article/details/89288276

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

声明：本文为个人在同步学习中国大学MOOC《数据结构(陈越、何钦铭)》(视频地址：https://www.icourse163.org/learn/ZJU-93001#/learn/content) 结合课件PPT所做的个人学习笔记，未经授权，禁止转载！但是您可以关注我的公众号“分享猿”，来获取此数据结构笔记（包括word版，pdf版，以及MarkDown版本），以及课件PPT，您需要关注后回复关键词“N01”获取资源！

获取此数据结构笔记（包括word版，pdf版，以及MarkDown版本），以及课件PPT，pdf书籍等资源，请关注本人公众号后回复关键词“N02”获取资源！

若要获取更多OpenCV，数字图像处理，python，深度学习，机器学习，计算机视觉等高清PDF以及更多有意思、实用的分享，可搜一搜微信公共号 “分享猿” 免费获取资源。也可扫描下面的二维码关注，期待你的到来~
在这里插入图片描述

本节思维导图
使用软件：Xmind

在这里插入图片描述

一丶图的基本概念

1.1 定义

不同于树的一对多关系，图表示多对多的关系。
包含：

一组顶点：通常用V (Vertex) 表示顶点集合
.一组边：通常用E (Edge) 表示边的集合
- 边是顶点对：(v, w) ∈E ，其中v, w ∈V
- 有向边< v, w> 表示从v指向w的边（单行线）
- 考虑重边和自回路
  vw
  vw

1.2 一些术语

无向图
有向图
简单图 - 无重边
邻接点
路径 - v到w顶点的集合
简单路径 - 路径中顶点不重复出现
无向完全图 - 任两点可邻接
有向完全图
顶点的度 - 包括出度，入度
稠密图，稀疏图
权图，网图
子图
连通图 - 任两点连通，单向
强连通图 - 任两点连通，双向
连通分量 - 无向图的极大连通子图
强连通分量 - 有向图的极大强连通子图
生成树 - 包含连通图G的全部n个顶点及n-1边的连通子图都是G的生成树
生成森林

二、图的存储结构

2.1邻接矩阵

邻接矩阵G[N][N]——N个顶点从0到N-1编号
在这里插入图片描述

邻接储存的优点及缺点

优点：

直观、简单、好理解
方便检查任意一对顶点间是否存在边
方便找任一顶点的所有“邻接点”（有边直接相连的顶点）
方便计算任一顶点的“度”（从该点发出的边数为“出度”，指向该点的边数为“入度”）

缺点：

浪费空间——存稀疏图（点很多而边很少）有大量无效元素
- 对稠密图（特别是完全图）还是很合算的
费时间——统计稀疏图中一共有多少条边

代码实现
https://blog.csdn.net/weixin_44537961/article/details/89047716

2.2邻接表

G[N]为指针数组，对应矩阵每行一个链表，只存非0元素
对于权图，结构中要增加权重的域。
在这里插入图片描述

代码实现https://blog.csdn.net/zhangxiangDavaid/article/details/38323593

2.3 图的遍历

深度优先搜索 DFS

简单概括：沿着某个方向一直访问到叶节点，循环（访问上一个节点，如果上一个结点不为空，则继续以此节点扩展深度，直到叶节点）。
在这里插入图片描述
以上图树为例，DFS访问路线如下:
A->B->D->B->E->H->E->B->A->C->F->I->F->C->G

广度优先搜索 BFS

简答概括：以首节点向四周扩展，循环（依次访问其每个邻接点，并依次放入队列直至所有邻接点都被访问，从队列中取出一个元素）

以上图树为例，BFS访问路线如下:
A->B->C->D->E->F->G->H->I
在这里插入图片描述

2.4 最短路径

无权图 - v到w边数最少的路径
有权图 - v到w各边权的和最小的路径

2.4.1 单源最短路径 - 某源点到其他各订单的最短路径

①无权图的单源最短路径

voidUnweighted( 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); 
			} 
	} 
}

dist[W] = S到W的最短距离 
dist[S] = 0 
path[W] = S到W的路上经过的某顶点

类似广度优先搜索

②有权图的单源最短路径

Dijistra算法，由于无权图是特殊的有权图(权为1)，所以此算法对有权图和无权图均适用

voidDijkstra( Vertex s ) 
{while(1) { 
	V = 未收录顶点中dist最小者; 
	if( 这样的V不存在) 
		break; 
	collected[V] = true; 
	for ( V 的每个邻接点W ) 
		if( collected[W] == false ) 
			if( dist[V]+E<V,W>< dist[W] ) { 
				dist[W] = dist[V] + E<V,W>; 
				path[W] = V; 
			} 
	} 
}/* 不能解决有负边的情况*/

代码实现：https://blog.csdn.net/txl16211/article/details/44980923

2.4.2 多源最短路径 - 每对顶点间最短距离

①直接将单源最短路径算法调用n(顶点数)遍 - 适用于稀疏图
②Floyd算法 - 适用于稠密图

/* Floyd算法 */
voidFloyd() 
{  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; 
				}
}

详细介绍
https://blog.csdn.net/xianpingping/article/details/79947091
.

2.5 最小生成树

2.5.1定义

最小/生成/树，逐一解释含义

树
- 无回路
- V个顶点一定有V-1个边
生成
- 包含全部顶点
- V-1条边都在图中
最小
- 边的权重和最小
  备注：向生成树中任加一条边一定形成回路；

2.5.2 Prim算法

思想：在不行成回路的情况下，从第一个节点/枝干向权最小的方向扩展
伪代码
图解
语言描述

/* 邻接矩阵存储 - 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;   /* 算法执行完毕，返回最小权重和或错误标记 */
}

2.5.3 Kruskal算法

思想：在不行成回路的情况下，依次找到最小权重的边至V-1条
伪代码
图解
语言描述

/* 邻接表存储 - 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;
}

两种算法的详细介绍：https://blog.csdn.net/qq_35644234/article/details/59106779

2.6 拓扑排序

AOV网（Activity On Vertex Network )
网：带权图。若在带权的有向图中，以顶点表示事件，以边（或者弧）表示活动，弧的权值表示活动的开销，则此带权有向图称为用边表示活动的网，简称：（AOV网（Activity On Vertex Network )。
在这里插入图片描述
拓扑排序的实现
1、从网中选择一个没有前驱的顶点（入度为0）并且输出它。
2、从网中删去该顶点，并且删去从该顶点发出的全部有向边
3、重复上述两步，直到剩余的网中不存在没有前驱的顶点为止。

伪代码

voidTopSort() 
{ for( 图中每个顶点V ) 
	if( Indegree[V]==0 ) 
		Enqueue( V, Q ); 
  while( !IsEmpty(Q) ) { 
	V = Dequeue( Q ); 
	输出V，或者记录V的输出序号; cnt++; 
	for( V 的每个邻接点W ) 
		if( ––Indegree[W]==0 ) 
			Enqueue( W, Q ); 
  } 
  if( cnt!= |V| ) 
	  Error( “图中有回路”); 
}

2.7关键路径

关键路径
如果用AOV网表示一个工程，那么正常情况下工程只有一个开始点和一个结束点，因此AOV网中只有一个入度为0的点，称为源点；一个出度为0的点，称为汇点。
AOV网具有以下两个性质：

1、只有在某顶点所代表的事情发生后，从该顶点出发的弧所代表的活动才能开始。
2、只有在进入某顶点的各弧所代表的活动都已经结束时，该顶点所代表的事情才能发生。

由于AOV网中的某些活动可以并行进行，所以完成整个工程最短时间是从源点到汇点的最大路径长度。具有最大路径长度的路径称为关键路径，关键路径上的活动称为关键活动。

心是蓝图

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【数据结构】3.图

一丶图的基本概念1.1 定义不同于树的一对多关系，图表示多对多的关系。包含：一组顶点：通常用V (Vertex) 表示顶点集合.一组边：通常用E (Edge) 表示边的集合边是顶点对：(v, w) ∈E ，其中v, w ∈V有向边< v, w> 表示从v指向w的边（单行线）考虑重边和自回路vwvw1.2 一些术语无向图有向图简单图 - 无重边邻...
复制链接

扫一扫