图的邻接表存储结构

// c7-2.h 图的邻接表存储结构(见图7.16)
#define MAX_VERTEX_NUM 20
enum GraphKind{DG,DN,UDG,UDN}; // {有向图,有向网,无向图,无向网}
struct ArcNode
{
	int adjvex; // 该弧所指向的顶点的位置
	ArcNode *nextarc; // 指向下一条弧的指针
	InfoType *info; // 网的权值指针
}; // 表结点
typedef struct
{
	VertexType data; // 顶点信息
	ArcNode *firstarc; // 第一个表结点的地址，指向第一条依附该顶点的弧的指针
}VNode,AdjList[MAX_VERTEX_NUM]; // 头结点
struct ALGraph
{
	AdjList vertices;
	int vexnum,arcnum; // 图的当前顶点数和弧数
	int kind; // 图的种类标志
};

图7
17 和图7
18 分别是有向图和无向网的的邻接表存储结构。要注意的是，为了
提高效率，bo7-2.cpp 中的基本操作函数CreateGraph()产生链表时总是在表头插入结点。
所以，对于给定的图，即使它的顶点输入顺序相同，邻接表的存储结构也不惟一。邻接表
的存储结构还与弧或边的输入顺序有关。

对于无向的图或网，每一条边产生2 个表结点，分别在该边的2 个顶点的链表上。由
图7
18 可见，2 条边的无向网有4 个表结点。为简化，无向网的每条边只动态生成1 个
存放权值的存储空间，由两个结点共同指向。由于邻接表存储结构中的链表的长度与该顶

点的邻接出弧或边数相等，显然，图的邻接表存储结构适合存储弧或边相对较少的稀
疏图。

由邻接表的存储结构可见，每个顶点的信息由表示顶点名称的字符串和不带头结点的
单链表组合而成。这样，对于单链表的处理，我们就可以利用不带头结点的单链表的基本
操作(在bo2-8.cpp 中)和扩展操作(在func2-1.cpp 中)来简化编程。为了能够利用这些操
作，需要将在bo2-8.cpp 和func2-1.cpp 中用到的类型ElemType、LNode、LinkList 和邻
接表的类型ArcNode 联系起来。c7-21.h 就是根据c7-2.h 建立了这种联系。

// c7-21.h 图的邻接表存储结构(与单链表的变量类型建立联系)
#define MAX_VERTEX_NUM 20
enum GraphKind{DG,DN,UDG,UDN}; // {有向图,有向网,无向图,无向网}
struct ElemType // 加(见图7.19)
{
	int adjvex; // 该弧所指向的顶点的位置
	InfoType *info; // 网的权值指针
};
struct ArcNode // 改(见图7.20)
{
	ElemType data; // 除指针以外的部分都属于ElemType
	ArcNode *nextarc; // 指向下一条弧的指针
}; // 表结点
typedef struct
{
	VertexType data; // 顶点信息
	ArcNode *firstarc; // 第一个表结点的地址,指向第一条依附该顶点的弧的指针
}VNode,AdjList[MAX_VERTEX_NUM]; // 头结点
struct ALGraph
{
	AdjList vertices;
	int vexnum,arcnum; // 图的当前顶点数和弧数
	int kind; // 图的种类标志
};
#define LNode ArcNode // 加，定义单链表的结点类型是图的表结点的类型
#define next nextarc // 加，定义单链表结点的指针域是表结点指向下一条弧的指针域
typedef ArcNode *LinkList; // 加，定义指向单链表结点的指针是指向图的表结点的指针

