#include<cstdio>
#include<cstdlib>
#include<string>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INF 327676//最大值，即正无穷大
#define MaxSize 100//最大顶点数
#define queuesize 100
using namespace std;
typedef char Elemtype;//假设顶点数据类型为字符型
typedef int ArcType; //假设边的权值为整型
typedef struct edgenode
{
int adjvex;//存放邻接的点在顶点表的下标，邻接点
struct edgenode *next;//指向Vi下一个邻接点的边结点
int weight;//权值
}edgenode;//边结点的类型定义
typedef struct vexnode
{
Elemtype data; //存储顶点的名称或其相关信息
edgenode *firstedge;//边表头指针
}vexnode; //顶点结点类型定义
typedef struct
{
vexnode vexlist[MaxSize];//顶点表
int n,e;//顶点数和边数
}ALGraph;//图的邻接表数据类型
typedef struct
{
Elemtype vex[MaxSize];//顶点表
int arc[MaxSize][MaxSize];//邻接矩阵
int n,e;
}MGraph;//图的邻接矩阵数据类型
//循环队列存储结构定义
typedef struct cirqueue
{
Elemtype *data; //队列存储空间的首地址
int front; //队头位置：指向当前队头元素
int rear; //队尾位置：指向当前队尾元素的下一位置
}cirqueue; // 循环队列
//构造空队，如果成功，返回1，如果失败，返回0
int initqueue(cirqueue *q)
{
q->data=(Elemtype *)malloc(queuesize*sizeof(cirqueue));
if(q->data==NULL)
return 0; // 存储分配失败
q->front=q->rear=0;
return 1;
}
// 插入元素e为Q的新的队尾元素 ,如果成功，返回1，如果失败，返回0
int enqueue (cirqueue *q,Elemtype e)
{
if ((q->rear+1)%queuesize==q->front)
return 0; //队列满
q->data[q->rear]=e;
q->rear=(q->rear+1)%queuesize; //队尾后移一位
return 1;
}
//若队列不空，则删除Q的队头元素，用e返回其值,并返回1；否则返回0
int dequeue (cirqueue *q,int *e)
{
if (q->front == q->rear)
return 0; //队列为空
*e = q->data[q->front];
q->front =(q->front+1)%queuesize; //队头后移一位
return 1;
}
//若栈不空，则用e返回队头元素,并返回1；否则返回0
int getfront(cirqueue q,Elemtype *e)
{
if (q.front == q.rear)
return 0; //队列为空
*e=q.data[q.front];
return 1;
}
//若队列为空栈，则返回1，否则返回0
int queueempty(cirqueue q)//栈非空
{
if(q.front == q.rear)
return 1; //队列为空
else return 0;
}
//返回队列的元素个数，即队列的长度
int queuelength(cirqueue q)
{
return (q.rear-q.front+queuesize)%queuesize;
}
//邻接表
int locatevex_1(ALGraph g,Elemtype v)//在图中查找顶点v,存在顶点数组中的下标，不存在返回-1
{
int i;
for(i=0;i<g.n;i++)
if(g.vexlist[i].data==v)return i;
return -1;
}//邻接表
void printDG_1(ALGraph g)//打印邻接表有向图和无向图数据类型
{
int i;
edgenode *p;
printf("图的邻接表表示:\n");
for(i=0;i<g.n;i++){
printf("%d%4c",i,g.vexlist[i].data);
p=g.vexlist[i].firstedge;
while(p!=NULL){
printf("-->%d",p->adjvex);
p=p->next;
}
printf("\n");
}
}
void printDN_1(ALGraph g)//打印邻接表有向网和无向网数据类型
{
int i;
edgenode *p;
printf("图的邻接表表示:\n");
for(i=0;i<g.n;i++){
printf("%d",i);
printf("%4c",g.vexlist[i].data);
p=g.vexlist[i].firstedge;
while(p!=NULL){
printf("-->%d(权值:%d)",p->adjvex,p->weight);
p=p->next;
}
printf("\n");
}
}
void CreateDG_1(ALGraph *g)//邻接表存储有向图
{
int i,j,k;
Elemtype v1,v2;
edgenode *s;
printf("请输入图的顶点数及边数:\n");
printf("顶点数:n=");
scanf("%d",&g->n);
printf("边 数:e=");
scanf("%d",&g->e);
printf("请输入图的顶点信息(需要用空格隔开):\n");
getchar();
for(i=0;i<=g->n;i++){
scanf("%c",&g->vexlist[i].data); //构造顶点信息
g->vexlist[i].firstedge=NULL;
}
printf("请输入图的边的信息(需要用空格隔开):\n");
for(k=0;k<g->e;k++)
{
printf("请输入第%d条边的两个端点下标(需要用空格隔开):",k+1);
scanf(" %c %c",&v1,&v2);getchar();//输入一条边的两个顶点
i=locatevex_1(*g,v1);
j=locatevex_1(*g,v2);
if(i>=0&&j>=0){
s=(edgenode *)malloc(sizeof(edgenode));
s->adjvex=j;
s->next=g->vexlist[i].firstedge;
g->vexlist[i].firstedge=s;
}
}
}
void CreateDN_1(ALGraph *g)//邻接表存储带权有向网
{
int i,j,k,w;
Elemtype v1,v2;
edgenode *s;
printf("请输入图的顶点数及边数:\n");
printf("顶点数:n=");scanf("%d",&g->n);
printf("边 数:e=");scanf("%d",&g->e);
printf("请输入图的顶点信息(需要用空格隔开):\n");getchar();
for(i=0;i<=g->n;i++){
scanf("%c",&g->vexlist[i].data); //构造顶点信息
g->vexlist[i].firstedge=NULL;
}
printf("请输入图的边的信息:\n");
for(k=0;k<g->e;k++)
{
printf("请输入第%d条边的两个端点下标和权值(需要用空格隔开):",k+1);
scanf(" %c %c %d",&v1,&v2,&w);getchar();//输入一条边的两个顶点及权值
i=locatevex_1(*g,v1);
j=locatevex_1(*g,v2);
if(i>=0&&j>=0){
s=(edgenode *)malloc(sizeof(edgenode));
s->adjvex=j;
s->weight=w;
s->next=g->vexlist[i].firstedge;
g->vexlist[i].firstedge=s;
}
}
}
void CreateUDG_1(ALGraph *g)//邻接表存储无向图
{
int i,j,k;
Elemtype v1,v2;
edgenode *s;
printf("请输入图的顶点数及边数:\n");
printf("顶点数:n=");scanf("%d",&g->n);
printf("边 数:e=");scanf("%d",&g->e);
printf("请输入图的顶点信息(需要用空格隔开):\n");
getchar();
for(i=0;i<=g->n;i++){
scanf("%c",&g->vexlist[i].data); //构造顶点信息
g->vexlist[i].firstedge=NULL;
}
printf("请输入图的边的信息(需要用空格隔开):\n");
for(k=0;k<g->e;k++)
{
printf("请输入第%d条边的两个端点下标(需要用空格隔开):",k+1);
scanf(" %c %c",&v1,&v2);//输入一条边的两个顶点
getchar();
i=locatevex_1(*g,v1);
j=locatevex_1(*g,v2);
if(i>=0&&j>=0){
s=(edgenode *)malloc(sizeof(edgenode));
s->adjvex=j;
s->next=g->vexlist[i].firstedge;
g->vexlist[i].firstedge=s;
s=(edgenode *)malloc(sizeof(edgenode));
s->adjvex=i;
s->next=g->vexlist[j].firstedge;
g->vexlist[j].firstedge=s;
}
}
}
void CreateUDN_1(ALGraph *g)//邻接表存储带权无向网
{
int i,j,k,w;
Elemtype v1,v2;
edgenode *s;
printf("请输入图的顶点数及边数:\n");
printf("顶点数:n=");scanf("%d",&g->n);
printf("边 数:e=");scanf("%d",&g->e);
printf("请输入图的顶点信息:\n");
getchar();
for(i=0;i<=g->n;i++){
scanf("%c",&g->vexlist[i].data); //构造顶点信息
g->vexlist[i].firstedge=NULL;
}
printf("请输入图的边的信息(需要用空格隔开):\n");
for(k=0;k<g->e;k++)
{
printf("请输入第%d条边的两个端点下标和权值(需要用空格隔开):",k+1);
scanf(" %c %c %d",&v1,&v2,&w);//输入一条边的两个顶点和权值
getchar();
i=locatevex_1(*g,v1);
j=locatevex_1(*g,v2);
if(i>=0&&j>=0){
s=(edgenode *)malloc(sizeof(edgenode));
s->adjvex=j;
s->weight=w;
s->next=g->vexlist[i].firstedge;
g->vexlist[i].firstedge=s;
s=(edgenode *)malloc(sizeof(edgenode));
s->adjvex=i;
s->weight=w;
s->next=g->vexlist[j].firstedge;
g->vexlist[j].firstedge=s;
}
}
}
int visited[MaxSize];//访问标志数组
void DFS_1(ALGraph g,int i)//从第i个顶点出发递归地深度优先遍历图
{
edgenode *p;
printf("%3c",g.vexlist[i].data);//访问第i个项点
visited[i]=1;
p=g.vexlist[i].firstedge;
while(p!=NULL)
{
if(visited[p->adjvex]==0)
DFS_1(g,p->adjvex);//对i的尚未访问的邻接顶点j递归调用DFS
p=p->next;
}
}
void DFStraverse_1(ALGraph g) //对图G进行深度优先遍历
{
int v;
for (v=0; v<g.n;v++)visited[v]=0; //初始化标志数组
for (v=0; v<g.n;v++) //保证非连通图的遍历
//从第v个顶点出发递归地深度优先遍历图G
if (!visited[v])DFS_1(g,v);
}
int BFSvisited[MaxSize];//利用邻接矩阵实现连通图的广度优先搜索遍历
//从第k个顶点出发广度优先遍历图G,G以邻接矩阵表示。
void BFS_1(ALGraph g,int k){
int i;
cirqueue q;
edgenode *p;
initqueue(&q);//初始化队列
printf("%3c",g.vexlist[k].data);//访问第k个项点
visited[k]=1;
enqueue(&q,k);//第k个顶点进队
while(queueempty(q)==0) {//队列非空
dequeue(&q,&i);
p=g.vexlist[i].firstedge;//获取第1个邻接点
while(p!=NULL){
if(visited[p->adjvex]==0){
//访问第i个顶点的末曾访问的顶点
printf("%3c",g.vexlist[p->adjvex].data);
visited[p->adjvex]=1;
enqueue(&q,p->adjvex);//第k个顶点进队
}
p=p->next;
}
}
}
void BFStraverse_1(ALGraph g) //对图进行广度优先遍历
{
int v;
for (v=0; v<g.n;v++) //初始化标志数组
visited[v]=0;
for (v=0; v<g.n;v++) //保证非连通图的遍历
if (!visited[v])BFS_1(g,v);
//从第v个顶点出发递归地深度优先遍历图
}
//邻接矩阵
int locatevex_2(MGraph g,Elemtype v)//在图中查找顶点v,存在顶点数组中的下标，不存在返回-1
{
int i;
for(i=0;i<g.n;i++)
if(g.vex[i]==v)return i;
return -1;
}//邻接矩阵
void printDG_2(MGraph g)//打印邻接矩阵有向图和无向图数据类型
{
int i,j;
printf("图的邻接矩阵表示:\n");
for(i=0;i<g.n;i++){
for(j=0;j<g.n;j++){
printf("%3d",g.arc[i][j]);
}
printf("\n");
}
}
void printDN_2(MGraph g)//打印邻接矩阵有向网和无向网数据类型
{
int i,j;
printf("图的邻接矩阵表示:\n");
for(i=0;i<g.n;i++)
{
for(j=0;j<g.n;j++)
{
if(g.arc[i][j]!=INF)
{
printf("%3d",g.arc[i][j]);
}
else if(g.arc[i][j]==INF)
{
printf("∞");
}
}
printf("\n");
}
}
void CreateUDG_2(MGraph *g)//邻接矩阵存储无向图
{
int i,j,k;
Elemtype v1,v2;
printf("请输入顶点数和边数:\n");
printf("顶点数:n=");scanf("%d",&g->n);
printf("边 数:e=");scanf("%d",&g->e);
printf("请输入图的顶点信息(需要用空格隔开):\n");
getchar();
for(i=0;i<=g->n;i++)
scanf(" %c",&g->vex[i]);
for(i=0;i<g->n;i++)
for(j=0;j<g->n;j++)
g->arc[i][j]=0;//初始化邻接矩阵
printf("请输入图的边的信息:\n");
for(k=0;k<g->e;k++)
{
printf("请输入第%d条边的两个端点(需要用空格隔开):",k+1);
scanf(" %c %c",&v1,&v2);
fflush(stdin);//清空输入缓冲区
i=locatevex_2(*g,v1);
j=locatevex_2(*g,v2);
if(i>=0&&j>=0){
g->arc[i][j]=1;
g->arc[j][i]=1;//无向图矩阵对称
}
}
}
void CreateDG_2(MGraph *g)//邻接矩阵存储有向图
{
int i,j,k;
Elemtype v1,v2;
printf("请输入顶点数和边数:\n");
printf("顶点数:n=");scanf("%d",&g->n);
printf("边 数:e=");scanf("%d",&g->e);
printf("请输入图的顶点信息:\n");
getchar();
for(i=0;i<=g->n;i++)
scanf("%c",&g->vex[i]);
fflush(stdin);//清空输入缓冲区
for(i=0;i<g->n;i++)
for(j=0;j<g->n;j++)
g->arc[i][j]=0;//初始化邻接矩阵
printf("请输入图的边的信息(需要用空格隔开):\n");
for(k=0;k<g->e;k++)
{
printf("请输入第%d条边的两个端点(需要用空格隔开):",k+1);
scanf(" %c %c",&v1,&v2);
fflush(stdin);//清空输入缓冲区
i=locatevex_2(*g,v1);
j=locatevex_2(*g,v2);
if(i>=0&&j>=0){
g->arc[i][j]=1;
}
}
}
void CreateDN_2(MGraph *g)//邻接矩阵存储有权有向网
{
int i,j,k,w;
Elemtype v1,v2;
printf("请输入顶点数和边数:\n");
printf("顶点数:n=");scanf("%d",&g->n);
printf("边 数:e=");scanf("%d",&g->e);
printf("请输入图的顶点信息:\n");
getchar();
for(i=0;i<=g->n;i++)
scanf("%c",&g->vex[i]);
for(i=0;i<g->n;i++)
for(j=0;j<g->n;j++)
g->arc[i][j]=INF;//初始化邻接矩阵
printf("请输入图的边的信息(需要用空格隔开):\n");
for(k=0;k<g->e;k++)
{
printf("请输入第%d条边的两个端点和权值(需要用空格隔开):",k+1);
scanf(" %c %c %d",&v1,&v2,&w);
fflush(stdin);//清空输入缓冲区
i=locatevex_2(*g,v1);
j=locatevex_2(*g,v2);
if(i>=0&&j>=0)
{
g->arc[i][j]=w;
}
}
}
void CreateUDN_2(MGraph *g)//邻接矩阵存储有权无向网
{
int i,j,k,w;
Elemtype v1,v2;
printf("请输入顶点数和边数:\n");
printf("顶点数:n=");scanf("%d",&g->n);
printf("边 数:e=");scanf("%d",&g->e);
printf("请输入图的顶点信息:\n");
getchar();
for(i=0;i<=g->n;i++)
scanf("%c",&g->vex[i]);
for(i=0;i<g->n;i++)
for(j=0;j<g->n;j++)
g->arc[i][j]=INF;//初始化邻接矩阵
printf("请输入图的边的信息:\n");
for(k=0;k<g->e;k++)
{
printf("请输入第%d条边的两个端点和权值(需要用空格隔开):",k+1);
scanf(" %c %c %d",&v1,&v2,&w);//输入边及边上的权值
fflush(stdin);//清空输入缓冲区
i=locatevex_2(*g,v1);
j=locatevex_2(*g,v2);
if(i>=0&&j>=0){
g->arc[i][j]=w;
g->arc[j][i]=g->arc[i][j];
}
}
}
int DFSvisited[MaxSize];//访问标志数组
void DFS_2(MGraph g,int i)
{
int j;
printf("%3c",g.vex[i]); //访问第i个项点
DFSvisited[i]=1;
for(j=0;j<g.n;j++)
{
if((g.arc[i][j]==1)&&(DFSvisited[j]==0))
DFS_2(g,j);//对i的尚未访问的邻接顶点j递归调用DFS
}
}
//对图进行深度优先遍历
void DFStraverse_2(MGraph g)
{
int v;
for (v=0; v<g.n;v++)
DFSvisited[v]=0; //初始化标志数组
for (v=0; v<g.n;v++) //保证非连通图的遍历,连通图只执行一次
//从第v个顶点出发递归地深度优先遍历图G
if (!DFSvisited[v]) DFS_2(g,v);
}
//从第k个顶点出发广度优先遍历图G,G以邻接矩阵表示。
void BFS_2(MGraph g,int i){
int j;
cirqueue q;
initqueue(&q);//初始化队列
printf("%3c",g.vex[i]);//访问第k个顶点
BFSvisited[i]=1;
enqueue(&q,i);//第k个顶点进队
while(queueempty(q)==0) {//队列非空
dequeue(&q,&i);
for(j=0;j<g.n;j++){
if((g.arc[i][j]==1)&&(BFSvisited[j]==0)){
//访问第i个顶点的末曾访问的顶点j
printf("%3c",g.vex[j]);
BFSvisited[j]=1;
enqueue(&q,j);//第k个顶点进队
}
}
}
}
//对图进行广度优先遍历
void BFStraverse_2(MGraph g) //对图进行广度优先遍历
{
int v;
for (v=0; v<g.n;v++) //初始化标志数组
BFSvisited[v]=0;
for (v=0; v<g.n;v++) //保证非连通图的遍历
if (!BFSvisited[v])BFS_2(g,v);
//从第v个顶点出发递归地广度优先遍历图
}
//有向网,无向网转换
void MatToList(MGraph g,ALGraph *G)//邻接矩阵转换为邻接表
{
int i,j,l;
edgenode *p;
G->n=g.n;
G->e=g.e;
for(l=0;l<g.n;l++)
G->vexlist[l].data=g.vex[l];
for(i=0; i<g.n; i++)
G->vexlist[i].firstedge=NULL;
for(i=0;i<g.n; i++)
{
for(j=g.e-1;j>=0;j--)
{
if(g.arc[i][j]!=0&&g.arc[i][j]!=INF)
{
p=(edgenode*)malloc(sizeof(edgenode));
p->adjvex=j;
p->weight=g.arc[i][j];
p->next=G->vexlist[i].firstedge;
G->vexlist[i].firstedge=p;
}
}
}
}
void ListToMat(ALGraph *T,MGraph &S)//邻接表转换成邻接矩阵
{
int i,l,j;
edgenode *p;
for(l=0;l<S.n;l++)
{
for(j=0;j<S.n;j++)
{
S.arc[l][j]=0;
}
}
for(i=0;i<T->n; i++)
{
p=T->vexlist[i].firstedge;
while(p!=NULL)
{
S.arc[i][p->adjvex]=p->weight;
p=p->next;
}
}
S.n=T->n;
S.e=T->e;
}
//有向图、无向图转换
void MatToList_2(MGraph E,ALGraph *F)//将邻接矩阵转换成邻接表
{
int i,j,l;
edgenode *p;
for(l=0;l<E.n;l++)
F->vexlist[l].data=E.vex[l];
for(i=0;i<E.n;i++)//给邻接表中所有头节点的指针域置初值
F->vexlist[i].firstedge=NULL;
for (i=0; i<E.n; i++) //检查邻接矩阵中每个元素
for (j=E.n-1;j>=0;j--)
if (E.arc[i][j]!=0)//存在一条边
{
p=(edgenode*)malloc(sizeof(edgenode));//创建一个节点*p
p->adjvex=j;
p->next=F->vexlist[i].firstedge;//采用头插法插入*p
F->vexlist[i].firstedge=p;
}
F->n=E.n;
F->e=E.e;
}
void ListToMat_2(ALGraph *L,MGraph &M)//将邻接表转换成邻接矩阵
{
int i;
edgenode *p;
for(i=0;i<L->n;i++)
{
p=L->vexlist[i].firstedge;
while (p!=NULL)
{
M.arc[i][p->adjvex]=1;
p=p->next;
}
}
M.n=L->n;
M.e=L->e;
}
//邻接表的销毁
void Destory_1(ALGraph *lg){
int i;
edgenode *p,*q;
for(i=0;i<lg->n;i++){
p = lg->vexlist[i].firstedge; //指针p指向顶点i的单链表的第一个边结点
if(p!=NULL)
{
q=p->next;
while(q!=NULL)
{
free(p);
p=q;
q=q->next;
}
free(p);
}
}
free(lg);
}
//邻接矩阵的销毁
void Destory_2(MGraph &g)
{
int i,k,j;
for(k=0;k<MaxSize;k++)
g.vex[k]=0;
for(i=0;i<g.n;i++)
for(j=0;j<g.n;j++)
{
g.arc[i][j]=0;
}
g.e=0;
g.n=0;
}
void menu()
{
printf("*********************菜单*********************\n");
printf("**1.邻接表存储有向图 2.邻接矩阵存储有向图**\n");
printf("**3.邻接表存储无向图 4.邻接矩阵存储无向图**\n");
printf("**5.邻接表存储有向网 6.邻接矩阵存储有向网**\n");
printf("**7.邻接表存储无向网 8.邻接矩阵存储无向网**\n");
printf("**********************************************\n");
printf("请选择>:");
}
int main()
{
printf("\n");
printf("\t\t图的存储及相互转换\t\t\t\t\t\t\t\n");
printf(" \n");
int input=0;
ALGraph G;
MGraph H;
do
{
menu();
scanf("%d",&input);//输入选择
switch(input)
{
case 1:
CreateDG_1(&G);
printDG_1(G);
printf("\n");
printf("深度优先遍历输出数据元素：\n");
DFStraverse_1(G);
printf("\n");
printf("广度优先遍历输出数据元素：\n");
BFStraverse_1(G);
printf("\n");
printf("图G的邻接表转换成邻接矩阵：\n");
ListToMat_2(&G,H);
printDG_2(H);
printf("\n");
Destory_1(&G);
Destory_2(H);
break;
case 2:
CreateDG_2(&H);
printDG_2(H);
printf("\n");
printf("深度优先遍历输出数据元素：\n");
DFStraverse_2(H);
printf("\n");
printf("广度优先遍历输出数据元素：\n");
BFStraverse_2(H);
printf("\n");
printf("图G的邻接矩阵转换成邻接表：\n");
MatToList_2(H,&G);
printDG_1(G);
printf("\n");
Destory_1(&G);
Destory_2(H);
break;
case 3:
CreateUDG_1(&G);
printDG_1(G);
printf("\n");
printf("深度优先遍历输出数据元素：\n");
DFStraverse_1(G);
printf("\n");
printf("广度优先遍历输出数据元素：\n");
BFStraverse_1(G);
printf("\n");
printf("图G的邻接表转换成邻接矩阵：\n");
ListToMat_2(&G,H);
printDG_2(H);
printf("\n");
Destory_1(&G);
Destory_2(H);
break;
case 4:
CreateUDG_2(&H);
printDG_2(H);
printf("\n");
printf("深度优先遍历输出数据元素：\n");
DFStraverse_2(H);
printf("\n");
printf("广度优先遍历输出数据元素：\n");
BFStraverse_2(H);
printf("\n");
printf("图G的邻接矩阵转换成邻接表：\n");
MatToList_2(H,&G);
printDG_1(G);
printf("\n");
Destory_1(&G);
Destory_2(H);
break;
case 5:
CreateDN_1(&G);
printDN_1(G);
printf("\n");
printf("深度优先遍历输出数据元素：\n");
DFStraverse_1(G);
printf("\n");
printf("广度优先遍历输出数据元素：\n");
BFStraverse_1(G);
printf("\n");
printf("图G的邻接表转换成邻接矩阵：\n");
ListToMat(&G,H);
printDG_2(H);
printf("\n");
Destory_1(&G);
Destory_2(H);
break;
case 6:
CreateDN_2(&H);
printDN_2(H);
printf("\n");
printf("深度优先遍历输出数据元素：\n");
DFStraverse_2(H);
printf("\n");
printf("广度优先遍历输出数据元素：\n");
BFStraverse_2(H);
printf("\n");
printf("图G的邻接矩阵转换成邻接表：\n");
MatToList(H,&G);
printDN_1(G);
printf("\n");
Destory_1(&G);
Destory_2(H);
break;
case 7:
CreateUDN_1(&G);
printDN_1(G);
printf("\n");
printf("深度优先遍历输出数据元素：\n");
DFStraverse_1(G);
printf("\n");
printf("广度优先遍历序列输出数据元素：\n");
BFStraverse_1(G);
printf("图G的邻接表转换成邻接矩阵：\n");
ListToMat(&G,H);
printDG_2(H);
printf("\n");
Destory_1(&G);
Destory_2(H);
break;
case 8:
CreateUDN_2(&H);
printDG_2(H);
printf("\n");
printf("深度优先遍历输出数据元素：\n");
DFStraverse_2(H);
printf("\n");
printf("广度优先遍历输出数据元素：\n");
BFStraverse_2(H);[]()
printf("\n");
MatToList(H,&G);
printDN_1(G);
printf("\n");
Destory_1(&G);
Destory_2(H);
break;
default:
return ERROR;
}
}while(input);
return 0;
}
800行代码啊，至少得具体一点吧