数据结构 实验五1） 采用邻接矩阵/邻接表建立图（无向图，有向图，无向网络，有向网络）； 2） 采用深度优先/广度优先搜索方式遍历图；

最新推荐文章于 2023-05-22 20:16:49 发布
最新推荐文章于 2023-05-22 20:16:49 发布
阅读量1.9w 收藏 162
点赞数 22
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hide_on_rush/article/details/91350755
版权

实验目的：

      1. 掌握图的邻接矩阵和邻接表的存储结构；

      2. 验证图在不同存储结构下遍历操作的实现。

      3. 掌握图的实际应用

实验内容：

采用邻接矩阵/邻接表建立图（无向图，有向图，无向网络，有向网络）；   

采用深度优先/广度优先搜索方式遍历图；

 

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <LIMITS.H>

using namespace std;

#define Status int
#define VRType int
#define InfoType char
#define VertexType char

#define ERROR 0
#define OK 1
#define TRUE 1
#define FALSE 0

#define INFINITY 0 //最大值
#define MAX_VERTEX_NUM 20 //最大顶点个数


bool visited[MAX_VERTEX_NUM];//访问标志数组

typedef struct ArcCell//邻接矩阵(元素)类型
{
    VRType adj; //顶点关系(边或弧),图用1\0表示是否相邻,网为权值
    InfoType *info; //边或弧的相关信息指针
} ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct//图的邻接矩阵类型
{
    VertexType vexs[MAX_VERTEX_NUM]; //顶点向量
    AdjMatrix arcs; //邻接矩阵
    int vexnum,arcnum; //图的顶点数和边或弧数
} Mgraph;

void (*VisitFunc)(Mgraph G,int v);//函数变量

void Input(InfoType *info)//录入弧
{
    info=(char*)malloc(sizeof(char));
    scanf("%c",&*info);
}

Status LocateVex(Mgraph &G,VertexType u)//若G中存在点u,则返回该点在图中的位置
{
    int Loc;
    for(Loc=0; Loc<G.vexnum; Loc++)
    {
        if(G.vexs[Loc]==u)
        {
            return Loc;
        }
    }
    return -1;
}

Status CreateDG(Mgraph &G)//采用邻接矩阵表示法，构造有向图G
{
    int IncInfo,i,j,k;
    char v1,v2;
    printf("请输入图的顶点数(1~20):\n");
    scanf("%d",&G.vexnum);
    getchar();
    printf("请输入图的弧数:\n");
    scanf("%d",&G.arcnum);
    getchar();
    printf("各弧是否含有其他信息（1(有)，0(没有)）：\n");
    scanf("%d",&IncInfo);
    getchar();
    for(i=0; i<G.vexnum; i++)
    {
        printf("请输入第%d个顶点:\n",i+1);
        scanf("%c",&G.vexs[i]);
        getchar();
    }
    for(i=0; i<G.vexnum; i++)
    {
        for(j=0; j<G.vexnum; j++)
        {
            G.arcs[i][j].adj=INFINITY;
            G.arcs[i][j].info=NULL;
        }
    }
    for(k=0; k<G.arcnum; k++)
    {
        printf("请输入一条弧连接的顶点:\n");
        printf("弧尾顶点：\n");//输入一条弧依附的顶点
        scanf("%c",&v1);
        getchar();
        printf("弧头顶点：\n");
        scanf("%c",&v2);
        getchar();
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);//确定v1和v2在G中的位置
        G.arcs[i][j].adj=1;//v1和v2的连接关系
        if(IncInfo)
        {
            Input(G.arcs[i][j].info);//若弧含有相关信息，则输入
        }
    }
    return OK;
}//CreateDG

