图的定义：
图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为： G=(V，E)
其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。
在线性表中，元素个数可以为零，称为空表；
在树中，结点个数可以为零，称为空树；
在图中，顶点个数不能为零，但可以没有边。
若顶点vi和vj之间的边没有方向，则称这条边为无向边，表示为(vi,vj)。
如果图的任意两个顶点之间的边都是无向边，则称该图为无向图。
若从顶点vi到vj的边有方向，则称这条边为有向边，表示为<vi,vj>。
如果图的任意两个顶点之间的边都是有向边，则称该图为有向图。
简单图：在图中，若不存在顶点到其自身的边，且同一条边不重复出现。
无向完全图：在无向图中，如果任意两个顶点之间都存在边，则称该图为无向完全图。
有向完全图：在有向图中，如果任意两个顶点之间都存在方向相反的两条弧，则称该图为有向完全图。
邻接、依附：
无向图中，对于任意两个顶点vi和顶点vj，若存在边(vi，vj)，则称顶点vi和顶点vj互为邻接点，同时称边(vi，vj)依附于顶点vi和顶点vj。
有向图中，对于任意两个顶点vi和顶点vj，若存在弧<vi，vj>，则称顶点vi邻接到顶点vj，顶点vj邻接自顶点vi，同时称弧<vi，vj>依附于顶点vi和顶点vj 。
在线性结构中，数据元素之间仅具有线性关系；
在树结构中，结点之间具有层次关系；
在图结构中，任意两个顶点之间都可能有关系。
含有n个顶点的无向完全图有n×(n-1)/2条边。
含有n个顶点的有向完全图有n×(n-1)条边
稀疏图：称边数很少的图为稀疏图；
稠密图：称边数很多的图为稠密图。
顶点的度：在无向图中，顶点v的度是指依附于该顶点的边数，通常记为TD (v)。
顶点的入度：在有向图中，顶点v的入度是指以该顶点为弧头的弧的数目，记为ID (v)；
顶点的出度：在有向图中，顶点v的出度是指以该顶点为弧尾的弧的数目，记为OD (v)。
在无向图中，度的总数等于边数的二倍
在有向图中，入度等于出度等于边数
图的基本术语
权：是指对边赋予的有意义的数值量。
网：边上带权的图，也称网图。
路径：在无向图G=(V, E)中，从顶点vp到顶点vq之间的路径是一个顶点序列(vp=vi0,vi1,vi2, …, vim=vq)，其中，(vij-1,vij)∈E（1≤j≤m）。若G是有向图，则路径也是有方向的，顶点序列满足<vij-1,vij>∈E。（一般情况下，图中的路径不惟一）
路径长度：
非带权图——路径上边的个数
带权图——路径上各边的权之和
回路（环）：第一个顶点和最后一个顶点相同的路径。
简单路径：序列中顶点不重复出现的路径。
简单回路（简单环）：除了第一个顶点和最后一个顶点外，其余顶点不重复出现的回路。
子图：若图G=（V，E），G'=（V'，E'），如果V'ÍV 且E' Í E ，则称图G'是G的子图。
连通图：在无向图中，如果从一个顶点vi到另一个顶点vj(i≠j)有路径，则称顶点vi和vj是连通的。如果图中任意两个顶点都是连通的，则称该图是连通图。
连通分量：非连通图的极大连通子图称为连通分量。
强连通图：在有向图中，对图中任意一对顶点vi和vj (i≠j)，若从顶点vi到顶点vj和从顶点vj到顶点vi均有路径，则称该有向图是强连通图。
强连通分量：非强连通图的极大强连通子图。
生成树：n个顶点的连通图G的生成树是包含G中全部顶点的一个极小连通子图。
生成森林：在非连通图中，由每个连通分量都可以得到一棵生成树，这些连通分量的生成树就组成了一个非连通图的生成森林。
图的遍历操作
图的遍历是从图中某一顶点出发，对图中所有顶点访问一次且仅访问一次。
遍历的起始顶点：从编号小的顶点开始
因图中可能存在回路，某些顶点可能会被重复访问，为避免遍历不会因回路而陷入死循环附设访问标志数组visited[n]
在图中，一个顶点可以和其它多个顶点相连，当这样的顶点访问过后，如何选取下一个要访问的顶点？
解决方案：深度优先遍历和广度优先遍历。
深度优先遍历 （DFS：Depth First Search）
基本思想 ：
⑴ 访问顶点v；
⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。
广度优先遍历 （BFS：Broad First Search ；FIFO: First In First Out）
基本思想：
⑴ 访问顶点v；
⑵ 依次访问v的各个未被访问的邻接点v1, v2, …, vk；
⑶ 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。
顺序存储结构存储图（邻接矩阵（数组表示法））
基本思想：
用一个一维数组存储图中顶点的信息
用一个二维数组（称为邻接矩阵）存储图中各顶点之间的邻接关系。
无向图的邻接矩阵的特点：主对角线为 0 且一定是对称矩阵。
有向图的邻接矩阵不一定不对称:例如有向完全图。
邻接矩阵存储无向图的类
const int MaxSize=10;
template <class T>
class Mgraph{
public:
MGraph(T a[ ], int n, int e );
~MGraph( )
void DFSTraverse(int v);
void BFSTraverse(int v);
……
private:
T vertex[MaxSize];
int arc[MaxSize][MaxSize];
int vertexNum, arcNum;
};
邻接矩阵中图的基本操作——构造函数MGraph(T a[ ], int n, int e );
2. 输入顶点信息存储在一维数组vertex中；
3. 初始化邻接矩阵；
4. 依次输入每条边存储在邻接矩阵arc中；
4.1 输入边依附的两个顶点的序号i, j；
4.2 将邻接矩阵的第i行第j列的元素值置为1；
4.3 将邻接矩阵的第j行第i列的元素值置为1；
template <class T>
MGraph::MGraph(T a[ ], int n, int e) {
vertexNum=n; arcNum=e;
for (i=0; i<vertexNum; i++)
vertex[i]=a[i];
for (i=0; i<vertexNum; i++) //初始化邻接矩阵
for (j=0; j<vertexNum; j++)
arc[i][j]=0;
for (k=0; k<arcNum; k++) {
cin>>i>>j; //边依附的两个顶点的序号
arc[i][j]=1; arc[j][i]=1; //置有边标志
}
}
邻接矩阵中图的基本操作——深度优先遍历
int visited[MaxSize];
template <class T>
void MGraph::DFSTraverse(int v)
{
cout<<vertex[v]; visited [v]=1;
for (j=0; j<vertexNum; j++)
if (arc[v][j]==1 && visited[j]==0)
DFSTraverse( j );
}
邻接矩阵中图的基本操作——广度优先遍历
int visited[MaxSize];
template <class T>
void MGraph::BFSTraverse(int v){
front=rear=-1; //假设采用顺序队列且不会发生溢出
int Q[MaxSize]; cout<<vertex[v]; visited[v]=1; Q[++rear]=v;
while (front!=rear) {
v=Q[++front];
for (j=0; j<vertexNum; j++)
if (arc[v][j]==1 && visited[j]==0 ) {
cout<<vertex[j]; visited[j]=1; Q[++rear]=j;
}
}
}
链式存储结构存储图（邻接表）
邻接表存储的基本思想：对于图的每个顶点vi，将所有邻接于vi的顶点链成一个单链表，称为顶点vi的边表（对于有向图则称为出边表）
所有边表的头指针和存储顶点信息的一维数组构成了顶点表。
邻接表有两种结点结构：顶点表结点和边表结点。
顶点表 边 表
vertex：数据域，存放顶点信息。
firstedge：指针域，指向边表中第一个结点。
adjvex：邻接点域，边的终点在顶点表中的下标。
next：指针域，指向边表中的下一个结点。
定义邻接表的结点
struct ArcNode
{
int adjvex;
ArcNode *next;
};
template <class T>
struct VertexNode
{
T vertex;
ArcNode *firstedge;
};
邻接表存储有向图的类
const int MaxSize=10; //图的最大顶点数
template <class T>
class ALGraph
{
public:
ALGraph(T a[ ], int n, int e);
~ALGraph;
void DFSTraverse(int v);
void BFSTraverse(int v);
………
private:
VertexNode adjlist[MaxSize];
int vertexNum, arcNum;
};
邻接表中图的基本操作——构造函数
1. 确定图的顶点个数和边的个数；
2. 输入顶点信息，初始化该顶点的边表；
3. 依次输入边的信息并存储在边表中；
3.1 输入边所依附的两个顶点的序号i和j；
3.2 生成邻接点序号为j的边表结点s；
3.3 将结点s插入到第i个边表的头部；
template <class T>
ALGraph::ALGraph(T a[ ], int n, int e)
{
vertexNum=n; arcNum=e;
for (i=0; i<vertexNum; i++)
{
adjlist[i].vertex=a[i];
adjlist[i].firstedge=NULL;
}
for (k=0; k<arcNum; k++)
{
cin>>i>>j;
s=new ArcNode; s->adjvex=j;
s->next=adjlist[i].firstedge;
adjlist[i].firstedge=s;
}
}
邻接表中图的基本操作——深度优先遍历
template <class T>
void ALGraph::DFSTraverse(int v){
cout<<adjlist[v].vertex; visited[v]=1;
p=adjlist[v].firstedge;
while (p!=NULL) {
j=p->adjvex;
if (visited[j]==0) DFSTraverse(j);
p=p->next;
}
}
邻接表中图的基本操作——广度优先遍历
template <class T>
void ALGraph::BFSTraverse(int v){
front=rear=-1;
cout<<adjlist[v].vertex; visited[v]=1; Q[++rear]=v;
while (front!=rear) {
v=Q[++front]; p=adjlist[v].firstedge;
while (p!=NULL) {
j= p->adjvex;
if (visited[j]==0) {
cout<<adjlist[j].vertex; visited[j]=1; Q[++rear]=j;
}
p=p->next;
}
}
}
十字链表：有向图的链式存储结构
十字链表的结点结构
vertex：数据域，存放顶点信息；
firstin：入边表头指针；
firstout：出边表头指针；
tailvex：弧的起点在顶点表中的下标；
headvex：弧的终点在顶点表中的下标；
headlink：入边表指针域；
taillink：出边表指针域。
边集数组
利用两个一维数组
图的连通性
求无向图的连通分量（非连通图的遍历方法）
2. for (图中每个顶点v)
2.1 if (v尚未被访问过)
2.1.1 count++;
2.1.2 从v出发遍历该图（函数调用）；
3. if (count==1) cout<<"图是连通的";
else cout<<"图中有"<<count<<"个连通分量";
最小生成树（minimal spanning tree）
最小生成树：在图G所有生成树中，代价最小的生成树称为最小生成树。
构造最小代价生成树
两种方法：
Prime法：加点法
Kruskal方法：加边法
普里姆（Prim）算法
基基本思想：
设G=(V, E)是具有n个顶点的连通网，
T=(U, TE)是G的最小生成树，
T的初始状态为U={u0}（u0∈V），TE={ }，
重复执行下述操作：
在所有u∈U，v∈V-U的边中找一条代价最小的边(u, v)并入集合TE，同时v并入U，直至U=V。
数据结构设计：
数组lowcost[n]：用来保存集合V-U中各顶点与集合U中顶点最短边的权值，lowcost[v]=0表示顶点v已加入最小生成树中；
数组adjvex[n]：用来保存该边所依附的（集合V-U中各顶点与集合U中顶点的最短边）集合U中的顶点。
Prim算法——伪代码
1. 初始化两个辅助数组lowcost（=arc[0][i]）和adjvex(=0)(0是始点)；
2. 输出顶点u0，将顶点u0加入集合U中；
3. 重复执行下列操作n-1次
3.1 在lowcost中选取最短边(lowcost[k])，取对应的顶点序号k；
3.2 输出顶点k和对应的权值；
3.3 将顶点k加入集合U中（lowcost[k]=0）；
3.4 调整数组lowcost和adjvex；
Void prime(MGraph G){
for(int i=1;i<G.vertexNu;i++){
lowcost[i]=G.arc[0][i]; adjvex[i]=0;
}
lowcost[0]=0;
for(i=1;i<G.vertexNum;i+++){
k=MinEdge(lowcost,G.vertexNum)
cout<<K<<adjvex[k]<<lowcost[k];
lowcost[k]=0;
for(j=1;j<G.vertexNum;j++)
if((G.arc[k][j]<lowcost[j]){
lowcost[j]=G.arc[k][j];
arcvex[j]=k;
}
}
}
克鲁斯卡尔（Kruskal）算法
基本思想：
3.1确定u所在的树的根节点vex1;
3.2确定v所在的树的根节点vex2;
3.3 如果vex1!=vex2，则执行
a. parent[vex2]=vex1;//将第一个节点的父亲设为第二个节点的父亲， 合并 为一个连通分量
b. count++;
c. 如果count==n-1,算法结束。
int main(){
int arcNum, int vertexNum;
EdgeNode *edge;
int *parent;
cout<<"please input the number of vertexNum:"; cin>>vertexNum;
cout<<"please input the number of edges:"; cin>>arcNum;
edge=new EdgeNode[arcNum]; parent=new int[vertexNum];
for(int i=0;i<arcNum;i++) {
cout<<"Please input the edges:";
cin>>edge[i].from>>edge[i].to>>edge[i].weight;
}
sort(edges, G); //对边集数组进行堆排序，时间复杂性为O(eloge)
for (i=0;i<vertexNum;i++)
parent[i]=-1; //每个节点分属于不同的集合
int k=0,begin,end,count=0;
cout<<"next is the MST :"<<endl;
for (k=0;k<arcNum;k++) {
begin=edge[k].from; end=edge[k].to;
int m,n;
m=Find(parent,begin); n=Find(parent,end);
if(m!=n) {
cout<<begin<<","<<end<<","<<edge[k].weight<<endl;
parent[n]=m; count++;
if(count==vertexNum-1) break;
}
}
return 0;
}
int Find(int *parent, int node)
{
int f;
f=node;
while(parent[f]>-1)
f=parent[f];
return f;
}
最短路径 问题
在非网图中，最短路径是指两顶点之间经历的边数最少的路径。
单源点到其他顶点的最短路径
Dijkstra方法，O（n2）
任意一对顶点之间的最短路径
Floyed方法，O（n3）
Dijkstra算法
基本思想：
重复上述过程，直到集合V中全部顶点加入到集合S中。
Dijkstra算法——伪代码
1. 初始化数组dist、path和s；
2. while (s中的元素个数<n)
2.1 在dist[n]中求最小值，其下标为k；
2.2 输出dist[k]和path[k]；
2.3 修改数组dist和path；
2.4 将顶点vk添加到数组s中；
Const int MAX=1000;
void Dijkstra(MGraph g, int v){
for ( i =0; i<g.vexnum ; i++){
dist［i］=g.arcs［v］［i］;
if ( dist［i］!= MAX) path [i]=g.vertex[v]+g.vertex[i]; else path[i]=“”;
}
S[0]=g.vertex[v];
num=1;
While (num<g.vextexNum){
k=0;
for(i=0;i<G.vertexNum;i++)
if((dist[i]<dist[k]) k=i
cout<<dist[k]<<path[k];
s[num++]=G.vertex[k];
for(i=0;i<G.vertexNum;i++)
if(dist[k]+g.arc[k][i]<dist[i] {
dist[i]=dist[k]+g.arc[k][i];
path[i]=path[k]+g.vertex[i];
}
}
}
Floyd算法
基本思想：
设图g用邻接矩阵法表示，
求图g中任意一对顶点vi、 vj间的最短路径。
（-1） 将vi到vj 的最短的路径长度初始化为(vi,vj)， 然后进行如下n次比较和修正：
（0） 在vi、vj间加入顶点v0，比较（vi, v0, vj）和(vi, vj)的路径的长度，取其中较短的路径作为vi到vj的且中间顶点号不大于0的最短路径。
数组dist[n][n]：存放在迭代过程中求得的最短路径长度。迭代公式：
dist-1[i][j]=arc[i][j]
dist k[i][j]=min{distk-1[i][j], distk-1[i][k]+distk-1[k][j]} 0≤k ≤n-1
数组path[n][n]： 存放从vi到vj的最短路径，初始为path[i][j]="vivj"。
void Floyd(MGraph G)
{
for (i=0; i<G.vertexNum; i++)
for (j=0; j<G.vertexNum; j++)
{
dist[i][j]=G.arc[i][j];
if (dist[i][j]!=∞)
path[i][j]=G.vertex[i]+G.vertex[j];
else path[i][j]="";
}
for (k=0; k<G.vertexNum; k++)
for (i=0; i<G.vertexNum; i++)
for (j=0; j<G.vertexNum; j++)
if (dist[i][k]+dist[k][j]<dist[i][j]) {
dist[i][j]=dist[i][k]+dist[k][j];
path[i][j]=path[i][k]+path[k][j];
}
}
AOV网与拓扑排序
AOV网：在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，称这样的有向图为顶点表示活动的网，简称AOV网。
AOV网特点：
1.AOV网中的弧表示活动之间存在的某种制约关系。
2.AOV网中不能出现回路 。
拓扑序列：
设G=(V，E)是一个具有n个顶点的有向图，V中的顶点序列v1, v2, …, vn称为一个拓扑序列，当且仅当满足下列条件：若从顶点vi到vj有一条路径，则在顶点的拓扑序列中顶点vi必在顶点vj之前。
拓扑排序：对一个有向图构造拓扑序列的过程称为拓扑排序 。
拓扑排序基本思想：
⑴ 从AOV网中选择一个没有前驱的顶点并且输出；
⑵ 从AOV网中删去该顶点，并且删去所有以该顶点为尾的弧；
⑶ 重复上述两步，直到全部顶点都被输出，或AOV网中不存在没有前驱的顶点。
AOV-网的拓扑序列不是唯一的。
图的存储结构：采用邻接表存储 ，在顶点表中增加一个入度域。
顶点表结点
. 栈S：存储所有无前驱的顶点（入度为零的顶点）。
基于邻接表的拓扑排序的基本思想：
（1）找G中无前驱的顶点
查找indegree ［i］为零的顶点vi；
（2）修改邻接于顶点i的顶点的入度（删除以i为起点的所有弧）
对链在顶点i后面的所有邻接顶点k，将对应的indegree［k］ 减1。
为了避免重复检测入度为零的顶点，可以再设置一个辅助栈，若某一顶点的入度减为0，则将它入栈。每当输出某一入度为0的顶点时，便将它从栈中删除。
拓扑排序算法——伪代码
1. 栈S初始化；累加器count初始化；
2. 扫描顶点表，将没有前驱的顶点压栈；
3. 当栈S非空时循环
3.1 vj=退出栈顶元素；输出vj；累加器加1；
3.2 将顶点vj的各个邻接点的入度减1；
3.3 将新的入度为0的顶点入栈；
4. if (count<vertexNum) 输出有回路信息；
void TOpSort(){
int top=-1, count=0;
for(int i=0;i<vertexnum;i++)
if(adjlist[i].in==0) s[++top]=i;
while(top!=-1){
j=s[top--]; cout <<adjlist[j].vertext; count++;
p=adjlist[j].firstedge;
while(p!=NULL){
k=p->adjvex; adjlist[k].in--;
if(adjlist[k].in==0) s[top++]=k;
p=p->next;
}
}
AOE网与关键路径
AOE网：
在一个表示工程的带权有向图中，
用顶点表示事件，
用有向边表示活动，
边上的权值表示活动的持续时间，
称这样的有向图叫做边表示活动的网，简称AOE网。
AOE网中没有入边的顶点称为始点（或源点），没有出边的顶点称为终点（或汇点）。
AOE网的性质：
⑴ 只有在某顶点所代表的事件发生后，从该顶点出发的各活动才能开始；
⑵ 只有在进入某顶点的各活动都结束，该顶点所代表的事件才能发生。
关键路径
关键路径：在AOE网中，从始点到终点具有最大路径长度（该路径上的各个活动所持续的时间之和）的路径称为关键路径。
关键活动：关键路径上的活动称为关键活动。
要找出关键路径，必须找出关键活动, 即不按期完成就会影响整个工程完成的活动。
首先计算以下与关键活动有关的量：
⑴ 事件的最早发生时间ve[k]
⑵ 事件的最迟发生时间vl[k]
⑶ 活动的最早开始时间e[i]
⑷ 活动的最晚开始时间l[i]
最后计算各个活动的时间余量 l[k] - e[k]，时间余量为0者即为关键活动。
存储结构的选择：
为处理方便，同时采用了邻接矩阵和边集数组两种存储结
邻接矩阵可以方便的查找邻接点，完成时间的最早和最晚发生时间的计算。
边集数组可以方便的计算时间的活动的最晚发生时间
struct Edge
{
int from;
int to;
int e;
int l;
};
class Grap
{
int vertexnum,e;
int **adjlist; //邻接矩阵
int start,end;
Edge *edge; //边集数组
public:
Grap(int n,int e);
int path();
};
⑴ 事件的最早发生时间ve[k]
ve[k]是指从始点开始到顶点vk的最大路径长度。这个长度决定了所有从顶点vk发出的活动能够开工的最早时间。
ve[1]=0；ve[k]=max{ve[j]+len<vj, vk>} (<vj, vk>∈p[k])
p[k]表示所有到达vk的有向边的集合
q.push(0);//源点时间入队
for(j=0;j<vertexnum;j++) { //初始化每个事件最早发生时间
ve[j]=0; visit[j]=0; }
visit[0]=1;
while(!q.empty()) {
i=q.front(); //利用标准模板库中的队列实现
q.pop();
for(j=0;j<vertexnum;j++){//计算i的邻接点的ve
if(adjlist[i][j]!=9999 && ve[i]+adjlist[i][j]>ve[j] ){
ve[j]=ve[i]+adjlist[i][j];
if(!visit[j]) //如果j没有被访问过，顶点j入队
q.push(j);
visit[j]=1;
}
}
}
⑵ 事件的最迟发生时间vl[k]
vl[k]是指在不推迟整个工期的前提下,事件vk允许的最晚发生时间。
vl[n]=ve[n]；vl[k]=min{vl[j]-len<vk , vj>}（<vk, vj>∈s[k]）
s[k]为所有从vk发出的有向边的集合
q.push(vertexnum-1);
for(j=0;j<vertexnum;j++) {
vl[j]=ve[vertexnum-1]; visit[j]=0; }
while(!q.empty()) {
i=q.front();
q.pop();
for(j=0;j<vertexnum;j++) {
if(adjlist[j][i]!=9999 && vl[i]-adjlist[j][i]<vl[j] ){
vl[j]=vl[i]-adjlist[j][i];
if(!visit[j])
q.push(j);
visit[j]=1;
}
}
}
⑶ 活动的最早开始时间e[i]
若活动ai是由弧<vk , vj>表示，则活动ai的最早开始时间应等于事件vk的最早发生时间。因此，有： e[i]=ve[k]
for(i=0;i<e;i++)
{
edge[i].e=ve[edge[i].from];
}
⑷ 活动的最晚开始时间l[i]
活动ai的最晚开始时间是指，在不推迟整个工期的前提下， ai必须开始的最晚时间。
若ai由弧<vk，vj>表示，
则ai的最晚开始时间要保证事件vj的最迟发生时间不拖后。
因此，有：
l[i]=vl[j]-len<vk, vj>
for(i=0;i<e;i++)
{
edge[i].e=ve[edge[i].from];
edge[i].l=vl[edge[i].to]-adjlist[edge[i].from][edge[i].to];
if(edge[i].e==edge[i].l)
cout<<edge[i].from<<" "<<edge[i].to<<endl;
}
最后，根据每个活动ai的最早开始时间ee[i]和最晚开始时间el[i]，判定该活动是否为关键活动，那些el[i]=ee[i]的活动就是关键活动。关键活动确定之后，关键活动所在的路径就是关键路径。
176
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