// bo7-2.cpp 图的邻接表存储(存储结构由c7-21.h定义)的基本操作(15个)，包括算法7.4～7.6
#include"bo2-8.cpp" // 不带头结点的单链表基本操作
#include"func2-1.cpp" // 不带头结点的单链表扩展操作
int LocateVex(ALGraph G,VertexType u)
{ // 初始条件：图G存在，u和G中顶点有相同特征
	// 操作结果：若G中存在顶点u，则返回该顶点在图中位置；否则返回-1
	int i;
	for(i=0;i<G.vexnum;++i)
		if(strcmp(u,G.vertices[i].data)==0)
			return i;
		return -1;
}
void CreateGraph(ALGraph &G)
{ // 采用邻接表存储结构，构造没有相关信息图或网G(用一个函数构造4种图)
	int i,j,k,w; // w是权值
	VertexType va,vb; // 连接边或弧的2顶点
	ElemType e;
	printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
	scanf("%d",&G.kind);
	printf("请输入图的顶点数,边数: ");
	scanf("%d,%d",&G.vexnum,&G.arcnum);
	printf("请输入%d个顶点的值(<%d个字符):\n",G.vexnum,MAX_NAME);
	for(i=0;i<G.vexnum;++i) // 构造顶点向量
	{
		scanf("%s",G.vertices[i].data);
		G.vertices[i].firstarc=NULL; // 初始化与该顶点有关的出弧链表
	}
	if(G.kind%2) // 网
		printf("请输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");
	else // 图
		printf("请输入每条弧(边)的弧尾和弧头(以空格作为间隔):\n");
	for(k=0;k<G.arcnum;++k) // 构造相关弧链表
	{
		if(G.kind%2) // 网
			scanf("%d%s%s",&w,va,vb);
		else // 图
			scanf("%s%s",va,vb);
		i=LocateVex(G,va); // 弧尾
		j=LocateVex(G,vb); // 弧头
		e.info=NULL; // 给待插表结点e赋值，图无权
		e.adjvex=j; // 弧头
		if(G.kind%2) // 网
		{
			e.info=(int *)malloc(sizeof(int)); // 动态生成存放权值的空间
			*(e.info)=w;
		}
		ListInsert(G.vertices[i].firstarc,1,e); // 插在第i个元素(出弧)的表头，在bo2-8.cpp中
		if(G.kind>=2) // 无向图或网，产生第2个表结点，并插在第j个元素(入弧)的表头
		{
			e.adjvex=i; // e.info不变，不必再赋值
			ListInsert(G.vertices[j].firstarc,1,e); // 插在第j个元素的表头，在bo2-8.cpp中
		}
	}
}
void CreateGraphF(ALGraph &G)
{ // 采用邻接表存储结构，由文件构造没有相关信息图或网G(用一个函数构造4种图)
	int i,j,k,w; // w是权值
	VertexType va,vb; // 连接边或弧的2顶点
	ElemType e;
	char filename[13];
	FILE *graphlist;
	printf("请输入数据文件名(f7-1.txt或f7-2.txt)：");
	scanf("%s",filename);
	printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
	scanf("%d",&G.kind);
	graphlist=fopen(filename,"r"); // 以读的方式打开数据文件，并以graphlist表示
	fscanf(graphlist,"%d",&G.vexnum);
	fscanf(graphlist,"%d",&G.arcnum);
	for(i=0;i<G.vexnum;++i) // 构造顶点向量
	{
		fscanf(graphlist,"%s",G.vertices[i].data);
		G.vertices[i].firstarc=NULL; // 初始化与该顶点有关的出弧链表
	}
	for(k=0;k<G.arcnum;++k) // 构造相关弧链表
	{
		if(G.kind%2) // 网
			fscanf(graphlist,"%d%s%s",&w,va,vb);
		else // 图
			fscanf(graphlist,"%s%s",va,vb);
		i=LocateVex(G,va); // 弧尾
		j=LocateVex(G,vb); // 弧头
		e.info=NULL; // 给待插表结点e赋值，图无权
		e.adjvex=j; // 弧头
		if(G.kind%2) // 网
		{
			e.info=(int *)malloc(sizeof(int)); // 动态生成存放权值的空间
			*(e.info)=w;
		}
		ListInsert(G.vertices[i].firstarc,1,e); // 插在第i个元素(出弧)的表头，在bo2-8.cpp中
		if(G.kind>=2) // 无向图或网，产生第2个表结点，并插在第j个元素(入弧)的表头
		{
			e.adjvex=i; // e.info不变，不必再赋值
			ListInsert(G.vertices[j].firstarc,1,e); // 插在第j个元素的表头，在bo2-8.cpp中
		}
	}
	fclose(graphlist); // 关闭数据文件
}
void DestroyGraph(ALGraph &G)
{ // 初始条件：图G存在。操作结果：销毁图G
	int i;
	ElemType e;
	for(i=0;i<G.vexnum;++i) // 对于所有顶点
		if(G.kind%2) // 网
			while(G.vertices[i].firstarc) // 对应的弧或边链表不空
			{
				ListDelete(G.vertices[i].firstarc,1,e); // 删除链表的第1个结点，并将值赋给e
				if(e.adjvex>i) // 顶点序号>i(保证动态生成的权值空间只释放1次)
					free(e.info);
			}
			else // 图
				DestroyList(G.vertices[i].firstarc); // 销毁弧或边链表，在bo2-8.cpp中
			G.vexnum=0; // 顶点数为0
			G.arcnum=0; // 边或弧数为0
}
VertexType& GetVex(ALGraph G,int v)
{ // 初始条件：图G存在，v是G中某个顶点的序号。操作结果：返回v的值
	if(v>=G.vexnum||v<0)
		exit(ERROR);
	return G.vertices[v].data;
}
Status PutVex(ALGraph &G,VertexType v,VertexType value)
{ // 初始条件：图G存在，v是G中某个顶点。操作结果：对v赋新值value
	int i;
	i=LocateVex(G,v);
	if(i>-1) // v是G的顶点
	{
		strcpy(G.vertices[i].data,value);
		return OK;
	}
	return ERROR;
}
int FirstAdjVex(ALGraph G,VertexType v)
{ // 初始条件：图G存在，v是G中某个顶点
	// 操作结果：返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点，则返回-1
	ArcNode *p;
	int v1;
	v1=LocateVex(G,v); // v1为顶点v在图G中的序号
	p=G.vertices[v1].firstarc;
	if(p)
		return p->data.adjvex;
	else
		return -1;
}
Status equalvex(ElemType a,ElemType b)
{ // DeleteArc()、DeleteVex()和NextAdjVex()要调用的函数
	if(a.adjvex==b.adjvex)
		return OK;
	else
		return ERROR;
}
int NextAdjVex(ALGraph G,VertexType v,VertexType w)
{ // 初始条件：图G存在，v是G中某个顶点，w是v的邻接顶点
	// 操作结果：返回v的(相对于w的)下一个邻接顶点的序号。若w是v的最后一个邻接点，则返回-1
	LinkList p,p1; // p1在Point()中用作辅助指针，Point()在func2-1.cpp中
	ElemType e;
	int v1;
	v1=LocateVex(G,v); // v1为顶点v在图G中的序号
	e.adjvex=LocateVex(G,w); // e.adjvex为顶点w在图G中的序号
	p=Point(G.vertices[v1].firstarc,e,equalvex,p1); // p指向顶点v的链表中邻接顶点为w的结点
	if(!p||!p->next) // 没找到w或w是最后一个邻接点
		return -1;
	else // p->data.adjvex==w
		return p->next->data.adjvex; // 返回v的(相对于w的)下一个邻接顶点的序号
}
void InsertVex(ALGraph &G,VertexType v)
{ // 初始条件：图G存在，v和图中顶点有相同特征
	// 操作结果：在图G中增添新顶点v(不增添与顶点相关的弧，留待InsertArc()去做)
	strcpy(G.vertices[G.vexnum].data,v); // 构造新顶点向量
	G.vertices[G.vexnum].firstarc=NULL;
	G.vexnum++; // 图G的顶点数加1
}
Status DeleteVex(ALGraph &G,VertexType v)
{ // 初始条件：图G存在，v是G中某个顶点。操作结果：删除G中顶点v及其相关的弧
	int i,j,k;
	ElemType e;
	LinkList p,p1;
	j=LocateVex(G,v); // j是顶点v的序号
	if(j<0) // v不是图G的顶点
		return ERROR;
	i=ListLength(G.vertices[j].firstarc); // 以v为出度的弧或边数，在bo2-8.cpp中
	G.arcnum-=i; // 边或弧数-i
	if(G.kind%2) // 网
		while(G.vertices[j].firstarc) // 对应的弧或边链表不空
		{
			ListDelete(G.vertices[j].firstarc,1,e); // 删除链表的第1个结点，并将值赋给e
			free(e.info); // 释放动态生成的权值空间
		}
		else // 图
			DestroyList(G.vertices[j].firstarc); // 销毁弧或边链表，在bo2-8.cpp中
		G.vexnum--; // 顶点数减1
		for(i=j;i<G.vexnum;i++) // 顶点v后面的顶点前移
			G.vertices[i]=G.vertices[i+1];
		for(i=0;i<G.vexnum;i++) // 删除以v为入度的弧或边且必要时修改表结点的顶点位置值
		{
			e.adjvex=j;
			p=Point(G.vertices[i].firstarc,e,equalvex,p1); // Point()在func2-1.cpp中
			if(p) // 顶点i的邻接表上有v为入度的结点
			{
				if(p1) // p1指向p所指结点的前驱
					p1->next=p->next; // 从链表中删除p所指结点
				else // p指向首元结点
					G.vertices[i].firstarc=p->next; // 头指针指向下一结点
				if(G.kind<2) // 有向
				{
					G.arcnum--; // 边或弧数-1
					if(G.kind==1) // 有向网
						free(p->data.info); // 释放动态生成的权值空间
				}
				free(p); // 释放v为入度的结点
			}
			for(k=j+1;k<=G.vexnum;k++) // 对于adjvex域>j的结点，其序号-1
			{
				e.adjvex=k;
				p=Point(G.vertices[i].firstarc,e,equalvex,p1); // Point()在func2-1.cpp中
				if(p)
					p->data.adjvex--; // 序号-1(因为前移)
			}
		}
		return OK;
}
Status InsertArc(ALGraph &G,VertexType v,VertexType w)
{ // 初始条件：图G存在，v和w是G中两个顶点
	// 操作结果：在G中增添弧<v,w>，若G是无向的，则还增添对称弧<w,v>
	ElemType e;
	int i,j;
	i=LocateVex(G,v); // 弧尾或边的序号
	j=LocateVex(G,w); // 弧头或边的序号
	if(i<0||j<0)
		return ERROR;
	G.arcnum++; // 图G的弧或边的数目加1
	e.adjvex=j;
	e.info=NULL; // 初值
	if(G.kind%2) // 网
	{
		e.info=(int *)malloc(sizeof(int)); // 动态生成存放权值的空间
		printf("请输入弧(边)%s→%s的权值: ",v,w);
		scanf("%d",e.info);
	}
	ListInsert(G.vertices[i].firstarc,1,e); // 将e插在弧尾的表头，在bo2-8.cpp中
	if(G.kind>=2) // 无向，生成另一个表结点
	{
		e.adjvex=i; // e.info不变
		ListInsert(G.vertices[j].firstarc,1,e); // 将e插在弧头的表头
	}
	return OK;
}
Status DeleteArc(ALGraph &G,VertexType v,VertexType w)
{ // 初始条件：图G存在，v和w是G中两个顶点
	// 操作结果：在G中删除弧<v,w>，若G是无向的，则还删除对称弧<w,v>
	int i,j;
	Status k;
	ElemType e;
	i=LocateVex(G,v); // i是顶点v(弧尾)的序号
	j=LocateVex(G,w); // j是顶点w(弧头)的序号
	if(i<0||j<0||i==j)
		return ERROR;
	e.adjvex=j;
	k=DeleteElem(G.vertices[i].firstarc,e,equalvex); // 在func2-1.cpp中
	if(k) // 删除成功
	{
		G.arcnum--; // 弧或边数减1
		if(G.kind%2) // 网
			free(e.info);
		if(G.kind>=2) // 无向，删除对称弧<w,v>
		{
			e.adjvex=i;
			DeleteElem(G.vertices[j].firstarc,e,equalvex);
		}
		return OK;
	}
	else // 没找到待删除的弧
		return ERROR;
}
Boolean visited[MAX_VERTEX_NUM]; // 访问标志数组(全局量)
void(*VisitFunc)(char* v); // 函数变量(全局量)
void DFS(ALGraph G,int v)
{ // 从第v个顶点出发递归地深度优先遍历图G。算法7.5
	int w;
	visited[v]=TRUE; // 设置访问标志为TRUE(已访问)
	VisitFunc(G.vertices[v].data); // 访问第v个顶点
	for(w=FirstAdjVex(G,G.vertices[v].data);w>=0;w=NextAdjVex(G,G.vertices[v].data,
		G.vertices[w].data))
		if(!visited[w])
			DFS(G,w); // 对v的尚未访问的邻接点w递归调用DFS
}
void DFSTraverse(ALGraph G,void(*Visit)(char*))
{ // 对图G作深度优先遍历。算法7.4
	int v;
	VisitFunc=Visit; // 使用全局变量VisitFunc，使DFS不必设函数指针参数
	for(v=0;v<G.vexnum;v++)
		visited[v]=FALSE; // 访问标志数组初始化
	for(v=0;v<G.vexnum;v++)
		if(!visited[v])
			DFS(G,v); // 对尚未访问的顶点调用DFS
		printf("\n");
}
typedef int QElemType; // 队列元素类型
#include"c3-2.h" // 链队列的存储结构
#include"bo3-2.cpp" // 链队列的基本操作
void BFSTraverse(ALGraph G,void(*Visit)(char*))
{//按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组visited。算法7.6
	int v,u,w;
	LinkQueue Q;
	for(v=0;v<G.vexnum;++v)
		visited[v]=FALSE; // 置初值
	InitQueue(Q); // 置空的辅助队列Q
	for(v=0;v<G.vexnum;v++) // 如果是连通图，只v=0就遍历全图
		if(!visited[v]) // v尚未访问
		{
			visited[v]=TRUE;
			Visit(G.vertices[v].data);
			EnQueue(Q,v); // v入队列
			while(!QueueEmpty(Q)) // 队列不空
			{
				DeQueue(Q,u); // 队头元素出队并置为u
				for(w=FirstAdjVex(G,G.vertices[u].data);w>=0;w=NextAdjVex(G,G.vertices[u].data,
					G.vertices[w].data))
					if(!visited[w]) // w为u的尚未访问的邻接顶点
					{
						visited[w]=TRUE;
						Visit(G.vertices[w].data);
						EnQueue(Q,w); // w入队
					}
			}
		}
		printf("\n");
}
void DFS1(ALGraph G,int v,void(*Visit)(char*))
{ // 从第v个顶点出发递归地深度优先遍历图G。仅适用于邻接表存储结构
	ArcNode *p; // p指向表结点
	visited[v]=TRUE; // 设置访问标志为TRUE(已访问)
	Visit(G.vertices[v].data); // 访问该顶点
	for(p=G.vertices[v].firstarc;p;p=p->next) // p依次指向v的邻接顶点
		if(!visited[p->data.adjvex])
			DFS1(G,p->data.adjvex,Visit); // 对v的尚未访问的邻接点递归调用DFS1
}
void DFSTraverse1(ALGraph G,void(*Visit)(char*))
{ // 对图G作深度优先遍历。DFS1设函数指针参数
	int v;
	for(v=0;v<G.vexnum;v++)
		visited[v]=FALSE; // 访问标志数组初始化，置初值为未被访问
	for(v=0;v<G.vexnum;v++) // 如果是连通图，只v=0就遍历全图
		if(!visited[v]) // v尚未被访问
			DFS1(G,v,Visit); // 对v调用DFS1
		printf("\n");
}
void BFSTraverse1(ALGraph G,void(*Visit)(char*))
{ // 按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组visited。仅适用于邻接表结构
	int v,u;
	ArcNode *p; // p指向表结点
	LinkQueue Q; // 链队列类型
	for(v=0;v<G.vexnum;++v)
		visited[v]=FALSE; // 置初值为未被访问
	InitQueue(Q); // 初始化辅助队列Q
	for(v=0;v<G.vexnum;v++) // 如果是连通图，只v=0就遍历全图
		if(!visited[v]) // v尚未被访问
		{
			visited[v]=TRUE; // 设v为已被访问
			Visit(G.vertices[v].data); // 访问v
			EnQueue(Q,v); // v入队列
			while(!QueueEmpty(Q)) // 队列不空
			{
				DeQueue(Q,u); // 队头元素出队并置为u
				for(p=G.vertices[u].firstarc;p;p=p->next) // p依次指向u的邻接顶点
					if(!visited[p->data.adjvex]) // u的邻接顶点尚未被访问
					{
						visited[p->data.adjvex]=TRUE; // 该邻接顶点设为已被访问
						Visit(G.vertices[p->data.adjvex].data); // 访问该邻接顶点
						EnQueue(Q,p->data.adjvex); // 入队该邻接顶点序号
					}
			}
		}
		printf("\n");
}
void Display(ALGraph G)
{ // 输出图的邻接矩阵G
	int i;
	ArcNode *p;
	switch(G.kind)
	{
	case DG: printf("有向图\n");
		break;
	case DN: printf("有向网\n");
		break;
	case UDG:printf("无向图\n");
		break;
	case UDN:printf("无向网\n");
	}
	printf("%d个顶点：\n",G.vexnum);
	for(i=0;i<G.vexnum;++i)
		printf("%s ",G.vertices[i].data);
	printf("\n%d条弧(边):\n",G.arcnum);
	for(i=0;i<G.vexnum;i++)
	{
		p=G.vertices[i].firstarc;
		while(p)
		{
			if(G.kind<=1||i<p->data.adjvex) // 有向或无向两次中的一次
			{
				printf("%s→%s ",G.vertices[i].data,G.vertices[p->data.adjvex].data);
				if(G.kind%2) // 网
					printf(":%d ",*(p->data.info));
			}
			p=p->nextarc;
		}
		printf("\n");
	}
}