Status CreateDN(Mgraph &G)//采用邻接矩阵表示法，构造有向网G
{
    int IncInfo,i,j,k,w;
    char v1,v2;
    printf("请输入图的顶点数(1~20):\n");
    scanf("%d",&G.vexnum);
    getchar();
    printf("请输入图的弧数:\n");
    scanf("%d",&G.arcnum);
    getchar();
    printf("各弧是否含有其他信息（1(有)，0(没有)）\n");
    scanf("%d",&IncInfo);
    getchar();
    for(i=0; i<G.vexnum; ++i) //构造顶点向量
    {
        printf("请输入第%d个顶点：",i+1);
        scanf("%c",&G.vexs[i]);
        getchar();
    }
    for(i=0; i<G.vexnum; ++i) //初始化邻接矩阵
    {
        for(j=0; j<G.vexnum; ++j)
        {
            G.arcs[i][j].adj=INFINITY;
            G.arcs[i][j].info=NULL;
        }
    }
    for(k=0; k<G.arcnum; ++k) //构造邻接矩阵
    {
        printf("请输入一条弧连接的顶点及权值\n");
        printf("弧尾顶点：\n");//输入一条弧连接的顶点及权值
        scanf("%c",&v1);
        getchar();
        printf("弧头顶点：\n");
        scanf("%c",&v2);
        getchar();
        printf("权值：\n");
        scanf("%d",&w);
        getchar();
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);//确定v1和v2在G中的位置
        G.arcs[i][j].adj=w;//弧<v1,v2>的权值
        if(IncInfo)
        {
            Input(G.arcs[i][j].info);//若弧含有相关信息，则输入
        }
    }
    return OK;
}//CreateDN

Status CreateUDG(Mgraph &G)//采用邻接矩阵表示法，构造无向图G
{
    int IncInfo,i,j,k;
    char v1,v2;
    printf("请输入图的顶点数(1~20):\n");
    scanf("%d",&G.vexnum);
    getchar();
    printf("请输入图的弧数:\n");
    scanf("%d",&G.arcnum);
    getchar();
    printf("各弧是否含有其他信息（1(有)，0(没有)）\n");
    scanf("%d",&IncInfo);
    getchar();
    for(i=0; i<G.vexnum; ++i) //构造顶点向量
    {
        printf("请输入第%d个顶点：",i+1);
        scanf("%c",&G.vexs[i]);
        getchar();
    }
    for(i=0; i<G.vexnum; ++i) //初始化邻接矩阵
    {
        for(j=0; j<G.vexnum; ++j)
        {
            G.arcs[i][j].adj=INFINITY;
            G.arcs[i][j].info=NULL;
        }
    }
    for(k=0; k<G.arcnum; ++k) //构造邻接矩阵
    {
        printf("请输入一条弧连接的顶点\n");
        printf("弧尾顶点：\n");//输入一条弧依附的顶点
        scanf("%c",&v1);
        getchar();
        printf("弧头顶点：\n");
        scanf("%c",&v2);
        getchar();
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);//确定v1和v2在G中的位置
        G.arcs[i][j].adj=1;//v1和v2的连接关系
        if(IncInfo)
        {
            Input(G.arcs[i][j].info);//若弧含有相关信息，则输入
        }
        G.arcs[j][i]=G.arcs[i][j];//置<v1,v2>的对称弧<v2,v1>
    }
    return OK;
}//CreateUDG

Status CreateUDN(Mgraph &G)//采用邻接矩阵表示法，构造无向网G
{
    int IncInfo,i,j,k,w;
    char v1,v2;
    printf("请输入图的顶点数(1~20):\n");
    scanf("%d",&G.vexnum);
    getchar();
    printf("请输入图的弧数:\n");
    scanf("%d",&G.arcnum);
    getchar();
    printf("各弧是否含有其他信息（1(有)，0(没有)）:\n");
    scanf("%d",&IncInfo);
    getchar();
    for(i=0; i<G.vexnum; ++i)
    {
        printf("请输入第%d个顶点：",i+1);
        scanf("%c",&G.vexs[i]);
        getchar();
    }//构造顶点向量
    for(i=0; i<G.vexnum; ++i)
    {
        for(j=0; j<G.vexnum; ++j)
        {
            G.arcs[i][j].adj=INFINITY;
            G.arcs[i][j].info=NULL;
        }
    }//初始化邻接矩阵
    for(k=0; k<G.arcnum; ++k) //构造邻接矩阵
    {
        printf("请输入一条弧连接的顶点及权值\n");
        printf("弧尾顶点：\n");//输入一条弧连接的顶点及权值
        scanf("%c",&v1);
        getchar();
        printf("弧头顶点：\n");
        scanf("%c",&v2);
        getchar();
        printf("权值：\n");
        scanf("%d",&w);
        getchar();
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);//确定v1和v2在G中的位置
        G.arcs[i][j].adj=w;//弧<v1,v2>的权值
        if(IncInfo)
        {
            Input(G.arcs[i][j].info);//若弧含有相关信息，则输入
        }
        G.arcs[j][i]=G.arcs[i][j];//置<v1,v2>的对称弧<v2,v1>
    }
    return OK;
}//CreateUDN


