数据结构(B)上机实验四__图

数据结构上机实验六

实验内容:图的基本操作

实验要求:

1) 图的遍历与基本操作要作为函数被调用.

2) 把自己使用的图结构明确的表达出来.

3) 基本上实现每个实验题目的要求.

分组要求：可单独完成，也可两人一组。

实验目的:

1)熟悉C/C++基本编程,培养动手能力.

2)通过实验,加深对图的理解.

评分标准：

1) 只完成第一和第二题，根据情况得4，5分；

2）完成前3题，根据情况得5，6分；

3）在2）基础上，选做四）中题目，根据情况得7到10分。

题目:

一)建立一个无向图+遍历+插入

(1)以数组表示法作为存储结构，从键盘依次输入顶点数、弧数与各弧信息建立一个无向图；

(2)对（1）中生成的无向图进行广度优先遍历并打印结果；

(3)向（1）中生成的无向图插入一条新弧并打印结果；

二)建立一个有向图+遍历+插入+删除

(1)以邻接表作为图的存储结构，从键盘输入图的顶点与弧的信息建立一个有向图；

(2)对（1）中生成的有向图进行深度优先遍历并打印结果；

(3)在（1）中生成的有向图中，分别插入与删除一条弧并打印其结果；

(4)在（1）中生成的有向图中，分别插入与删除一个顶点并打印结果；

(5) 在（1）中生成的有向图中,各顶点的入度与出度并打印结果；

三）基本应用题

（1）编写算法，判断图中指定的两个顶点是否连通。

（2）编写算法，判断图的连通性。如果不连通，求连通分量的个数

（3）编写算法，判断图中任意两个顶点的连通性

（4）编写算法，判断图中是否存在回路。

（5）实现图的广度优先搜索算法。

四）高级应用题

（1）实现Prim算法

（2）实现Kruskal算法

（3）实现迪杰斯特拉算法

（4）实现拓扑排序算法

（5）实现关键路径算法

一)建立一个无向图+遍历+插入

(1)以数组表示法作为存储结构，从键盘依次输入顶点数、弧数与各弧信息建立一个无向图；

(2)对（1）中生成的无向图进行广度优先遍历并打印结果；

(3)向（1）中生成的无向图插入一条新弧并打印结果；

#include

#include

#include

#include

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define OVERFLOW -2

#define MAX_NAME 5 /* 顶点字符串的最大长度+1 */

#define MAX_INFO 20 /* 相关信息字符串的最大长度+1 */

#define INFINITY INT_MAX /* 用整型最大值代替∞ */

#define MAX_VERTEX_NUM 20 /* 最大顶点个数 */

typedef int Boolean;

Boolean visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */

typedef int Status;

typedef int VRType;

typedef char InfoType;

typedef char VertexType[MAX_NAME];

typedef enum{DG,DN,AG,AN}GraphKind; /* {有向图,有向网,无向图,无向网} */

typedef struct

{

VRType adj; /* 顶点关系类型。对无权图，用1(是)或0(否)表示相邻否； */

/* 对带权图，c则为权值类型 */

InfoType *info; /* 该弧相关信息的指针(可无) */

}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct

{

VertexType vexs[MAX_VERTEX_NUM]; /* 顶点向量 */

AdjMatrix arcs; /* 邻接矩阵 */

int vexnum,arcnum; /* 图的当前顶点数和弧数 */

GraphKind kind; /* 图的种类标志 */

}MGraph;

int LocateVex(MGraph G,VertexType u)

