1、图
1）图 Graph
是一种非线性的数据结构
节点之间的关系是任意的，图中任意的两个数据元素之间都有可能相关
图的形式化描述
Graph = ( V, R )
其中 V = { Vi | Vi属于图中的数据元素(i=0,1,2,3,...n-1),顶点的集合，当n=0时，V是空集}
R = { <vi,vj> | vi,vj都属于集合V，且vi和vj之间存在路径的 0<= i,j <= n-1}
是顶点之间的关系的集合
<vi,vj>为顶点vi到顶点vj之间是否存在路径的判定条件
即 如果顶点vi到顶点vj之间是存在路径的，那么<vi,vj>属于集合R
图是一个二元组，是 顶点 以及 顶点之间的路径的 集合
2）分类
无向图
路径 --> 边
如果<vi,vj>存在，那么<vj,vi>就一定存在
有向图
路径 --> 弧
如果<vi,vj>存在，那么<vj,vi>就不一定存在
3）网
如果在图的关系<vi,vj>或者<vj,vi>上 附加一个权值w，称w为弧或者边上的权
带权值的图 称为 网
4）顶点的度
顶点的边或者弧的条数
有向图 分为 ：入度 和 出度
5）图的物理存储结构
存储图需要存储哪些东西？
顶点的集合 --> 数据元素的集合
关系的集合 --> 顶点与顶点之间的关系
"数据表示法" 邻接矩阵
"邻接表"
"十字链表"
"邻接多重表"
邻接点：
在无向图中，如果存在一条边(vi,vj),则vi和vj互为邻接点
在有向图中，如果存在一条弧<vi,vj>，则vi是该弧的起点，vj是弧的终点
称 vj是vi的邻接点
() --> 路径
<> --> 关系
2、"数组表示法" 邻接矩阵 Adjacency matrix
G = (V, R)
用两个数组来保存图G
一个 一维数组 来存储顶点的集合
一个 二维数组 来存储图G中 顶点之间的关系
typedef char VType; //顶点的数据类型
typedef int AdjType; //权值的类型
#define MAXN 256
struct Graph
{
VType V[MAXN]; //一维数组 来存储顶点的集合
AdjType Adj[MAXN][MAXN]; //二维数组 来存储图G中 顶点之间的关系
int vex_num; //顶点的个数
int arc_num; //图中 弧的个数
};
3、"邻接表" Adjacency List
数组 + 链表
所谓 邻接表就是将图中的每一个顶点v 和 由v出发的边或者弧 构成的一个单链表
邻接表 是 图的一种链式的存储结构
struct adj //邻接表 节点的类型
{
int termIndex; //边的终点在顶点数组中的下标
int w; //权值
struct adj *next; //指向下一个点
};
struct Vertex //顶点结构体数组的类型
{
VType data;
struct adj *first;
};
struct Vertex graph[MAXN]; //顶点结构体数组
4、代码实现
邻接矩阵 方法实现图
typedef char VType; //顶点的数据类型
typedef int AdjType; //权值的类型
#define MAXN 256
struct Graph
{
VType V[MAXN]; //一维数组 来存储顶点的集合
AdjType Adj[MAXN][MAXN]; //二维数组 来存储图G中 顶点之间的关系
int vex_num; //顶点的个数
int arc_num; //图中 弧的个数
};
Graph.c / Graph.h
练习：
1）创建一个图
//创建一个图
struct Graph * create_graph()
{
//1.创建一个空图,把关系集合初始化
struct Graph *g = malloc(sizeof(struct Graph));
g->vex_num = 0;
g->arc_num = 0;
//把关系的集合否赋值为无穷大/小 INT_MAX / INT_MIN
//或者 自定义一个宏 #define ADJ_MAX 65535
int i,j;
for( i=0; i<MAXN; i++ )
{
for(j=0; j<MAXN; j++ )
{
g->Adj[i][j] = ADJ_MAX;
}
}
//2.根据用户的输入 初始化顶点的集合
printf("please input the Vertex value (eg: abcdefg ) :\n");
char vex[MAXN] = {0};
scanf("%s", vex);
getchar();//吸收掉回车
i=0;
while( vex[i] )
{
g->V[i] = vex[i]; //把顶点数据 保存到图g中顶点集合V
g->vex_num ++ ;
i++;
}
//3.根据用户的输入 初始化邻接矩阵（关系的集合：顶点s到顶点d的权值为w）
printf("please input the Relations value (NO space ! eg: ab15 ac2 ad12 ) :\n");
while(1)
{
VType s,d;
int w;
scanf("%c%c%d", &s, &d, &w ); //注意：输入时一组数据中不用空格隔开
getchar(); //吸收掉回车
if( s == '#' || d == '#' ) //人为约定退出条件
{
break;
}
//找出顶点s,d 在顶点集合V中对应的下标
int si = find_index( g->V, g->vex_num, s );
int di = find_index( g->V, g->vex_num, d );
//保存关系 权值
if( si != -1 && di != -1 )
{
g->Adj[si][di] = w;
g->arc_num ++ ;
}
}
return g;
}
//打印一个图
void print_graph(struct Graph *g)
{
//打印顶点数组
int i,j;
putchar('\t');
for(i=0; i<g->vex_num; i++ )
{
printf("%c\t", g->V[i] );
}
putchar('\n');
//打印关系
for( i=0; i<g->vex_num; i++ )
{
printf("%c:\t", g->V[i] );
for( j=0; j<g->vex_num; j++ )
{
if( g->Adj[i][j] == ADJ_MAX )
{
printf("-\t");
}
else
{
printf("%d\t", g->Adj[i][j] );
}
}
putchar('\n');
}
}
5、图的遍历
图的遍历 是树的遍历的推广，是按照某种规则访问图中的每一个顶点，且只访问一次
也就是 将网状结构按照某种规则线性化的过程
对于图的遍历： "深度优先搜索" 和 "广度优先搜索"
1）深度优先搜索 DFS： Depth First Search ---》 类似于树的先序遍历
设 初始时，图中各个顶点都是未被访问的，
从图中的某个顶点出发(设为v0)，先访问v0，
然后再找v0的邻接点vi，如果vi未被访问，那么就按照同样的方式去访问vi，
再去搜索vi的邻接点 ... (深度优先搜索)
如果该顶点所有的邻接点都被访问完毕，则回溯到它的上一个顶点
然后再去以该顶点 以"深度优先搜索"的方式 去搜索其余的邻接点 ...
直到那个访问的顶点 全部都被访问完毕
DFS( g, v ) --> 从图g中以顶点v出发，按照深度优先搜索的算法
去访问v的邻接点，v的邻接点v1,v2,v3,...vn
v未被访问
visit v
if( not visit v1 )
{
visit v1
DFS( g, v1 ); //按照同样的规则DFS去访问v1的邻接点
}
if( not visit v2 )
{
visit v2
DFS( g, v2 ); //按照同样的规则DFS去访问v2的邻接点
}
...
if( not visit vn )
{
visit vn
DFS( g, vn ); //按照同样的规则DFS去访问vn的邻接点
}
代码实现：
// ============= DFS 深度优先搜索 ====================================
int visit[MAXN]; //访问 标志位数组，表示下标对应的顶点是否以及访问
//0表示没有访问，1表示已经被访问了
//在图g中，找到v的第一个邻接点的下标
int FirstAdjVex(struct Graph *g, int v)
{
//遍历，判断与各个顶点是否存在路径
int i;
for( i=0; i<g->vex_num; i++ )
{
if( g->Adj[v][i] != ADJ_MAX ) //关系存在
{
return i;
}
}
return -1;
}
//在图g中，找到v的邻接点w的下一个邻接点的下标
int NextAdjVex(struct Graph *g, int v, int w)
{
int i;
for( i=w+1; i<g->vex_num; i++ )
{
if( g->Adj[v][i] != ADJ_MAX ) //关系存在
{
return i;
}
}
return -1;
}
//深度优先搜索
void DFS(struct Graph *g, int v)
{
//1.先访问v
visit[v] = 1;
printf("%c ", g->V[v] );
//2.找到v的第一个邻接点的下标w，如果x未被访问
//就按照 深度优先搜索的方式去访问w
//for( 取v的第一个邻接点w; w != -1; 再取下一个邻接点 )
int w;
for( w=FirstAdjVex(g, v); w != -1; w=NextAdjVex(g, v, w) )
{
if( visit[w] == 0 ) //未被访问
{
DFS( g, w );
}
}
}
//以深度优先搜索的算法，去遍历图g中的每一个顶点
void DFS_Traverse(struct Graph *g)
{
//先把标志位全部置0
int i;
for( i=0; i<g->vex_num ; i++ )
{
visit[i] = 0;
}
printf("\n------- DFS --------\n");
//深度优先搜索去遍历图中的每一个顶点
for( i=0; i<g->vex_num; i++ )
{
if( visit[i] == 0 )
{
DFS( g, i); //从顶点i出发，按照深度优先搜索的算法，去遍历图g中的每一个顶点
}
}
putchar('\n');
}
2）广度优先搜索 BFS：Breath First Search ---》 类似于树的层次遍历
设 初始时，图中各个顶点都是未被访问的，
从图中的某个顶点v0出发，去访问它，并依次访问完v0的所有的邻接点
然后 再从这些已经访问的邻接点中，仍然按照广度优先搜索 的方式去访问它的邻接点...
直到所有的顶点全部访问完毕
用到 队列的思想
入队元素 先访问再入队
出队元素 把它所有未被访问的邻接点入队
// ============= BFS 广度优先搜索 ====================================
//广度优先搜索
void BFS( struct Graph * g, int v )
{
//初始化一个队列 CircleQueue.c / CircleQueue.h
struct CircleQueue * cq = InitQueue();
//访问v，然后再把v入队（只需要入队顶点的下标）
visit[v] = 1;
printf("%c ", g->V[v] );
EnQueue( cq, v ); //把v入队
while( ! IsEmpty(cq) ) //队列不为空
{
//出队，获取该顶点的下标i，把i所有的未被访问的邻接点入队
int i = 0;
DeQueue( cq, &i );
//for( 取i的第一个邻接点w; w != -1; 再取下一个邻接点 )
int w = 0;
for( w=FirstAdjVex(g, i); w != -1 ; w=NextAdjVex(g,i,w) )
{
if( visit[w] == 0 )
{
//先访问，再入队
visit[w] = 1;
printf("%c ", g->V[w] );
EnQueue(cq, w);
}
}
}
//销毁队列
DestroyQueue(cq);
}
//以广度优先搜索的算法，去遍历图
void BFS_Traverse(struct Graph *g)
{
//先把标志位全部置0
int i;
for( i=0; i<g->vex_num; i++ )
{
visit[i] = 0;
}
//以广度优先搜索的算法，去遍历图
printf("\n------- BFS --------\n");
for( i=0; i<g->vex_num; i++ )
{
if( visit[i] == 0 )
{
BFS( g , i ); //以顶点i出发，按照广度优先搜索的方法去访问
}
}
putchar('\n');
}
6、最短路径问题
解决带权有向图中 两个顶点之间的最短距离的问题
两个经典的算法：
Dijkstra（迪杰斯特拉）算法 和 Floyd（弗洛伊德）算法
都是基于比较 v0vi 与 v0vk+vkvi 的大小的基本算法
Dijkstra（迪杰斯特拉）算法：使用两层循环 计算一个顶点到其他各个顶点的最短距离
Floyd（弗洛伊德）算法 ：使用三层循环 计算每一个顶点到其他各个顶点的最短距离
Dijkstra（迪杰斯特拉）算法：
是解决网络中任意的顶点(源点)出发，
求它到其他的各个顶点(终点)的最短距离
基本思想：
如果顶点vi --》顶点vj的最短距离是经过顶点vk的
那么 <vi,vj>路径中，顶点vi到顶点vk的路径 一定是vi到vk的最短路径
需要三个辅助变量：
v：表示以v为下标的顶点（源点）
(1)向量 S[n] 标记最短路径是否已经求出来了 （标志位数组）
S[i] == 1 源点v到顶点i的最短距离已经被求出来了
S[i] == 0 源点v到顶点i的最短距离还没有被求出来
初始时 S[v] = 1, 其他的S[i] = 0
(2)向量 dist[n]
dist[i] --> 存放 源点v 到 顶点i 的最短距离的长度
初始时，dist[i]
<v,vi>上的权为w，如果p(v,vi)存在，也就是v到vi有一条直接路径
如果(v,vi)不存在，dist[i] = 无穷大 ，也就是说 v到vi没有直接路径
(3)向量 path[n]
path[i] --> 存放 源点v 到 顶点i 的最短路径(v -> ... -> vi )
初始时 path[i] = {v}
算法：
1)把源点v 到 其他各个顶点的第一条最短路径长度（直接路径）求出来 //初始化dist[n]
2)dist[m] = MIN( dist[i] | i=0,1,2,... 且S[i] == 0 )
表示在所有未被求出来的最短路径中 找出一条最短的，其长度当作成当前求出的最短路径
- 对于所有的 S[i] == 0 （源点v到顶点i的最短距离还没有被求出来）
if( dist[m] + <m, i> < dist[i] )
{
更新 dist[i] = dist[m] + <m, i> ;
}
重复 2) 和 3) ....
/*
用Dijkstra算法 求从v出发到其他各个顶点的最短距离
*/
//================== Dijkstra算法 ======================
int S[MAXN]; //是否已经求出最短路径，标志位数组
int dist[MAXN]; //存放源点到其他顶点的最短路径长度
int path[MAXN]; //存放源点到终点i的最短路径，时利用哪些最优点更新的
/*
用Dijkstra算法 求从v出发到其他各个顶点的最短距离
*/
void Dijkstra(struct Graph *g, int v)
{
//1.初始化辅助变量
int i;
for( i=0; i<g->vex_num; i++ )
{
S[i] = 0;
dist[i] = g->Adj[v][i];
path[i] = v;
}
S[v] = 1;
dist[v] = 0;
//在所有未被求出来的最短路径中 找出一条最短的，其长度当作成当前求出的最短路径
int min; //保存最小值
int min_i; //最优点的下标
int j; //寻找最短路径的次数，每次找一条
for( j=0; j<g->vex_num; j++ )
{
//2.求出当前的最优点 （在dist[n]找最小值）
min = ADJ_MAX;
for( i=0; i<g->vex_num; i++ )
{
if( S[i] == 0 && dist[i] <= min )
{
min = dist[i];
min_i = i;
}
}
S[min_i] = 1;
//3.根据最优的顶点去比较，更新其他的dist
for( i=0; i<g->vex_num; i++ )
{
if( S[i] == 0 )
{
// dist[m] + <m, i> < dist[i]
if( dist[min_i]+ g->Adj[min_i][i] < dist[i] )
{
//更新
dist[i] = dist[min_i]+ g->Adj[min_i][i];
path[i] = min_i;
}
}
}
}
}
// a --> b : 15
void print_dist(struct Graph *g, int v)
{
printf("\n ------ dist[n] ------ \n");
int i;
for( i=0; i<g->vex_num; i++ )
{
printf("%c --> %c : %d\n", g->V[v], g->V[i], dist[i] );
}
}
// a --> g : a c f d g
void print_path(struct Graph *g, int v)
{
printf("\n ------ path[n] ------ \n");
int i;
for( i=0; i<g->vex_num; i++ )
{
if( dist[i] == ADJ_MAX )
{
printf("%c --> %c : is no path !!!\n",g->V[v], g->V[i]);
continue;
}
printf("%c --> %c : ",g->V[v], g->V[i]);
int j = path[i];
char a[MAXN];
int count = 0;
a[count++] = g->V[i];
while(1)
{
a[count++] = g->V[j];
if( j == v )
{
break;
}
j = path[j];
}
int k;
for( k=count-1; k>=0; k-- )
{
printf("%c ", a[k] );
}
putchar('\n');
}
}