Status FirstAdjVex(Mgraph G,int v)//返回v的第一个邻接顶点
{
    int i;
    if(v>=0&&v<G.vexnum)
    {
        for(i=0; i<G.vexnum; i++)
        {
            if(G.arcs[v][i].adj)
            {
                return i;
            }
        }
    }
    return -1;
}//FirstAdjVex

Status NextAdjVex(Mgraph G,int v,int w)//返回v的（相对于w的）下一个邻接顶点
{
    int i;
    if(v>=0 && v<G.vexnum)
    {
        if(w>=0 && w<G.vexnum)
        {
            for(i=w+1; i<G.vexnum; i++)
            {
                if(G.arcs[v][i].adj)
                {
                    return i;
                }
            }
        }
    }
    return -1;
}//NextAdjVex

void Print_JZ(Mgraph G)//打印矩阵
{
    int i,j;
    for(i=0; i<G.vexnum; i++)
    {
        for(j=0; j<G.vexnum; j++)
        {
            printf("%d ",G.arcs[i][j].adj);
        }
        printf("\n");
    }
}

void Print(Mgraph G,int v)
{
    printf("%c",G.vexs[v]);
}

void DFS(Mgraph G,int v)
{
    //从第v个顶点出发递归地深度优先遍历图G
    int w;
    visited[v]=TRUE;
    VisitFunc(G,v);//访问第v个顶点
    for(w=FirstAdjVex(G,v); w>0; w=NextAdjVex(G,v,w))
    {
        if(!visited[w])
        {
            DFS(G,w);//对v的尚未访问的邻接顶点w递归调用DFS
        }
    }
}//DFS

void DFSTraverse(Mgraph G,void (*Print)(Mgraph G,int v))
{
    //对图G做深度优先遍历
    int v;
    VisitFunc=Print;//使用全局变量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
        }
    }
}//DFSTraverse

int main()
{
    char Ch;
    Mgraph G;
    while(1)
    {
        system("cls");
        printf("请选择操作：\n");
        printf("1.构造有向图\n2.构造有向网\n3.构造无向图\n4.构造无向网\n5.退出\n");
        scanf("%c",&Ch);
        getchar();
        switch(Ch)
        {
        case '1':
            CreateDG(G);//构造有向图G
            printf("有向图G的邻接矩阵为：\n");
            Print_JZ(G);
            printf("有向图G的深度优先遍历：\n");
            DFSTraverse(G,Print);
            getchar();
            system("pause");
            break;
        case '2':
            CreateDN(G);//构造有向网G
            printf("有向网G的邻接矩阵为：\n");
            Print_JZ(G);
            printf("有向网G的深度优先遍历：\n");
            DFSTraverse(G,Print);
            getchar();
            system("pause");
            break;
        case '3':
            CreateUDG(G);//构造无向图G
            printf("无向图G的邻接矩阵为：\n");
            Print_JZ(G);
            printf("无向图G的深度优先遍历：\n");
            DFSTraverse(G,Print);
            getchar();
            system("pause");
            break;
        case '4':
            CreateUDN(G);//构造无向网G
            printf("无向网G的邻接矩阵为：\n");
            Print_JZ(G);
            printf("无向网G的深度优先遍历：\n");
            DFSTraverse(G,Print);
            getchar();
            system("pause");
            break;
        case '5':
            exit(0);
            break;
        default:
            printf("选择错误！\n");
            system("pause");
        }
        return 0;
    }
}

运行效果如图：

使用了邻接矩阵和深度优先算法