// main7-2.cpp 检验bo7-2.cpp的主程序
#include"c1.h"
#define MAX_NAME 3 // 顶点字符串的最大长度+1
typedef int InfoType; // 网的权值类型
typedef char VertexType[MAX_NAME]; // 顶点类型为字符串
#include"c7-21.h"
#include"bo7-2.cpp"
void print(char *i)
{
	printf("%s ",i);
}
void main()
{
	int i,j,k,n;
	ALGraph g;
	VertexType v1,v2;
	printf("请顺序选择有向图,有向网,无向图,无向网\n");
	for(i=0;i<4;i++) // 验证4种情况
	{
		CreateGraph(g);
		Display(g);
		printf("插入新顶点，请输入顶点的值: ");
		scanf("%s",v1);
		InsertVex(g,v1);
		printf("插入与新顶点有关的弧或边，请输入弧或边数: ");
		scanf("%d",&n);
		for(k=0;k<n;k++)
		{
			printf("请输入另一顶点的值: ");
			scanf("%s",v2);
			if(g.kind<=1) // 有向
			{
				printf("对于有向图或网，请输入另一顶点的方向(0:弧头1:弧尾): ");
				scanf("%d",&j);
				if(j)
					InsertArc(g,v2,v1);
				else
					InsertArc(g,v1,v2);
			}
			else // 无向
				InsertArc(g,v1,v2);
		}
		Display(g);
		if(i==3)
		{
			printf("删除一条边或弧，请输入待删除边或弧的弧尾弧头：");
			scanf("%s%s",v1,v2);
			DeleteArc(g,v1,v2);
			printf("修改顶点的值，请输入原值新值: ");
			scanf("%s%s",v1,v2);
			PutVex(g,v1,v2);
		}
		printf("删除顶点及相关的弧或边，请输入顶点的值: ");
		scanf("%s",v1);
		DeleteVex(g,v1);
		Display(g);
		DestroyGraph(g);
	}
}

