⑴ 图的存储结构——所存储的信息有哪些
一、邻接矩阵存储方法
邻接矩阵是表示顶点之间相邻关系的矩阵。
设G=(V，E)是具有n（n＞0）个顶点的图，顶点的顺序依次为0～n-1，则G的邻接矩阵A是n阶方阵，其定义如下：
（1）如果G是无向图，则：
A[i][j]=1：若(i,j)∈E(G) 0:其他
（2）如果G是有向图，则：
A[i][j]=1：若<i,j>∈E(G) 0:其他
（3）如果G是带权无向图，则：
A[i][j]= wij ：若i≠j且(i,j)∈E(G) 0：i=j ∞：其他
（4）如果G是带权有向图，则：
A[i][j]= wij ：若i≠j且<i,j>∈E(G) 0：i=j∞：其他
注意：带权图和不带权图表示的元素类型不同。
带权图（不论有向还是无向图）A[i][j]用double表示，不带权图（不论有向还是无向图）A[i][j]用int表示。
用一维数组G[ ]存储有4个顶点的无向图如：G[ ] = { 0, 1, 0, 1, 1, 0, 0, 0, 1, 0 }
则顶点2和顶点0之间是有边的。
如：
邻接矩阵的特点如下：
（1）图的邻接矩阵表示是唯一的。
（2）无向图的邻接矩阵一定是一个对称矩阵。因此，按照压缩存储的思想，在具体存放邻接矩阵时只需存放上（或下）三角形阵的元素即可。
（3）不带权的有向图的邻接矩阵一般来说是一个稀疏矩阵。因此，当图的顶点较多时，可以采用三元组表的方法存储邻接矩阵。
（4）对于无向图，邻接矩阵的第i行（或第i列）非零元素（或非∞元素）的个数正好是第i个顶点的度。
（5）对于有向图，邻接矩阵的第i行（或第i列）非零元素（或非∞元素）的个数正好是第i个顶点的出度（或入度）。
（6）用邻接矩阵方法存储图，很容易确定图中任意两个顶点之间是否有边相连。但是，要确定图中有多少条边，则必须按行、按列对每个元素进行检测，所花费的时间代价很大。这是用邻接矩阵存储图的局限性。
邻接矩阵的数据类型定义如下：
#define MAXV <最大顶点个数>
typedef struct
{ int no; //顶点编号
InfoType info; //顶点其他信息
} VertexType; //顶点类型
typedef struct //图的定义
{ int edges[MAXV][MAXV]; //邻接矩阵
int n，e; //顶点数，弧数
VertexType vexs[MAXV]; //存放顶点信息
} MGraph; //图的邻接矩阵表示类型
二、 邻接表存储方法
图的邻接表存储方法是一种顺序分配与链式分配相结合的存储方法。
在邻接表中，对图中每个顶点建立一个单链表，第i个单链表中的节点表示依附于顶点i的边（对有向图是以顶点i为尾的边）。每个单链表上附设一个表头节点。
其中，表节点由三个域组成，adjvex指示与顶点i邻接的点在图中的位置，nextarc指示下一条边或弧的节点，info存储与边或弧相关的信息，如权值等。
表头节点由两个域组成，data存储顶点i的名称或其他信息，firstarc指向链表中第一个节点。
typedef struct ANode
{ int adjvex; //该边的终点编号
struct ANode *nextarc; //指向下一条边的指针
InfoType info; //该边的相关信息
} ArcNode; //边表节点类型
typedef struct Vnode
{ Vertex data; //顶点信息
ArcNode *firstarc; //指向第一条边
} VNode; //邻接表头节点类型
typedef VNode AdjList[MAXV]; //AdjList是邻接表类型
typedef struct
{ AdjList adjlist; //邻接表
int n,e; //图中顶点数n和边数e
} ALGraph; //完整的图邻接表类型
邻接表的特点如下：
（1）邻接表表示不唯一。这是因为在每个顶点对应的单链表中，各边节点的链接次序可以是任意的，取决于建立邻接表的算法以及边的输入次序。
（2）对于有n个顶点和e条边的无向图，其邻接表有n个顶点节点和2e个边节点。显然，在总的边数小于n(n-1)/2的情况下，邻接表比邻接矩阵要节省空间。
（3）对于无向图，邻接表的顶点i对应的第i个链表的边节点数目正好是顶点i的度。
（4）对于有向图，邻接表的顶点i对应的第i个链表的边节点数目仅仅是顶点i的出度。其入度为邻接表中所有adjvex域值为i的边节点数目。
例， 给定一个具有n个节点的无向图的邻接矩阵和邻接表。
（1）设计一个将邻接矩阵转换为邻接表的算法；
（2）设计一个将邻接表转换为邻接矩阵的算法；
（3）分析上述两个算法的时间复杂度。
解：
（1）在邻接矩阵上查找值不为0的元素，找到这样的元素后创建一个表节点并在邻接表对应的单链表中采用前插法插入该节点。
void MatToList(MGraph g，ALGraph *&G)
//将邻接矩阵g转换成邻接表G
{ int i，j，n=g.n; ArcNode *p; //n为顶点数
G=(ALGraph *)malloc(sizeof(ALGraph));
for (i=0;i<n;i++) //给所有头节点的指针域置初值
G->adjlist[i].firstarc=NULL;
for (i=0;i<n;i++) //检查邻接矩阵中每个元素
for (j=n-1;j>=0;j--)
if (g.edges[i][j]!=0)
{ p=(ArcNode *)malloc(sizeof(ArcNode));
//创建节点*p
p->adjvex=j;
p->nextarc=G->adjlist[i].firstarc;
//将*p链到链表头
G->adjlist[i].firstarc=p;
}
G->n=n;G->e=g.e;
}
（2）在邻接表上查找相邻节点，找到后修改相应邻接矩阵元素的值。
void ListToMat(ALGraph *G，MGraph &g)
{ int i，j，n=G->n;ArcNode *p;
for (i=0;i<n;i++)
{ p=G->adjlist[i].firstarc;
while (p!=NULL)
{ g.edges[i][p->adjvex]=1;
p=p->nextarc;
}
}
g.n=n;g.e=G->e;
}
（3）算法1的时间复杂度均为O(n2)。算法2的时间复杂度为O(n+e)，其中e为图的边数。
⑵ 图的基本概念，图的存储--邻接矩阵、邻接表、十字链表、邻接多重表
一个图(G)定义为一个偶对(V,E)，记为G=(V,E)。
V是顶点(Vertex)的非空有限集合，记为V(G)。
E是无序集V&V的一个子集，记为E(G)，其元素是图的弧(Arc)。
将顶点集合为空的图称为空图。
弧：表示两个顶点v和w之间存在一个关系，用顶点偶对<v,w>表示。
(1)无向图:
在一个图中，如果任意两个顶点构成的偶对(v,w)∈E 是无序的，即顶点之间的连线是没有方向的，则称该图为无向图。
(2)有向图:
在一个图中，如果任意两个顶点构成的偶对(v,w)∈E 是有序的，即顶点之间的连线是有方向的，则称该图为有向图。一般记作<v,w>
(3)完全无向图:
在一个无向图中，如果任意两顶点都有一条直接边相连接，则称该图为完全无向图。在一个含有 n 个顶点的完全无向图中，有n(n-1)/2条边。
(4)完全有向图:
在一个有向图中，如果任意两顶点之间都有方向互为相反的两条弧相连接，则称该图为完全有向图。在一个含有 n 个顶点的完全有向图中，有n(n-1)条边。
(5)稠密图、稀疏图:
若一个图接近完全图，称为稠密图;称边数很少( )的图为稀疏图。
(6)顶点的度、入度、出度:
顶点的度(degree)是指依附于某顶点 的边数，通常记为TD( )。
在无向图中，所有顶点度的和是图中边的2倍。
在有向图中，要区别顶点的入度(Indegree)与出度(Outdegree)的概念。
顶点 的入度是指以顶点为终点的弧的数目，记为ID ( );
顶点 出度是指以顶点 为始点的弧的数目，记为 OD( )。
顶点 的出度与入度之和称为 的度，记为TD( )。即TD( )=OD( )+ID ( )。
(7)边的权、网图:
与边有关的数据信息称为权(weight)。在实际应用中，权值可以有某种含义。
边上带权的图称为网图或网络(network)。如果边是有方向的带权图，则就是一个有向网图。
(8)路径、路径长度:
对无向图，若从顶点 经过若干条边能到达 ，则称顶点 和 是连通的，又称顶点 到 有路径。
对有向图，从顶点 到 有有向路径，指的是从顶点 经过若干条有向边能到达 。
路径上边或有向边(弧)的数目称为路径长度。
(9)简单路径、回路、简单回路:
在一条路径中，若没有重复相同的顶点，该路径称为简单路径。
第一个顶点和最后一个顶点相同的路径称为回路(环)。
除第一个顶点与最后一个顶点之外，其他顶点不重复出现的回路称为简单回路，或者简单环。
(10)子图和生成子图:
对于图 G=(V，E)，G’=(V’，E’)，若存在 V’是 V 的子集 ，E’是 E的子集，则称图 G’是 G 的一个子图；
若V’=V且E’是E的子集，则称图G’是G的一个生成子图。
(11)连通图、连通分量:
对无向图G=(V,E)，若任意 都是连通的，则称该图是连通图，否则称为非连通图。
若G是非连通图，则极大连通子图称为连通分量。
极大的含义：指的是对子图再增加图G中的其它顶点，子图就不再连通。
任何连通图的连通分量只有一个，即本身，而非连通图有多个连通分量。
(12)强连通图、强连通分量:
对于有向图来说，若图中任意一对顶点 均有从一个顶点 到另一个顶点 有路径，也有从 到 的路径，则称该有向图是强连通图。
有向图的极大强连通子图称为强连通分量。
强连通图只有一个强连通分量，即本身。非强连通图有多个强连通分量。
(13)生成树:
一个连通图(无向图)的生成树是一个极小连通子图，它含有图中全部n个顶点和只有足以构成一棵树的n-1条边，称为图的生成树。
(14)生成森林:
有向树是只有一个顶点的入度为0，其余顶点的入度均为1的有向图。
有向图的生成森林是这样一个子图，由若干棵有向树组成，含有图中全部顶点。
(1)邻接矩阵法(Adjacency Matrix)
基本思想：对于有n个顶点的图，用一维数组vexs[n]存储顶点信息，用二维数组A[n][n]存储顶点之间关系的信息。该二维数组称为邻接矩阵。
在邻接矩阵中，以顶点在vexs数组中的下标代表顶点，邻接矩阵中的元素A[i][j]存放的是顶点i到顶点j之间关系的信息。
1)无向图的数组表示
①无向无权图的邻接矩阵
无向无权图其邻接矩阵是n阶对称方阵。
若两条边相连,A[i][j]=1; 若不相连A[i][j]=0。
②无向带权图的邻接矩阵
若两条边相连， ，W为权值。
若两条边不相连，A[i][j]=
③无向图邻接矩阵的特性
无向图的邻接矩阵一定是一个对称矩阵。因此，在具体存放邻接矩阵时只需存放 上(或下)三角矩阵的元素即可。
对于顶点 ，其度数是第i行的非0元素(或非 元素)的个数。
无向图的边数是上（或下）三角形矩阵的非0元素(或非 元素)的个数。
2)有向图的数组表示
①有向无权图的邻接矩阵
若有向无权图G=(V,E)有n个顶点，则其邻接矩阵是n阶方阵：
若从 到 有弧，A[i][j]=1；
若从 到 没有弧，A[i][j]=0；
②有向带权图的邻接矩阵
③有向图邻接矩阵的特性
对于顶点 ，第i行的非0元素(或非 元素)的个数是其出度OD( )；
第i列的非0元素(或非 元素)的个数是其入度ID( );
邻接矩阵中非0元素(或非 元素)的个数就是图的弧的个数。
对于n个顶点e条边的无向图，邻接矩阵表示时有n n个元素，2 e个非0元素。
对于n个顶点e条边的有向图，邻接矩阵表示时有n n个元素，e个非0元素。
3)图的邻接矩阵的操作
定义两个数组分别存储顶点信息(数据元素)和边或弧的信息(数据元素之间的关系) 。
图的各种操作。
①图的创建
②图的顶点定位
实际上是确定一个顶点在 vexs 数组中的位置(下标) ，其过程完全等同于在顺序存储的线性表中查找一个数据元素。
③向图中增加顶点
向图中增加一个顶点的操作，类似在顺序存储的线性表的末尾增加一个数据元素。
④向图中增加一条弧
根据给定的弧或边所依附的顶点，修改邻接矩阵中所对应的数组元素。
(2)邻接链表法
1)基本思想：类似于树的孩子链表法，就是对于图 G 中的每个顶点 ，将所有邻接于 的顶点 链成一个单链表，这个单链表就称为顶点 的邻接链表，再将所有点的邻接表表头放到数组中，就构成了图的邻接链表。
对无向图，其邻接链表是唯一(按顺序链接)的；对有向图，其邻接链表有两种形式。
2)从图的邻接表存储方法容易看出，这种表示具有以下特点:
①表头向量中每个分量就是一个单链表的头结点，分量个数就是图中的顶点数目。
②在边稀疏的情况下，用邻接表表示图比邻接矩阵节省存储空间。
③在无向图的邻接表中，顶点 的度恰为第 i 个链表中的结点数。
④有向图可以建立一个正邻接表和逆邻接表，便于统计每个结点的出度和入度。
⑤在邻接表上容易找到任一顶点的第一个邻接点和下一个邻接点，但要判定任意两个顶点( 和 )之间是否有边或弧相连，则需搜索第 i 个或第 j 个链表，因此，不及邻接矩阵方便。
对于n个顶点e条边的无向图，邻接表表示时有n个表头结点，2 e个表结点。
对于n个顶点e条边的有向图，邻接表表示时有n个表头结点，表结点数不确定，但正邻接表加上逆邻接表表结点数为e。
3)表结点及其类型定义
图的各种操作
①图的创建
②顶点定位
图的顶点定位实际上是确定一个顶点在 AdjList 数组中的某个元素的 data 域内容。
③向图中增加顶点
向图中增加一个顶点的操作，在 AdjList 数组的末尾增加一个数据元素。
④向图中增加一条弧
根据给定弧或边所依附的顶点，修改单链表，无向图修改两个单链表;有向图修改一个单链表。
(3) 十字链表法
十字链表(Orthogonal List)是有向图的另一种链式存储结构，是将有向图的正邻接表和逆邻接表结合起来得到的一种链表。
在这种结构中，每条弧的弧头结点和弧尾结点都存放在链表中，并将弧结点分别组织到以弧尾结点为头(顶点)结点和以弧头结点为头(顶点)结点的链表中。这种结构的结点逻辑结构如图所示。
data 域:存储和顶点相关的信息;
指针域 firstin:指向以该顶点为弧头的第一条弧所对应的弧结点，即逆邻接链表;
指针域 firstout:指向以该顶点为弧尾的第一条弧所对应的弧结点，即正邻接链表;
尾域 tailvex:指示弧尾顶点在图中的位置;
头域 headvex:指示弧头顶点在图中的位置;
指针域 hlink:指向弧头相同的下一条弧;
指针域 tlink:指向弧尾相同的下一条弧;
Info 域:指向该弧的相关信息，比如权值;
结点类型定义：
下图所示是一个有向图及其十字链表(略去了表结点的 info 域)。实质就是先把图的正邻接链表(出度)画出来，然后再把firstin,firstout,hlink,tlink连起来。
(4)邻接多重表法
邻接多重表(Adjacency Multilist)是无向图的另一种链式存储结构。
邻接多重表的结构和十字链表类似，每条边用一个结点表示。
邻接多重表中的顶点结点结构与邻接表中的完全相同，而表结点包括六个域。
data 域:存储和顶点相关的信息;
指针域 firstedge:指向依附于该顶点的第一条边所对应的表结点;
标志域 mark:用以标识该条边是否被访问过;
ivex 和 jvex 域:分别保存该边所依附的两个顶点在图中的位置;
info 域:保存该边的相关信息;
指针域 ilink:指向下一条依附于顶点 ivex 的边;
指针域 jlink:指向下一条依附于顶点 jvex 的边;
结点类型定义:
邻接多重表与邻接表的区别:后者的同一条边用两个表结点表示，而前者只用一个表结点表示;除标志域外，邻接多重表与邻接表表达的信息是相同的，因此，操作的实现也基本相似。
⑶ 数据结构，求无向图用邻接矩阵和邻接表的存储空间大小，怎么算
邻接表所需的存储空间为e（边数），但不适合查询两点间是否存在路径
邻接矩阵所需的存储空间为你n^2，适合查询两点间是否存在路径
对于第二问，邻接表所需的存储空间为9900，邻接矩阵所需的存储空间为你n^2=10000，差不多，所以选性能更优的邻接矩阵
实际上像（2）这种稠密图（其实是个满图）一般适合邻接矩阵
⑷ c++利用邻接矩阵存储方法实现图的存储与输出。
复制粘贴即可
#include <iostream>
using namespace std;
//*****stack.h
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status;
template<class QElemType>
class stack
{
public:
void InitStack();
void DestroyStack();
void ClearStack();
Status StackEmpty();
Status StackLength();
void GetTop(QElemType & e);
void Push(QElemType e);
void Pop(QElemType & e);
private:
struct SqStack{
QElemType *base;
QElemType *top;
int stacksize;
}S;
};
//******stack.cpp------
template<class QElemType>
void stack<QElemType>::InitStack()
{
S.base = (QElemType *)malloc(STACK_INIT_SIZE * sizeof(QElemType));
if(!S.base) exit(0);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
}
template <class QElemType>
void stack<QElemType>::DestroyStack()
{
free(S.base);
}
template <class QElemType>
void stack<QElemType>::ClearStack()
{
S.top = S.base;
}
template <class QElemType>
Status stack<QElemType>::StackEmpty()
{
if(S.top == S.base) return 1;
else return 0;
}
template <class QElemType>
Status stack<QElemType>::StackLength()
{
return (S.top - S.base);
}
template <class QElemType>
void stack<QElemType>::GetTop(QElemType & e)
{
if(S.top != S.base)
e = *(S.top - 1);
else cout << "ERROR" << endl;
}
template <class QElemType>
void stack<QElemType>::Push(QElemType e)
{
if(S.top - S.base >= S.stacksize)
{
S.base = (QElemType *)realloc(S.base,(S.stacksize + STACKINCREMENT) * sizeof(QElemType));
if(!S.base) exit(0);
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
}
template <class QElemType>
void stack<QElemType>::Pop(QElemType & e)
{
if(S.top == S.base) cout << "ERROR" << endl;
else
e = * --S.top;
}
//**********stack.cpp End
template <class TElemType>
class Graph
{
public:
void CreateUDN();
void DestroyUDN();
void CreateAlgraph();
void DestroyAlgraph();
void DFS(int v,bool *visited);
void DFSTraverse();
void Minispantree_prim(); //PRIM算法求最小生成树
void Shortestpath_DIJ(TElemType data1,TElemType data2); //对环不适用，如从V1到V1就不适用
void Shortestpath_FLOYD(TElemType data1,TElemType data2);
private:
template <class TElemType>
struct Mgraph{
int vexnum;
int arcnum;
TElemType *vertex;
int **AdjMatrix;
};
Mgraph<TElemType> gph; //邻接矩阵存储
struct Arcnode
{
int adjvex;
Arcnode *nextarc;
float weight;
};
template <class TElemType>
struct Vexnode
{
TElemType data;
Arcnode *firarc;
};
struct ALgraph
{
int vexnum;
int arcnum;
bool kind;
Vexnode<TElemType> *vex;
};
ALgraph algraph; //邻接表存储
};
//*********Graph.cpp
template <class TElemType>
void Graph<TElemType>::CreateUDN()
{
cout << "输入无向网的顶点数和边数:" << endl;
cin >> gph.vexnum >> gph.arcnum;
gph.vertex = (TElemType *)malloc(gph.vexnum * sizeof(TElemType));
int i,j,m,n; //m,n表示顶点信息对应的序号，w是权值
int w;
TElemType v1,v2;
cout << "输入顶点信息:" << endl;
for(i = 0;i < gph.vexnum;i++)
cin >> gph.vertex[i];
gph.AdjMatrix = (int **)malloc(gph.vexnum * sizeof(int *));
for(i = 0;i < gph.vexnum;i++)
gph.AdjMatrix[i] = (int *)malloc(gph.vexnum * sizeof(int));
for(i = 0;i < gph.vexnum;i++)
for(j = 0;j < gph.vexnum;j++)
gph.AdjMatrix[i][j] = INT_MAX; //INT_MAX
cout << "输入一条边依附的两点及权值:" << endl;
for(int k = 0;k < gph.arcnum;k++)
{
cin >> v1 >> v2 >> w;
for(i = 0;i < gph.vexnum;i++)
{
if(v1 == gph.vertex[i]) m = i;
if(v2 == gph.vertex[i]) n = i;
}
gph.AdjMatrix[m][n] = gph.AdjMatrix[n][m] = w;
}
}
template <class TElemType>
void Graph<TElemType>::DestroyUDN()
{
free(gph.vertex);
for(int i = 0;i < gph.vexnum;i++)
free(gph.AdjMatrix[i]);
free(gph.AdjMatrix);
}
template <class TElemType>
void Graph<TElemType>::CreateAlgraph()
{
int i,j,m,n;
float w;
TElemType v1,v2;
Arcnode *p;
cout << "输入图类型（1是无向图，0是有向图):" << endl;
cin >> algraph.kind;
cout << "输入顶点数和边数:" << endl;
cin >> algraph.vexnum >> algraph.arcnum;
algraph.vex = (Vexnode<TElemType> *)malloc(algraph.vexnum * sizeof(Vexnode<TElemType>));
cout << "输入顶点信息:" << endl;
for(i = 0;i < algraph.vexnum;i++)
{
cin >> algraph.vex[i].data;
algraph.vex[i].firarc = NULL;
}
if(algraph.kind)
{
cout << "输入各边依附的两点和权值:" << endl;
for(i = 0;i < algraph.arcnum;i++)
{
cin >> v1 >> v2 >>w;
for(j = 0;j < algraph.vexnum;j++)
{
if(v1 == algraph.vex[j].data) m = j;
if(v2 == algraph.vex[j].data) n = j;
}
p = (Arcnode *)malloc(2*sizeof(Arcnode));
p[0].adjvex = n;p[0].weight = w;
p[1].adjvex = m;p[1].weight = w;
p[0].nextarc = algraph.vex[m].firarc;algraph.vex[m].firarc = p;
p[1].nextarc = algraph.vex[n].firarc;algraph.vex[n].firarc = ++p;
}
}
else
{
cout << "输入各边的弧尾与弧头结点及有向边的权值:" << endl;
for(i = 0;i < algraph.arcnum;i++)
{
cin >> v1 >> v2 >> w;
for(j = 0;j < algraph.vexnum;j++)
{
if(v1 == algraph.vex[j].data) m = j;
if(v2 == algraph.vex[j].data) n = j;
}
p = (Arcnode *)malloc(sizeof(Arcnode));
p->adjvex = n;p->weight = w;
p->nextarc = algraph.vex[m].firarc;algraph.vex[m].firarc = p;
}
}
} //构造完成
template <class TElemType>
void Graph<TElemType>::DestroyAlgraph()
{
int i;
Arcnode *p,*q;
for(i = 0;i < algraph.vexnum;i++)
{
p = algraph.vex[i].firarc;
if(p)
{
q = p->nextarc;
while(q)
{
free(p);
p = q;
q = q->nextarc;
}
free(p);
}
}
free(algraph.vex);
}
template <class TElemType>
void Graph<TElemType>::DFS(int v,bool *visited)
{
cout << algraph.vex[v].data << endl;
visited[v] = true;
Arcnode *p;
int v1;
for(p = algraph.vex[v].firarc;p;p = p->nextarc)
{
v1 = p->adjvex;
if(!visited[v1]) DFS(v1,visited);
}
}
template <class TElemType>
void Graph<TElemType>::DFSTraverse()
{
int i,v;
bool *visited = (bool *)malloc(algraph.vexnum * sizeof(bool));
for(i = 0;i < algraph.vexnum;i++)
visited[i] = false;
for(v = 0;v < algraph.vexnum;v++)
if(!visited[v]) DFS(v,visited);
free(visited);
} //EndDFSTraverse
template <class TElemType>
void Graph<TElemType>::Minispantree_prim()
{
struct closedge
{
int adjvex;
int lowcost;
};
closedge *edge = (closedge *)malloc(gph.vexnum * sizeof(closedge));
int i,j,k = 0,u;
int min;
for(i = 0;i < gph.vexnum;i++)
{
if(i != k)
{
edge[i].adjvex = 0;
edge[i].lowcost = gph.AdjMatrix[k][i];
}
}
edge[k].lowcost = 0;
cout << "最小生成树的边如下:" << endl;
for(i = 1;i < gph.vexnum;i++)
{
min = INT_MAX;
for(j = 0;j < gph.vexnum;j++)
if(edge[j].lowcost != INT_MAX &&edge[j].lowcost != 0 && edge[j].lowcost < min)
{
min = edge[j].lowcost;
k = j;
}
u = edge[k].adjvex;
edge[k].lowcost = 0;
cout << "(" << gph.vertex[u] << "," << gph.vertex[k] << ")" << " ";
for(j = 0;j < gph.vexnum;j++)
if(gph.AdjMatrix[j][k] < edge[j].lowcost)
{
edge[j].lowcost = gph.AdjMatrix[j][k];
edge[j].adjvex = k;
}
}
free(edge);
cout << endl;
}
template <class TElemType>
void Graph<TElemType>::Shortestpath_DIJ(TElemType data1,TElemType data2)
{
int i,j,v,u,k,min;
stack<int> S;
S.InitStack();
int *spath = (int *)malloc(gph.vexnum * sizeof(int));
int *pathrecord = (int *)malloc(gph.vexnum * sizeof(int));
bool *visited = (bool *)malloc(gph.vexnum * sizeof(bool));
for(i = 0;i < gph.vexnum;i++) visited[i] = false;
for(i = 0;i < gph.vexnum;i++)
{
if(data1 == gph.vertex[i]) v = i;
if(data2 == gph.vertex[i]) u = i;
}
for(i = 0;i < gph.vexnum;i++)
{
spath[i] = gph.AdjMatrix[v][i];
pathrecord[i] = v;
}
spath[v] = 0;visited[v] = true;pathrecord[v] = -1;
for(i = 1;i < gph.vexnum;i++)
{
min = INT_MAX;
for(j = 0;j < gph.vexnum;j++)
{
if(!visited[j])
{
if(spath[j] < min) {min = spath[j];k = j;}
}
}
visited[k] = true;
for(j = 0;j < gph.vexnum;j++)
if(!visited[j] && gph.AdjMatrix[k][j] < INT_MAX && spath[k]+gph.AdjMatrix[k][j] < spath[j])
{
spath[j] = spath[k]+gph.AdjMatrix[k][j];
pathrecord[j] = k;
}
}
free(visited);
cout << spath[u] << endl;
S.Push(u);
for(v = pathrecord[u];v != -1;v = pathrecord[v])
S.Push(v);
while(!S.StackEmpty())
{
S.Pop(i);
cout << gph.vertex[i] << " ";
}
cout << endl;
S.DestroyStack();
free(spath);
free(pathrecord);
}
template <class TElemType>
void Graph<TElemType>::Shortestpath_FLOYD(TElemType data1,TElemType data2)
{
int i,j,k,v,u,m;
int **D = (int **)malloc(gph.vexnum * sizeof(int *));
bool ***path = (bool ***)malloc(gph.vexnum * sizeof(bool **));
for(i = 0;i < gph.vexnum;i++)
{
D[i] = (int *)malloc(gph.vexnum * sizeof(int));
path[i] = (bool **)malloc(gph.vexnum * sizeof(bool *));
if(data1 == gph.vertex[i]) v = i;
if(data2 == gph.vertex[i]) u = i;
}
for(i = 0;i < gph.vexnum;i++)
for(j = 0;j < gph.vexnum;j++)
path[i][j] = (bool *)malloc(gph.vexnum *sizeof(bool));
for(i = 0;i < gph.vexnum;i++)
for(j = 0;j < gph.vexnum;j++)
{
D[i][j] = gph.AdjMatrix[i][j];
for(k = 0;k < gph.vexnum;k++)
path[i][j][k] = false;
if(D[i][j] < INT_MAX)
{
path[i][j][i] = true;path[i][j][j] = true;
}
}
for(k = 0;k < gph.vexnum;k++)
for(i = 0;i < gph.vexnum;i++)
for(j = 0;j < gph.vexnum;j++)
if(D[i][k] != INT_MAX && D[k][j] != INT_MAX && D[i][k]+D[k][j] < D[i][j])
{
D[i][j] = D[i][k] + D[k][j];
for(m = 0;m < gph.vexnum;m++)
path[i][j][m] = path[i][k][m] || path[k][j][m];
}
cout << "从" << gph.vertex[v] << "到" << gph.vertex[u] << "的最短路径及经过的点如下:" << endl;
cout << D[v][u] << endl;
for(i = 0;i < gph.vexnum;i++)
if(path[v][u][i] == true) cout << i << " ";
cout << endl;
for(i = 0;i < gph.vexnum;i++)
{
free(D[i]);
free(path[i]);
}
free(D);
free(path);
}
//***********end Graph
int main()
{
Graph<int> gph;
gph.CreateUDN();
gph.Minispantree_prim();
int data1,data2;
cout << "输入起点和终点:" << endl;
cin >> data1 >> data2;
gph.Shortestpath_DIJ(data1,data2);
//gph.Shortestpath_FLOYD(data1,data2);
gph.DestroyUDN();
return 0;
}
功能函数都实现了，可以自己在源程序中调用函数实现各种功能。
⑸ 有向图的邻接矩阵存储
有向图的邻接矩阵，用类似于二维链表做过，下面是c++的代码：
//顶点结构
structVexNode
{
chardata;
ArcNode*firstarc;
};
//弧结构
structArcNode
{//邻接顶点的下标
intadjvex;
ArcNode*nextarc;
};
classAdjList
{
private:
VexNodedata[100];
intvn,an;//顶点数弧数
public:
//构造函数以及其他的一些函数
AdjList();
virtual~AdjList();
};
⑹ 数据结构利用邻接矩阵存储结构怎样求图中两个顶点之间的所有路径
typedef struct {
ElemType vexs[MVN]; //顶点向量
AdjMatrix arcs; //邻接矩阵
int vexnum, arcnum; //图的当前顶点数和弧数
}MGraph;
int visited[100]; //指示顶点是否在当前路径上
bool exist(MGraph &G,int i,int j)
{
int k;
if(i == j)
{
return false;
}
else
{
if(G.arcs[i][j] == 1)
{
return true;
}
visited[i] = 1;
for(k = 0;k < G.vexnum;k++)
{
if(!visited[k] && exist(G,k,j))
{
return true;
}
}
}
}
int main()
{
system("pause");
return 0;
}
可以参考一下
⑺ 给出一个有向图的邻接表存，怎么画出其邻接矩阵存储，求详解，谢谢了
将每一行的链表中的结点的邻接点下标（比如第i个头结点的链表中的弧结点中的信息为j），放到邻接矩阵中就是A[i][j]=1，如果结点还有权值则为权值，除了这些非0元素外，其他的都是0（如果有权图则其他的都是无穷大）
如果有向图的邻接表中有k个弧（边）结点，则邻接矩阵中就有k个1（或者权值）