xiuzhublog
关注
  • 22
    点赞
  • 踩
  • 162
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
database-Graph.rar_4 3 2 1_无向图环_有向邻接表_邻接表做图
09-23
（1）键盘输入数据，建立一个有向图的邻接表，并输出该邻接表。 （2）在有向图的邻接表的基础上计算各顶点的度，并输出。 （3）以有向图的邻接表为基础实现并输出它的拓扑排序序列。 （4）在主函数中设计一个...
图的操作（c++实现）
路漫漫小菜狗的博客
12-05 1892
（1）采用邻接矩阵/邻接表建立图； （2）采用深度优先/广度优先搜索方式遍历图； （3）编程实现Dijkstra最短路径算法。 #include <iostream> using namespace std; #define MaxInt 32767 #define MVNum 100 typedef struct{ char vexs[MVNum]; int arcs[MVNum][MVNum]; int vexnum,arcnum; }AMGraph; typedef
图的操作及应用（以邻接矩阵或邻接表方式建立无向图，并分别利用深度优先遍历和广度优先遍历方法输出各结点元素。）
weixin_52416700的博客
12-19 2147
主要运用： 1．图的邻接矩阵和邻接表存储结构； 2．图的深度优先遍历和广度优先遍历算法，复习栈和队列的应用； 3．图的最小生成树、最短路径等应用及算法思想。 实现功能：以邻接矩阵或邻接表方式建立无向图，并分别利用深度优先遍历和广度优先遍历方法输出各结点元素。 #include <iostream> typedef int ElemType; #define MaxSize 100 #define MAXVEX 100 #define INF 32767 typedef .
图：邻接表法创建无向图并深度优先搜索遍历
双鱼座boyy的博客
05-17 3368
无向图： 代码： #include<iostream> using namespace std; #define pointMax 100 struct VtNode //权值信息 { int peace; VtNode *nextVt; int data; }; struct PoNode //顶点信息 { char data; VtNode *firstPo; }; struct A...
图的基本操作及应用（邻接表&&邻接矩阵）
qq_43590078的博客
07-05 2357
算法设计与分析 图的基本操作及应用（邻接表&&邻接矩阵） 图的基本操作及应用 1．实验目的 （1）掌握图的基本存储方法； （2）掌握有关图的操作算法并用高级语言实现； （3）熟练掌握图的两种搜索路径的遍历方法。 2．实验内容 （1）图的基本操作 分别用邻接矩阵和邻接表两种方法表示一个无向图，并实现以下操作（完成实验报告）： a. 增加一个结点 b. 删除一个结点 c. 增加一条边 d. 删除一条边 （2）图的应用（选做，参考迪杰斯特拉算法和弗洛伊德算法） 假设以一个带权有向图表示某一区域的
数据结构——图篇（邻接矩阵、邻接表、深度优先搜索、广度优先搜索）
m0_66881249的博客
12-07 2703
数据结构关于图的基本知识以及相关代码
创建无向图并进行深度优先和广度优先遍历
m0_68563008的博客
05-22 825
1.创建一个无向图（采用邻接矩阵方式存储）； 2．分别输出从结点0开始的一个深度优先遍历序列和一个广度优先遍历序列。
以邻接表方式建立无向图，分别利用深度优先遍历和广度优先遍历方法输出各结点元素（数据结构）
记录学编程后遇到的问题，注意点以及相关知识
12-14 5504
实验目的 掌握图的邻接矩阵和邻接表存储结构； 掌握图的深度优先遍历和广度优先遍历算法，复习栈和队列的应用； 掌握图的最小生成树、拓扑排序等应用及算法思想。 实验内容 以邻接矩阵或邻接表方式建立无向图，并分别利用深度优先遍历和广度优先遍历方法输出各结点元素。 Source Code #include<stdio.h> #include<stdlib.h> typedef int ElemType; #define MaxSize 100 #define MAXV 100 #defi
【数据结构】图的创建和深度（DFS）广度（BFS）优先遍历
m0_72532428的博客
05-15 1338
图的创建和遍历方法
C语言实现基于邻接表的完全无向图生成，图的深度优先搜索与广度优先搜索
rather_than的博客
08-24 1623
采用邻接表作为数据结构，创建了完全无向图，创建了测试用有向图，实现了图的广度与深度优先搜索
图：邻接矩阵表示法创建无向图并深度优先搜索遍历
双鱼座boyy的博客
05-16 5870
无向图表示： 代码： #include<iostream> using namespace std; #define pointMax 100 #define MaxInt 32767 struct AMgroup { char VTchart[pointMax]; //顶点表 int AMchart[pointMax][pointMax]; //邻接矩阵 int point, vert; ...
dsf.rar_有向图邻接表_有向邻接表
09-19
键盘输入数据，建立一个有向图的邻接表。（2）输出该邻接表。（3）在有向图的邻接表的基础上计算各顶点的度，并输出。（4）采用邻接表存储实现无向图的广度优先遍历。（5）采用邻接表存储实现无向图的深度优先非递归...
C++实现有向图的邻接表表示
12-20
本文实例为大家分享了C++有向图的邻接表表示，供大家参考，具体内容如下 一、思路： 有向图的插入有向边、删除边、删除顶点和无向图的有区别。其他的和无向图的类似。 1.插入有向边 只需要插入边就行，不需要插入...
tuDeBianLi.rar_图C_图的 邻接表 遍历_无向图_邻接表_邻接表 广度 遍历
09-24
以邻接表为存储结构，选择图的类型（有向图或无向图），创建相应的图。对创建的图按深度优先和广度优先的遍历。（文档中含代码）
有向图邻接表的建立，深度广度搜索及拓扑排序.zip_45V_bfs_dfs_有向图
07-15
对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑...
图的邻接矩阵存储，深度优先遍历（C语言）
qbyyds的博客
11-28 9309
内容： 采用邻接矩阵存储图，进行图的深度优先搜索并输出结果。 1.算法分析： 整个程序分为两部分，第一部分为邻接矩阵存储图，第二部分为图的优先搜索。将两个部分的算法做一个简单的分析即可。 第一部分，邻接矩阵存储图，因为顶点和顶点之间的关系直接合在一起存储比较困难，所以我们可以使用一维数组来存储顶点信息，用二维数组来存储边的信息。假设图G=(V,E)有n个确定的顶点，即V={V0,V1,…,V(n-1)}，则表示G中各顶点相邻关系为一个n*n的矩阵，矩阵...
数据结构/数据结构与算法实验三 图的相关算法实现
zombotany的博客
01-29 1622
1.实验题目 1.【功能1】建立一个无向图。 2.【功能2】按深度优先遍历该无向图，输出遍历序列。 3.【功能3】按广度优先遍历该无向图，输出遍历序列。 2.实验要求 1、无向图以邻接矩阵或邻接表作为存储结构 2、主程序测试数据 3.算法思路 1.类的设计 这次实验可以设计出一个邻接表作为图的存储结构。因为题目要求图的边没有权值，所以，我们可以对课本上的邻接表作一些适当简化。在设计图的边类adjlistnetworkarc类时，可以去掉边权域，仅保留顶点域和指针域。在设计图类adjlistdirnetwo
数据结构-图的邻接矩阵和邻接表的存储实现
m0_54570435的博客
04-27 2285
/输入存在边的两顶点。9.主函数：定义有向图G的邻接矩阵，顶点数为6，边数为10，分别输出G的邻接矩阵和邻接表，销毁邻接表。printf("第%d对：",i+1);printf("图G的邻接矩阵：\n");建立如图1所示的有向图G的邻接矩阵，并输出；实验内容：1．掌握图的邻接矩阵的存储定义；建立如图1所示的有向图G的邻接表，并输出；2．掌握图的邻接表的实现。5.有向图起始点、终点及权值的输入。
以邻接表邻接矩阵创建图，深度优先遍历与广度优先遍历
m0_54806993的博客
05-30 1380
参考其他博客，修改了一点点细节，没有过多简介，深度优先遍历和广度优先遍历过程可参考他人，附代码 #include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<string.h> //邻接矩阵：基于数组->用一个一维数组存储顶点，用一个二位数组存储边 //邻接表：基于链表->用一个一维数组或者一个链表来存储所有顶点 #define max 100 #define coun
采用邻接矩阵或邻接表存储结构来建立有向图或无向图，实现深度优先或广度优先的遍历算法。
最新发布
09-23
邻接矩阵和邻接表都是用来存储有向图或无向图的结构。邻接矩阵是一个二维数组，其中每个元素表示两个顶点之间是否有边相连。邻接表则是一个链表数组，其中每个链表表示一个顶点的邻居节点。通过这两种存储结构，可以实现深度优先或广度优先的遍历算法。深度优先遍历算法是从起始节点开始，尽可能深地访问每个节点，直到无法继续为止，然后回溯到上一个节点，继续访问其他节点。广度优先遍历算法则是从起始节点开始，依次访问每个节点的邻居节点，直到所有节点都被访问为止。这两种遍历算法可以用递归或非递归的方式实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值