图是由顶点的有穷非空集合和顶点之间边的集合组成,通常表示为G(V,E),其中G表示一个图,
V是图G中顶点的集合,E是G中边的集合。
· 图中的数据元素,称之为顶点
· 图结构中不允许没有顶点
· 任意两个顶点之间都可能有关系,顶点之间的逻辑关系用边表示。
图的定义与术语:
· 图按照有无方向分为无向图和有向图。无向图由 顶点 和 边 构成,有向图由顶点和弧构成。弧有弧尾和弧头只分。
· 图按照边或弧的多少分为稀疏图和稠密图。如果任意两个顶点间都存在边叫完全图,有向的叫有向完全图。
若无重复的边或定点到自身的边则叫简单图。
· 图中顶点之间有邻接点、依附的概念。无向图顶点边数叫做度,有向图顶点分为入度和出度。
· 图上的边或弧上带权则称为网。
· 图中顶点间存在路径,两顶点存在路径则说明是连通的,如果路径最终回到原始点则成为环,当中不重复
的叫做简单路径。若任意两顶点都是连通的,则图就是连通图,有向则成为强连通图。图中有子图,若子图
极大连通则就是连通分量,有向的则称为强连通分量。
· 无向图中连通且n个顶点n-1条边叫生成树。有向图中一顶点入度为0其余项点入度为1的叫有向树。一个有向图
由若干棵有向树构成生成森林。
邻接矩阵实现图的创建
typedef char VertexType;//顶点类型由用户定义
typedef int EdgeType; //边上权值类型由用户定义
const MaxVer 100; //最大顶点数
const Infinity 65535; //65535代表∞
typedef struct
{
VertexType vexs[MaxVer]; //顶点表
EdgeType arc[MaxVer][MaxVer];//邻接矩阵,可看做边表
int numVertexes,numEdges; //图中当前顶点数和边数
}MGraph;
/*建立无向网图的邻接矩阵表示*/
void CreateMGraph(MGraph *G)
{
int i,j,k,w;
printf("输入顶点数和边数:\n");
scanf("%d,%d",&G->numVertexes,&G->numEdges);//输入定点数和边数
for(i=0;i<G->numVertexes;i++)//读入顶点信息,建立顶点表
scanf(&G->vexs[i]);//录入顶点数据
for(i=0;i<G->numVertexes;i++)
for(j=0;j<G->numVertexes;j++)
G->arc[i][j]=Infinity; //邻接矩阵初始化,矩阵数值全为<span style="font-family: Arial, Helvetica, sans-serif;">∞</span>
for(k=0;k<G->numEdges;k++)//读入numEdges条边,建立临界矩阵
{
printf("输入边(vi,vj)上的下标i,下标j和权w:\n");
scanf("%d,%d,%d",&i,&j,&w);//输入边(vi,vj)上的权w
G->arc[i][j]=w;
G->arc[j][i]=G->arc[i][j];//因为是无向图,矩阵对称
}
}
对于稀疏图来讲,用邻接表代替邻接矩阵可节省空间
typedef char VertexType;//顶点类型由用户定义
typedef int EdgeType; //权值由用户定义
typedef struct EdgeNode //边表节点
{
int adjvex; //邻接点域,储存该顶点对应的下标
EdgeType weight;//用于存储权值,非网图不需要
struct EdgeNode *next;//链域,指向下一邻接点
}EdgeNode;
typedef struct VertexNode//顶点表节点
{
VertexType data; //顶点域,存储顶点信息
EdgeNode *firstedge;//边表头指针
}VertexNode,AdjList[MAXVEX];
typedef struct
{
AdjList adjList;
int numVertexes,numEdges;//图中当前定点数和边数
}GraphAdjList;
/*建立图的邻接表结构*/
void CreateALGraph(GraphAdjList *G)
{
int i,j,k;
EdgeNode *e;
printf("输入顶点数和边数\n");
scanf("d%,d%",&G->numVertexes,&G->numEdges);//输入顶点数和边数
for(i=0;i<G->numVertexes;i++)//读入顶点信息,建立顶点表
{
scanf(&G->adjList[i].data);//输入顶点信息
G->adjList[i].firstedge=NULL;//将边表置为空表
}
for(k=0;k<G->numEdges;k++) //建立边表
{
printf("输入边(vi,vj)上的顶点序号:\n");
scanf("d%,d%",&i,&j); //输入边(vi,vj)上的顶点序号
e=(EdgeNode*)malloc(sizeof(EdgeNode));//向内存申请空间,生成边表节点
e->adjvex=j; //邻接序号为j
e->next=G->adjList[i].firstedge;//将e指针指向当前顶点指向节点
G->adjList[i].firstedge=e;//将当前顶点的指针指向e
e=(EdgeNode*)malloc(sizeof(EdgeNode));//向内存申请空间,生成边表节点
e->adjvex=i; //邻接序号为i
e->next=G->adjList[j].firstedge;//将e指针指向当前顶点指向节点
G->adjList[j].firstedge=e;//将当前顶点的指针指向e
}
}
图的遍历
邻接矩阵方式遍历
/*邻接矩阵方式遍历*/
typedef int Boolean;
Boolean visited[MAX]; //访问标志数组
void DFS(MGraph G,int i)
{//邻接矩阵深度优先第归算法
int j;
visited[i]=TRUE;
printf("c%",G.vexs[i]); //打印顶点,也可以其他操作
for(j=0;j<G.numVertexes;j++)
if(G.arc[i][j]==1&&!visited[j])
DFS(G,j); //对访问的邻接顶点递归调用
}
void DFSTraverse(MGraph G)
{
int i;
for(i=0;i<G.numVertexes;i++)
visited[i]=FALSE; //初始所有顶点状态都是未访问状态
for(i=0;i<G.numVertexes;i++)
if(!visited[i])//对未访问过的顶点调用DFS,若是连通图
DFS(G,i);
}
邻接表遍历
/*邻接表结构遍历*/
void DFS(GraphAdjList GL,int i)
{//邻接表的深度优先递归算法
EdgeNode *p;
visited[i]=TRUE;
printf("%c",GL->adjList[i].data);//打印顶点,也可其它操作
p=GL->adjList[i].firstedge;
while(p)
{
if(!visited[p->adjvex])
DFS(GL,p->adjvex);//对访问的邻接节点递归调用
}
}
void DFSTraverse(GraphAdjList GL)
{//邻接表深度遍历操作
int i;
for(i=0;i<GL->numVertexes;i++)
visited[i]=FALSE; //初始化所有顶点状态都是未访问状态
for(i=0;i<GL->numVertexes;i++)
if(!visited[i])?//对未访问过的顶点调用DFS,若是连通图,只会执行一次
DFS(GL,i);
}
最小生成树(也就是找到连接所有顶点权值和最小的路径图)
· 普里姆算法
/*Prim算法最小生成树*/
void MiniSpanTree_Prim(MGraph G)
{
int min,i,j,k;
int adjvex[MaxVer];//保存相关顶点下标
int lowcost[MaxVer];//保存相关顶点间边权值
lowcost[0]=0; //初始化第一个权值为0,即v0加入生成树
//lowcost的值为0,在这里就是此下标的顶点已加入生成树
adjvex[0]=0; //初始化第一个顶点下标为0
for(i=1;i<G.numVertexes;i++)//循环除下标为0外的全部顶点
{
lowcost[i]=G.arc[0][i];//将v0顶点与之有边的权值存入数组
adjvex[i]=0; //初始化都为v0的下标
}
for(i=1;i<G.numVertexes;i++)
{
min=Infinity; //初始化最小权值为∞
J=1;k=0;
while(j<G.numVertexes)//循环全部顶点
{
if(lowcost[j]!=0&&lowcost[j]<min)
{//如果权值不为0且权值小于min
min=lowcost[j]; //则让当前权值成为最小值
k=j; //当前最小值下标存入k
}
j++;
}
printf("(%d,%d)",adjvex[k],k);//打印当前顶点边中权值最小边
lowcost[k]=0; //当前顶点的权值设置为0,表示此顶点已经完成任务
for(j=1;j<G.numVertexes;j++)//循环所有顶点
{
if(lowcost[j]!=0&&G.arc[k][j]<lowcost[j])
{//若下标为k顶点各边权值小于此前这些顶点未被加入生成树权值
lowcost[j]=G.arc[k][j]; //将较小权值存入lowcost
adjvex[j]=k; //将下标为k的顶点存入adjvex
}
}
}
}
克鲁斯卡尔算法
//克鲁斯卡尔(Kruskal)算法
typedef struct
{//对边集数组Edge结构的定义
int begin;
int end;
int weight;
}Edge;
Void MiniSpanTree_Kruskal(MGraph G)
{//Kruskal算法生成最小生成树
int i,n,m;
Edge edges[MAXEDGE];//定义边集数组
int parent[MaxVex];//定义一数组用来判断边与边是否形成环路
//此处省略将邻接矩阵G转换为边集数组edges并按权由小到大排序的代码
for(i=0;i<G.numVertexes;i++)
parent[i]=0; //初始化数组值为0
for(i=0;i<G.numEdges;i++)//循环每一条边
{
n=Find(parent,edges[i].begin);
m=Find(parent,edges[i].end;);
if(n=!m)//假如n与m不等,说明此边没有与现有生成树形成环路
{
parent[n]=m;//将此边的结尾顶点放入下标为起点的parents中
//表示此顶点已经在生成树集合中
printf("(%d,%d)%d",edges[i].begin,edges[i].end,edges[i].weight);
}
}
}
int Find(int *parent,int f)//查找连线顶点的尾部下标
{
while(parent[f]>0)
f=parent[f];
return f;
}
最短路径(和最小生成树不同的是,最短路径所找的是一个点到另一个点最短举例的路径)
迪杰斯特拉(Dijkstra)算法
#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXEDGE 20
#define MAXVEX 20
#define INFINITY 65535
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef struct
{
int vexs[MAXVEX];
int arc[MAXVEX][MAXVEX];
int numVertexes, numEdges;
}MGraph;
typedef int Patharc[MAXVEX]; /* 用于存储最短路径下标的数组 */
typedef int ShortPathTable[MAXVEX];/* 用于存储到各点最短路径的权值和 */
/* 构件图 */
void CreateMGraph(MGraph *G)
{
int i, j;
/* printf("请输入边数和顶点数:"); */
G->numEdges=16;
G->numVertexes=9;
for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
{
G->vexs[i]=i;
}
for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
{
for ( j = 0; j < G->numVertexes; j++)
{
if (i==j)
G->arc[i][j]=0;
else
G->arc[i][j] = G->arc[j][i] = INFINITY;
}
}
G->arc[0][1]=1;
G->arc[0][2]=5;
G->arc[1][2]=3;
G->arc[1][3]=7;
G->arc[1][4]=5;
G->arc[2][4]=1;
G->arc[2][5]=7;
G->arc[3][4]=2;
G->arc[3][6]=3;
G->arc[4][5]=3;
G->arc[4][6]=6;
G->arc[4][7]=9;
G->arc[5][7]=5;
G->arc[6][7]=2;
G->arc[6][8]=7;
G->arc[7][8]=4;
for(i = 0; i < G->numVertexes; i++)
{
for(j = i; j < G->numVertexes; j++)
{
G->arc[j][i] =G->arc[i][j];
}
}
}
/* Dijkstra算法,求有向网G的v0顶点到其余顶点v的最短路径P[v]及带权长度D[v] */
/* P[v]的值为前驱顶点下标,D[v]表示v0到v的最短路径长度和 */
void ShortestPath_Dijkstra(MGraph G, int v0, Patharc *P, ShortPathTable *D)
{
int v,w,k,min;
int final[MAXVEX];/* final[w]=1表示求得顶点v0至vw的最短路径 */
for(v=0; v<G.numVertexes; v++) /* 初始化数据 */
{
final[v] = 0; /* 全部顶点初始化为未知最短路径状态 */
(*D)[v] = G.arc[v0][v];/* 将与v0点有连线的顶点加上权值 */
(*P)[v] = 0; /* 初始化路径数组P为0 */
}
(*D)[v0] = 0; /* v0至v0路径为0 */
final[v0] = 1; /* v0至v0不需要求路径 */
/* 开始主循环,每次求得v0到某个v顶点的最短路径 */
for(v=1; v<G.numVertexes; v++)
{
min=INFINITY; /* 当前所知离v0顶点的最近距离 */
for(w=0; w<G.numVertexes; w++) /* 寻找离v0最近的顶点 */
{
if(!final[w] && (*D)[w]<min)
{
k=w;
min = (*D)[w]; /* w顶点离v0顶点更近 */
}
}
final[k] = 1; /* 将目前找到的最近的顶点置为1 */
for(w=0; w<G.numVertexes; w++) /* 修正当前最短路径及距离 */
{
/* 如果经过v顶点的路径比现在这条路径的长度短的话 */
if(!final[w] && (min+G.arc[k][w]<(*D)[w]))
{ /* 说明找到了更短的路径,修改D[w]和P[w] */
(*D)[w] = min + G.arc[k][w]; /* 修改当前路径长度 */
(*P)[w]=k;
}
}
}
}
int main(void)
{
int i,j,v0;
MGraph G;
Patharc P;
ShortPathTable D; /* 求某点到其余各点的最短路径 */
v0=0;
CreateMGraph(&G);
ShortestPath_Dijkstra(G, v0, &P, &D);
printf("最短路径倒序如下:\n");
for(i=1;i<G.numVertexes;++i)
{
printf("v%d - v%d : ",v0,i);
j=i;
while(P[j]!=0)
{
printf("%d ",P[j]);
j=P[j];
}
printf("\n");
}
printf("\n源点到各顶点的最短路径长度为:\n");
for(i=1;i<G.numVertexes;++i)
printf("v%d - v%d : %d \n",G.vexs[0],G.vexs[i],D[i]);
return 0;
}
弗洛伊德算法
#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXEDGE 20
#define MAXVEX 20
#define INFINITY 65535
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef struct
{
int vexs[MAXVEX];
int arc[MAXVEX][MAXVEX];
int numVertexes, numEdges;
}MGraph;
typedef int Patharc[MAXVEX][MAXVEX];
typedef int ShortPathTable[MAXVEX][MAXVEX];
/* 构件图 */
void CreateMGraph(MGraph *G)
{
int i, j;
/* printf("请输入边数和顶点数:"); */
G->numEdges=16;
G->numVertexes=9;
for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
{
G->vexs[i]=i;
}
for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
{
for ( j = 0; j < G->numVertexes; j++)
{
if (i==j)
G->arc[i][j]=0;
else
G->arc[i][j] = G->arc[j][i] = INFINITY;
}
}
G->arc[0][1]=1;
G->arc[0][2]=5;
G->arc[1][2]=3;
G->arc[1][3]=7;
G->arc[1][4]=5;
G->arc[2][4]=1;
G->arc[2][5]=7;
G->arc[3][4]=2;
G->arc[3][6]=3;
G->arc[4][5]=3;
G->arc[4][6]=6;
G->arc[4][7]=9;
G->arc[5][7]=5;
G->arc[6][7]=2;
G->arc[6][8]=7;
G->arc[7][8]=4;
for(i = 0; i < G->numVertexes; i++)
{
for(j = i; j < G->numVertexes; j++)
{
G->arc[j][i] =G->arc[i][j];
}
}
}
/* Floyd算法,求网图G中各顶点v到其余顶点w的最短路径P[v][w]及带权长度D[v][w]。 */
void ShortestPath_Floyd(MGraph G, Patharc *P, ShortPathTable *D)
{
int v,w,k;
for(v=0; v<G.numVertexes; ++v) /* 初始化D与P */
{
for(w=0; w<G.numVertexes; ++w)
{
(*D)[v][w]=G.arc[v][w]; /* D[v][w]值即为对应点间的权值 */
(*P)[v][w]=w; /* 初始化P */
}
}
for(k=0; k<G.numVertexes; ++k)
{
for(v=0; v<G.numVertexes; ++v)
{
for(w=0; w<G.numVertexes; ++w)
{
if ((*D)[v][w]>(*D)[v][k]+(*D)[k][w])
{/* 如果经过下标为k顶点路径比原两点间路径更短 */
(*D)[v][w]=(*D)[v][k]+(*D)[k][w];/* 将当前两点间权值设为更小的一个 */
(*P)[v][w]=(*P)[v][k];/* 路径设置为经过下标为k的顶点 */
}
}
}
}
}
int main(void)
{
int v,w,k;
MGraph G;
Patharc P;
ShortPathTable D; /* 求某点到其余各点的最短路径 */
CreateMGraph(&G);
ShortestPath_Floyd(G,&P,&D);
printf("各顶点间最短路径如下:\n");
for(v=0; v<G.numVertexes; ++v)
{
for(w=v+1; w<G.numVertexes; w++)
{
printf("v%d-v%d weight: %d ",v,w,D[v][w]);
k=P[v][w]; /* 获得第一个路径顶点下标 */
printf(" path: %d",v); /* 打印源点 */
while(k!=w) /* 如果路径顶点下标不是终点 */
{
printf(" -> %d",k); /* 打印路径顶点 */
k=P[k][w]; /* 获得下一个路径顶点下标 */
}
printf(" -> %d\n",w); /* 打印终点 */
}
printf("\n");
}
printf("最短路径D\n");
for(v=0; v<G.numVertexes; ++v)
{
for(w=0; w<G.numVertexes; ++w)
{
printf("%d\t",D[v][w]);
}
printf("\n");
}
printf("最短路径P\n");
for(v=0; v<G.numVertexes; ++v)
{
for(w=0; w<G.numVertexes; ++w)
{
printf("%d ",P[v][w]);
}
printf("\n");
}
return 0;
}
脑子秀逗了……逗逼图,老子不折磨自己了!