代码的运行结果：

请顺序选择有向图,有向网,无向图,无向网
请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): 0
请输入图的顶点数,边数: 2,1
请输入2个顶点的值(<3个字符):
a1 a2
请输入每条弧(边)的弧尾和弧头(以空格作为间隔):
a2 a1
有向图(见图7
21)
2个顶点：
a1 a2
1条弧(边):
a2→a1

插入新顶点，请输入顶点的值: a3
插入与新顶点有关的弧或边，请输入弧或边数: 2
请输入另一顶点的值: a1
对于有向图或网，请输入另一顶点的方向(0:弧头1:弧尾): 0
请输入另一顶点的值: a2
对于有向图或网，请输入另一顶点的方向(0:弧头1:弧尾): 1
有向图(见图7
22)
3个顶点：
a1 a2 a3
3条弧(边):
a2→a3 a2→a1
a3→a1

删除顶点及相关的弧或边，请输入顶点的值: a1
有向图(见图7
23)
2个顶点：
a2 a3
1条弧(边):
a2→a3

请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): 1
请输入图的顶点数,边数: 2,1
请输入2个顶点的值(<3个字符):

b1 b2
请输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):
3 b1 b2
有向网(见图7
24)
2个顶点：
b1 b2
1条弧(边):
b1→b2 :3
插入新顶点，请输入顶点的值: b3
插入与新顶点有关的弧或边，请输入弧或边数: 2
请输入另一顶点的值: b1
对于有向图或网，请输入另一顶点的方向(0:弧头1:弧尾): 0
请输入弧(边)b3→b1的权值: 5
请输入另一顶点的值: b2
对于有向图或网，请输入另一顶点的方向(0:弧头1:弧尾): 1
请输入弧(边)b2→b3的权值: 6
有向网(见图7
25)
3个顶点：
b1 b2 b3
3条弧(边):
b1→b2 :3
b2→b3 :6
b3→b1 :5
删除顶点及相关的弧或边，请输入顶点的值: b2
有向网(见图7
26)
2个顶点：
b1 b3
1条弧(边):
b3→b1 :5