{ /* 初始条件:图G存在,u和G中顶点有相同特征 */

/* 操作结果:若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */ int i;

for(i=0;i

if(strcmp(u,G.vexs[i])==0)

return i;

return -1;

}

Status CreateAG(MGraph &G)

{ /* 采用数组(邻接矩阵)表示法,构造无向图G */

int i,j,k,l,IncInfo;

char ch,s[MAX_INFO],*info;

VertexType va,vb;

printf("请输入无向图G的顶点数,边数,边是否含其它信息(是:1,否:0): "); scanf("%d %d %d",&G.vexnum,&G.arcnum,&IncInfo);

printf("请输入%d个顶点的值(<%d个字符):\n",G.vexnum,MAX_NAME);

for(i=0;i

scanf("%s",G.vexs[i]);

for(i=0;i

for(j=0;j

{

G.arcs[i][j].adj=0; /* 图 */

G.arcs[i][j].info=NULL;

}

printf("请输入%d条边的顶点1 顶点2(以空格作为间隔): \n",G.arcnum); for(k=0;k

{

scanf("%s",va);

scanf("%s",vb);

ch=getchar();

i=LocateVex(G,va);

j=LocateVex(G,vb);

G.arcs[i][j].adj=G.arcs[j][i].adj=1; /* 无向图 */

if(IncInfo)

{

printf("请输入该边的相关信息(<%d个字符): ",MAX_INFO);

scanf("%s",s);

l=strlen(s);

if(l)

{

info=(char*)malloc((l+1)*sizeof(char));

strcpy(info,s);

G.arcs[i][j].info=G.arcs[j][i].info=info; /* 无向 */

}

}

if(k

printf("请输入下一条边的顶点1 顶点2：\n");

}

G.kind=AG;

return OK;

}

typedef VRType QElemType; /* 队列类型 */

typedef struct QNode

{

QElemType data;

struct QNode *next;

}QNode,*QueuePtr;

typedef struct

{

QueuePtr front,rear; /* 队头、队尾指针 */

}LinkQueue;

Status InitQueue(LinkQueue *Q)

{ /* 构造一个空队列Q */

(*Q).front=(*Q).rear=(QueuePtr)malloc(sizeof(QNode));

if(!(*Q).front)

exit(OVERFLOW);

(*Q).front->next=NULL;

return OK;

}

Status QueueEmpty(LinkQueue Q)

{ /* 若Q为空队列,则返回TRUE,否则返回FALSE */

if(Q.front==Q.rear)

return TRUE;

else

return FALSE;

}

Status EnQueue(LinkQueue *Q,QElemType e)

{ /* 插入元素e为Q的新的队尾元素 */

QueuePtr p=(QueuePtr)malloc(sizeof(QNode));

if(!p) /* 存储分配失败 */

exit(OVERFLOW);

p->data=e;

p->next=NULL;

(*Q).rear->next=p;

(*Q).rear=p;

return OK;

}

Status DeQueue(LinkQueue *Q,QElemType *e)

{ /* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */ QueuePtr p;

if((*Q).front==(*Q).rear)

return ERROR;

p=(*Q).front->next;

*e=p->data;

(*Q).front->next=p->next;

if((*Q).rear==p)

(*Q).rear=(*Q).front;

free(p);

return OK;

}

void Visit(VertexType V)

{

printf("%s ",V);

}

int FirstAdjVex(MGraph G,VertexType v)

{ /* 初始条件: 图G存在,v是G中某个顶点 */

/* 操作结果: 返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1 */ int i,j=0,k;

k=LocateVex(G,v); /* k为顶点v在图G中的序号 */

for(i=0;i

if(G.arcs[k][i].adj!=j)

return i;

return -1;

}

int NextAdjVex(MGraph G,VertexType v,VertexType w)

{ /* 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点 */

/* 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号, */

/* 若w是v的最后一个邻接顶点,则返回-1 */

int i,j=0,k1,k2;

k1=LocateVex(G,v); /* k1为顶点v在图G中的序号 */

k2=LocateVex(G,w); /* k2为顶点w在图G中的序号 */

for(i=k2+1;i

if(G.arcs[k1][i].adj!=j)

return i;

return -1;

}

VertexType* GetVex(MGraph G,int v)

{ /* 初始条件: 图G存在，v是G中某个顶点的序号。操作结果: 返回v的值 */ if(v>=G.vexnum||v<0)

exit(ERROR);

return &G.vexs[v];

}

void BFSTraverse(MGraph G)

{ /* 初始条件: 图G存在,Visit是顶点的应用函数。算法7.6 */

/* 操作结果: 从第1个顶点起,按广度优先非递归遍历图G,并对每个顶点调用函数 */

/* Visit一次且仅一次。一旦Visit()失败,则操作失败。 */

/* 使用辅助队列Q和访问标志数组visited */

int v,u,w;

VertexType w1,u1;

LinkQueue Q;

for(v=0;v

visited[v]=FALSE; /* 置初值 */

InitQueue(&Q); /* 置空的辅助队列Q */

printf("按广度优先遍历图：\n");

for(v=0;v

if(!visited[v]) /* v尚未访问 */

{

visited[v]=TRUE; /* 设置访问标志为TRUE(已访问) */

Visit(G.vexs[v]);

EnQueue(&Q,v); /* v入队列 */

while(!QueueEmpty(Q)) /* 队列不空 */

{

DeQueue(&Q,&u); /* 队头元素出队并置为u */

strcpy(u1,*GetVex(G,u));

for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w))))

if(!visited[w]) /* w为u的尚未访问的邻接顶点的序号 */

{

visited[w]=TRUE;

Visit(G.vexs[w]);

EnQueue(&Q,w);

}

}

}

printf("\n");

}

Status InsertArc(MGraph &G,VertexType v,VertexType w)

{ /* 初始条件: 图G存在,v和W是G中两个顶点 */

/* 操作结果: 在G中增添弧,若G是无向的,则还增添对称弧 */ int i,l,v1,w1;

char *info,s[MAX_INFO];

v1=LocateVex(G,v); /* 尾 */

w1=LocateVex(G,w); /* 头 */

if(v1<0||w1<0)

return ERROR;

G.arcnum++; /* 弧或边数加1 */

G.arcs[v1][w1].adj=1;

printf("是否有该弧或边的相关信息(0:无 1:有): ");

scanf("%d%*c",&i);

if(i)

{

printf("请输入该弧或边的相关信息(<%d个字符)：",MAX_INFO);

gets(s);

l=strlen(s);

if(l)

{

info=(char*)malloc((l+1)*sizeof(char));

strcpy(info,s);

G.arcs[v1][w1].info=info;

}

}

G.arcs[w1][v1].adj=G.arcs[v1][w1].adj;

G.arcs[w1][v1].info=G.arcs[v1][w1].info; /* 指向同一个相关信息 */

return OK;

}

void Display(MGraph G)

{ /* 输出邻接矩阵G */

int i,j;

char s[7],s1[3];

switch(G.kind)

{

case DG: strcpy(s,"有向图\0");

strcpy(s1,"弧\0");

break;

case DN: strcpy(s,"有向网\0");

strcpy(s1,"弧\0");

break;

case AG: strcpy(s,"无向图\0");

strcpy(s1,"边\0");

break;

case AN: strcpy(s,"无向网\0");

strcpy(s1,"边\0");

}

printf("%d个顶点%d条%s的%s\n",G.vexnum,G.arcnum,s1,s);

for(i=0;i

printf("G.vexs[%d]=%s\n",i,G.vexs[i]);

printf("G.arcs.adj:\n"); /* 输出G.arcs.adj */

for(i=0;i

{

for(j=0;j

printf("%6d",G.arcs[i][j].adj);

printf("\n");

}

printf("https://www.360docs.net/doc/d216231745.html,:\n"); /* 输出https://www.360docs.net/doc/d216231745.html, */

printf("顶点1(弧尾) 顶点2(弧头) 该%s信息：\n",s1);

for(i=0;i

for(j=i+1;j

if(G.arcs[i][j].info)

printf("%5s %11s %s\n",G.vexs[i],G.vexs[j],G.arcs[i][j].info); }

void main()

{

char ch;

VertexType va,vb;

MGraph G;

CreateAG(G);

Display(G);

printf("\n");

BFSTraverse(G);

printf("\n");

printf("请输入要插入的弧所连接的顶点：");

scanf("%s",va);

scanf("%s",vb);

//ch=getchar();

InsertArc(G,va,vb);

Display(G);

printf("\n");

BFSTraverse(G);

}

二)建立一个有向图+遍历+插入+删除

(1)以邻接表作为图的存储结构，从键盘输入图的顶点与弧的信息建立一个有向图；

(2)对（1）中生成的有向图进行深度优先遍历并打印结果；

(3)在（1）中生成的有向图中，分别插入与删除一条弧并打印其结果；

(4)在（1）中生成的有向图中，分别插入与删除一个顶点并打印结果；

(5) 在（1）中生成的有向图中,各顶点的入度与出度并打印结果；

#include

#include

#include

#include

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define OVERFLOW -2

#define MAX_VERTEX_NUM 20

#define MAX_NAME 5 /* 顶点字符串的最大长度+1 */

typedef int Boolean;

Boolean visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */

typedef int Status;

typedef int VRType;

typedef char InfoType;

typedef char VertexType[MAX_NAME];

typedef enum{DG,DN,AG,AN}GraphKind; /* {有向图,有向网,无向图,无向网} */ typedef struct ArcNode

{

int adjvex; /* 该弧所指向的顶点的位置 */

struct ArcNode *nextarc; /* 指向下一条弧的指针 */

InfoType *info; /* 网的权值指针） */

}ArcNode;

typedef struct

{

VertexType data; /* 顶点信息 */

ArcNode *firstarc; /* 第一个表结点的地址,指向第一条依附该顶点的弧的指针 */ }VNode,AdjList[MAX_VERTEX_NUM]; /* 头结点 */

typedef struct

{

AdjList vertices;

int vexnum,arcnum; /* 图的当前顶点数和弧数 */

int kind; /* 图的种类标志 */

}ALGraph;

int LocateVex(ALGraph G,VertexType u)

{ /* 初始条件: 图G存在,u和G中顶点有相同特征 */

/* 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */ int i;

for(i=0;i

if(strcmp(u,G.vertices[i].data)==0)

return i;

return -1;

}

Status CreateGraph(ALGraph &G)

{ /* 采用邻接表存储结构,构造没有相关信息的有向图G*/

int i,j,k;

VertexType va,vb;

ArcNode *p;

G.kind=0;

printf("请输入图的顶点数,边数: ");

scanf("%d %d",&G.vexnum,&G.arcnum);

printf("请输入%d个顶点的值(<%d个字符):\n",G.vexnum,MAX_NAME);

for(i=0;i

{

scanf("%s",G.vertices[i].data);

G.vertices[i].firstarc=NULL;

}

printf("请顺序输入每条弧(边)的弧尾和弧头(以空格作为间隔):\n");

for(k=0;k

{

scanf("%s%s",va,vb);

i=LocateVex(G,va); /* 弧尾 */

j=LocateVex(G,vb); /* 弧头 */

p=(ArcNode*)malloc(sizeof(ArcNode));

p->adjvex=j;

p->info=NULL;

if(G.vertices[i].firstarc==NULL)

{

p->nextarc=G.vertices[i].firstarc; /* 插在表头 */

G.vertices[i].firstarc=p;

}

else

{

p->nextarc=G.vertices[i].firstarc->nextarc;

G.vertices[i].firstarc->nextarc=p;

}

if(k

printf("请输入下一条弧的弧尾和弧头(以空格作为间隔):\n");

}

return OK;

}

VertexType* GetVex(ALGraph G,int v)

{ /* 初始条件: 图G存在,v是G中某个顶点的序号。操作结果: 返回v的值 */ if(v>=G.vexnum||v<0)

exit(ERROR);

return &G.vertices[v].data;

}

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->adjvex;

else

return -1;

}

int NextAdjVex(ALGraph G,VertexType v,VertexType w)

{ /* 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点 */

/* 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号。 */

/* 若w是v的最后一个邻接点,则返回-1 */

ArcNode *p;

int v1,w1;

v1=LocateVex(G,v); /* v1为顶点v在图G中的序号 */

w1=LocateVex(G,w); /* w1为顶点w在图G中的序号 */

p=G.vertices[v1].firstarc;

while(p&&p->adjvex!=w1) /* 指针p不空且所指表结点不是w */

p=p->nextarc;

if(!p||!p->nextarc) /* 没找到w或w是最后一个邻接点 */

return -1;

else /* p->adjvex==w */

return p->nextarc->adjvex; /* 返回v的(相对于w的)下一个邻接顶点的序号 */ }

void VisitFunc(VertexType v)

{

printf("%s ",v);

}

void DFS(ALGraph G,int v)

{ /* 从第v个顶点出发递归地深度优先遍历图G */

int w;

VertexType v1,w1;

strcpy(v1,*GetVex(G,v));

visited[v]=TRUE; /* 设置访问标志为TRUE(已访问) */

VisitFunc(G.vertices[v].data); /* 访问第v个顶点 */

for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w)))) if(!visited[w])

DFS(G,w); /* 对v的尚未访问的邻接点w递归调用DFS */

}

void DFSTraverse(ALGraph G)

{ /* 对图G作深度优先遍历。算法7.4 */

printf("深度优先遍历图：\n");

int v;

for(v=0;v

visited[v]=FALSE; /* 访问标志数组初始化 */

for(v=0;v

if(!visited[v])

DFS(G,v); /* 对尚未访问的顶点调用DFS */

printf("\n");

}

Status InsertArc(ALGraph &G,VertexType v,VertexType w)

{ /* 初始条件: 图G存在,v和w是G中两个顶点 */

/* 操作结果: 在G中增添弧,若G是无向的,则还增添对称弧 */ ArcNode *p;

int i,j;

i=LocateVex(G,v); /* 弧尾或边的序号 */

j=LocateVex(G,w); /* 弧头或边的序号 */

if(i<0||j<0)

return ERROR;

G.arcnum++; /* 图G的弧或边的数目加1 */

p=(ArcNode*)malloc(sizeof(ArcNode));

p->adjvex=j;

p->info=NULL;

if(G.vertices[i].firstarc==NULL)

{

p->nextarc=G.vertices[i].firstarc; /* 插在表头 */

G.vertices[i].firstarc=p;

}

else

{

p->nextarc=G.vertices[i].firstarc->nextarc;

G.vertices[i].firstarc->nextarc=p;

}

return OK;

}

Status DeleteArc(ALGraph &G,VertexType v,VertexType w)

{ /* 初始条件: 图G存在,v和w是G中两个顶点 */

/* 操作结果: 在G中删除弧,若G是无向的,则还删除对称弧 */ ArcNode *p,*q;

int i,j;

i=LocateVex(G,v); /* i是顶点v(弧尾)的序号 */

j=LocateVex(G,w); /* j是顶点w(弧头)的序号 */

if(i<0||j<0||i==j)

return ERROR;

p=G.vertices[i].firstarc; /* p指向顶点v的第一条出弧 */

while(p&&p->adjvex!=j) /* p不空且所指之弧不是待删除弧 */

{ /* p指向下一条弧 */

q=p;

p=p->nextarc;

}

if(p&&p->adjvex==j) /* 找到弧 */

{

if(p==G.vertices[i].firstarc) /* p所指是第1条弧 */

G.vertices[i].firstarc=p->nextarc; /* 指向下一条弧 */

else

q->nextarc=p->nextarc; /* 指向下一条弧 */

free(p); /* 释放此结点 */

G.arcnum--; /* 弧或边数减1 */

}

return OK;

}

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;

ArcNode *p,*q;

j=LocateVex(G,v); /* j是顶点v的序号 */

if(j<0) /* v不是图G的顶点 */

return ERROR;

p=G.vertices[j].firstarc; /* 删除以v为出度的弧或边 */

while(p)

{

q=p;

p=p->nextarc;

free(q);

G.arcnum--; /* 弧或边数减1 */

}

G.vexnum--; /* 顶点数减1 */

for(i=j;i

G.vertices[i]=G.vertices[i+1];

for(i=0;i

{

p=G.vertices[i].firstarc; /* 指向第1条弧或边 */

while(p) /* 有弧 */

{

if(p->adjvex==j)

{

if(p==G.vertices[i].firstarc) /* 待删结点是第1个结点 */

{

G.vertices[i].firstarc=p->nextarc;

free(p);

p=G.vertices[i].firstarc;

G.arcnum--; /* 弧或边数减1 */

}

else

{

q->nextarc=p->nextarc;

free(p);

p=q->nextarc;

G.arcnum--; /* 弧或边数减1 */

}

}

else

{

if(p->adjvex>j)

p->adjvex--; /* 修改表结点的顶点位置值(序号) */

q=p;

p=p->nextarc;

}

}

}

return OK;

}

Status CountDegree(ALGraph &G)

{ /*计算各顶点的入度和出度*/

int i,j,in[20],out[20];

ArcNode *p;

for(i=0;i

in[i]=out[i]=0;

i=0;

while(i

{

if(G.vertices[i].firstarc!=NULL)

{

out[i]++;

j=G.vertices[i].firstarc->adjvex;

in[j]++;

p=G.vertices[i].firstarc->nextarc;

while(p!=NULL)

{

out[i]++;

j=p->adjvex;

p=p->nextarc;

in[j]++;

}

}

i++;

}

printf("各个结点的入度为：\n");

for(i=0;i

printf("%d ",in[i]);

printf("\n");

printf("各个结点的出度为：\n");

for(i=0;i

printf("%d ",out[i]);

return OK;

}

void main()

{

VertexType v,w;

ALGraph G;

CreateGraph(G);

DFSTraverse(G);

printf("请输入要插入的弧所要连接的两个结点：\n");

scanf("%s%s",&v,&w);

InsertArc(G,v,w);

DFSTraverse(G);

printf("请输入要删除的弧所要连接的两个结点：\n");

scanf("%s%s",&v,&w);

DeleteArc(G,v,w);

DFSTraverse(G);

printf("请输入要插入的结点：");

scanf("%s",&v);

InsertVex(G,v);

printf("请输入该结点要连接的结点：");

scanf("%s",&w);

InsertArc(G,w,v);

DFSTraverse(G);

printf("请输入要删除的结点：");

scanf("%s",&v);

DeleteVex(G,v);

DFSTraverse(G);

CountDegree(G);

printf("\n");

}