请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): 2
请输入图的顶点数,边数: 2,1
请输入2个顶点的值(<3个字符):
c1 c2
请输入每条弧(边)的弧尾和弧头(以空格作为间隔):
c1 c2
无向图(见图7
27)
2个顶点：
c1 c2
1条弧(边):
c1→c2
插入新顶点，请输入顶点的值: c3
插入与新顶点有关的弧或边，请输入弧或边数: 2
请输入另一顶点的值: c1
请输入另一顶点的值: c2
无向图(见图7
28)
3个顶点：
c1 c2 c3
3条弧(边):

c1→c3 c1→c2
c2→c3
删除顶点及相关的弧或边，请输入顶点的值: c3
无向图(见图7
29)
2个顶点：
c1 c2
1条弧(边):
c1→c2
请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): 3
请输入图的顶点数,边数: 2,1
请输入2个顶点的值(<3个字符):
d1 d2
请输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):
5 d1 d2
无向网(见图7
30)
2个顶点：
d1 d2
1条弧(边):
d1→d2 :5
插入新顶点，请输入顶点的值: d3
插入与新顶点有关的弧或边，请输入弧或边数: 2
请输入另一顶点的值: d1
请输入弧(边)d3→d1的权值: 4
请输入另一顶点的值: d2
请输入弧(边)d3→d2的权值: 6
无向网(见图7
31)
3个顶点：
d1 d2 d3
3条弧(边):
d1→d3 :4 d1→d2 :5
d2→d3 :6

删除一条边或弧，请输入待删除边或弧的弧尾弧头：d1 d2
修改顶点的值，请输入原值新值: d1 D1
删除顶点及相关的弧或边，请输入顶点的值: d2
无向网(见图7
32)
2个顶点：
D1 d3
1条弧(边):
D1→d3 :4