华中科技大学数据结构与算法分析图的遍历实验代码

已于 2023-05-12 13:50:10 修改
阅读量238 收藏 2
点赞数
文章标签： c++ 算法 广度优先 深度优先 图搜索算法
于 2023-04-05 19:57:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63870922/article/details/129975903
版权

 

 输出结果为：

#include <iostream>
#include <iomanip>
#include <queue>
#include <cstdlib> 
#include <string.h>
using namespace std;
#define OK 1;
#define TRUE 1;
#define ERROR 0;
#define FALSE 0;
#define MAX_VERTEX_NUM 25 //最大顶点个数
#define DATA_NUM_PER_LINE 25
typedef enum { DG, DN, UDG, UDN } GraphKind;//{有向图，有向网，无向图，无向网}
typedef int InfoType;
typedef char* VertexType;
typedef int Status;
typedef int VRType;
bool visited[MAX_VERTEX_NUM]; //访问标志数组，定义成全局变量
Status(*VisitFunc)(int v); //函数变量
//图的邻接矩阵表示
typedef struct ArcCell {
    VRType adj;//VRType是顶点关系类型。对无权图，用1或0表示是否相邻；对带权图，则为权值类型；
    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;

//图的邻接表表示
typedef struct ArcNode {
    int adjvex;//该弧所指顶点的位置
    struct ArcNode* nextarc;//该弧下一条弧的指针
    int weight;
    InfoType* info;//该弧相关信息的指针
}ArcNode;
typedef struct VNode {
    VertexType data;//顶点信息--名字 
    ArcNode* firstarc;//指向第一条依附该顶点的弧的指针
}VNode, AdjList[MAX_VERTEX_NUM];
typedef struct {
    AdjList vertices;
    int vexnum, arcnum;//图的当前顶点数合弧数
    GraphKind kind;//图的种类标志
}ALGraph;
Status CreateUDN_AdjMatrix(MGraph& G)
{
    G.vexnum = 25;
    for (int i = 0; i < 25; i++)
    {
        for (int j = 0; j < 25; j++)
        {
            G.arcs[i][j].adj = INT_MAX;
        }
    }
    G.arcs[0][1].adj = 137;   G.arcs[0][2].adj = 695;   G.arcs[0][15].adj = 668;
    G.arcs[1][10].adj = 674;  G.arcs[1][12].adj = 704;
    G.arcs[2][3].adj = 534;  G.arcs[2][10].adj = 349;  G.arcs[2][16].adj = 511;
    G.arcs[3][4].adj = 409;
    G.arcs[4][5].adj = 675; G.arcs[4][7].adj = 367;  G.arcs[4][19].adj = 902;  G.arcs[4][20].adj = 672;
    G.arcs[5][6].adj = 140;
    G.arcs[7][8].adj = 633;  G.arcs[7][9].adj = 825;
    G.arcs[9][10].adj = 651;
    G.arcs[11][12].adj = 397;
    G.arcs[12][13].adj = 305;
    G.arcs[13][14].adj = 241;
    G.arcs[15][22].adj = 1145;
    G.arcs[16][17].adj = 842; G.arcs[16][22].adj = 676;
    G.arcs[17][18].adj = 1100; G.arcs[17][19].adj = 967;
    G.arcs[18][19].adj = 639;
    G.arcs[19][20].adj = 607;
    G.arcs[20][21].adj = 255;
    G.arcs[22][23].adj = 216;   G.arcs[22][24].adj = 1892;
    for (int i = 0; i < G.vexnum; i++) {
        G.vexs[i] = (char*)malloc(20 * sizeof(char));
    }
    const char* name[] = { "北京","天津","哈尔滨","长春","沈阳","大连","呼和浩特","乌鲁木齐","西宁","兰州","西安","郑州",
                "徐州","上海","武汉","成都","昆明","贵阳","南宁","柳州","株洲","南昌","福州","广州","深圳" };
    for (int i = 0; i < G.vexnum; ++i)
    {
        strcpy(G.vexs[i], name[i]);
    }
    for (int i = 0; i < 25; i++)
    {
        for (int j = 0; j < 25; j++)
        {
            G.arcs[j][i].adj = G.arcs[i][j].adj;//由于构造的是无向网，所以还需要置<v1,v2>的对称弧<v2,v1> 
        }
    }
    return OK;
}
Status CreateUDN_AdjList(MGraph& g, ALGraph& G)
{
    int i, j;
    ArcNode* p;
    ALGraph* pG;
    pG = (ALGraph*)malloc(sizeof(ALGraph));
    if (pG) G = *pG;
    for (int i = 0; i < g.vexnum; i++) {
        G.vertices[i].data = (char*)malloc(20 * sizeof(char));
    }
    for (int i = 0; i < g.vexnum; ++i)
    {
        strcpy(G.vertices[i].data, g.vexs[i]);
    }
    for (i = 0; i < g.vexnum; i++)
        G.vertices[i].firstarc = NULL;
    for (i = 0; i < g.vexnum; i++)
    {
        for (j = g.vexnum - 1; j >= 0; j--)
        {
            if (g.arcs[i][j].adj != INT_MAX)
            {
                p = (ArcNode*)malloc(sizeof(ArcNode));
                p->adjvex = j;
                p->weight = g.arcs[i][j].adj;
                p->nextarc = G.vertices[i].firstarc;
                G.vertices[i].firstarc = p;
            }
        }
    }
    G.vexnum = g.vexnum;
    G.arcnum = g.arcnum;
    return OK;
}
Status LocateVex(MGraph& G, VertexType v)  //若找到结点返回i
{//查找顶点v 
    for (int i = 0; i <= G.vexnum; ++i)
    {
        if (!strcmp(G.vexs[i], v))
        {
            return i;
        }
    }
    return -1;  //否则返回-1，表示没有找到 
}
Status DestroyGraph(MGraph& G)
{//返回值：状态码，操作成功返回OK,作用：销毁图G
    //若是网 
    if (G.kind % 2) //重置邻接矩阵所有顶点之间不可达 
    {
        for (int i = 0; i < G.vexnum; i++)
        {
            for (int j = 0; j < G.vexnum; j++)
            {
                G.arcs[i][j].adj = INT_MAX;
            }
        }
    }
    else
    { //若是图 ,重置邻接矩阵所有顶点之间不可达
        for (int i = 0; i < G.vexnum; i++)
        {
            for (int j = 0; j < G.vexnum; j++)
            {
                G.arcs[i][j].adj = 0;
            }
        }
    }
    G.vexnum = 0;//重置顶点数为0
    G.arcnum = 0;//重置边数为0
    return OK;
}
Status PrintAdjMatrix(MGraph& G)
{//打印邻接矩阵
    int p = 1;
    cout << "AdjMatrix:" << endl;
    cout << "  ";
    for (int i = 0; i < G.vexnum; i++) //输出邻接矩阵的上坐标（全部顶点） 
    {
        cout <<setw(5)<< i+1;
    }
    cout << endl;
    for (int i = 0; i < G.vexnum; i++)//输出邻接矩阵的左坐标（全部顶点）和内容
    {
        cout << setw(2) <<i+1;//输出邻接矩阵左边的坐标
        for (int j = 0; j < G.vexnum; j++, p++)
        {
            if (G.arcs[i][j].adj == INT_MAX)
            {
                cout << "    ∞";
            }
            if (G.arcs[i][j].adj != INT_MAX)
            {
                cout << setw(5) << G.arcs[i][j].adj;
            }
            if (p % DATA_NUM_PER_LINE == 0)
                cout << endl;
        }
    }
    cout << "PrintAdjMatrix Over" << endl << endl;
    return OK;
}
Status PrintAdjList(ALGraph& G)
{//打印邻接表 
    cout << "AdjList:" << endl;
    for (int i = 0; i < G.vexnum; i++)
    {//顶点
        ArcNode* p = G.vertices[i].firstarc;
        cout << G.vertices[i].data<<'\t';
        while (p)
        {
            cout << '\t' <<"->" << G.vertices[i].data<<"("<<p->weight<<")";
            p = p->nextarc;
        }
        cout << endl;
    }
    cout << endl;
    return OK;
}
Status FirstAdjVex(MGraph G, VertexType v)
{//求顶点v在图G中的第一个邻接点
    int j = 0;//j表示不可达，在图中，0表示不可达，在网中INT_MAX表示不可达 
    int k = LocateVex(G, v); //v是顶点，不是序号！需要定位 //k就是顶点v在顶点数组中的序号
    if (G.kind == DN || G.kind == UDN)  //若是网，则INT_MAX表示不可达
    {
        j = INT_MAX;
    }
    for (int i = 0; i < G.vexnum; ++i) //在顶点v对应的第k行查找第一个邻接点的序号i 
    {
        if (G.arcs[k][i].adj != j)
        {
            return i;
        }
    }
    return -1;  //若未找到返回-1 
}
Status NextAdjVex(MGraph G, VertexType v, VertexType w)
{//求顶点v在图G中相对于邻接点w的下一个邻接点
    int j = 0;//j表示不可达，在图中，0表示不可达，在网中INT_MAX表示不可达
    int k1 = LocateVex(G, v);//k1是顶点v在顶点数组中的位序 
    int k2 = LocateVex(G, w);//k2是顶点w在顶点数组中的位序
    if (G.kind == DN || G.kind == UDN)//若是网，则使用INT_MAX表示不可达 
    {
        j = INT_MAX;
    }
    for (int i = k2 + 1; i < G.vexnum; ++i) //在图G中查找顶点v相对于顶点w的下一个邻接点的位置 
    {//若找到则返回i 
        if (G.arcs[k1][i].adj != j)
        {
            return i;
        }
    }
    return -1;//若未找到返回-1
}
void DFS_AdjMatrix(MGraph& G, int i)
{//从节点i开始DFS遍历
    int j;
    cout << G.vexs[i] << '\t';//输出起始结点 
    visited[i] = TRUE;//将已访问的结点标志成1
    for (j = 0; j < G.vexnum; j++)//依次搜索vi的邻接点 
    {
        if (G.arcs[i][j].adj != INT_MAX && !visited[j])//当满足有边且未被访问过时，递归调用去查找该邻接点 
        {
            DFS_AdjMatrix(G, j);//注意此处的G已经是指针类型，不需要再&G 
        }
    }
}
void DFSTraverse_AdjMatrix(MGraph G)
{//邻接矩阵的深度优先遍历
    int i;//初始化"标志"数组为0，代表未访问
    for (i = 0; i < G.vexnum; i++)
    {
        visited[i] = 0;
    }
    for (i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
        {
            DFS_AdjMatrix(G, i);
        }
    }
    cout << endl << endl;
}

void BFSTraverse_AdjMatrix(MGraph G)
{//邻接矩阵的广度优先遍历
    int i, j;//数组初始化为全0
    queue<int>Q;
    for (i = 0; i < G.vexnum; i++)
    {
        visited[i] = 0;
    }
    for (i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
        {
            cout << G.vexs[i] << '\t';//输出当前结点 
            visited[i] = 1;//将已访问的结点标志成1
            Q.push(i);//将已访问结点入队 
            while (!Q.empty())
            {
                j = Q.front();
                Q.pop();
                //接下来访问节点j的邻接节点 
                for (int m = 0; m < G.vexnum; m++) {
                    if (G.arcs[j][m].adj != INT_MAX && !visited[m]) //邻接且未访问 
                    {
                        cout << G.vexs[m] << '\t'; //输出顶点 
                        visited[m] = 1; //设置成已访问状态1 
                        Q.push(m);
                    }
                }
            }
        }
    }
    cout << endl << endl;
}

void DFS_AdjList(ALGraph& G, ArcNode* p)
{//从p所指节点开始DFS遍历，邻接链表
    cout << G.vertices[p->adjvex].data << '\t';//输出起始结点 
    visited[p->adjvex] = TRUE;//将已访问的结点标志成1
    p = G.vertices[p->adjvex].firstarc;
    while (p) {
        if (!visited[p->adjvex]) DFS_AdjList(G, p);
        p = p->nextarc;
    }
}
void DFSTraverse_AdjList(ALGraph G)
{//邻接表的深度优先遍历
    int i;//初始化"标志"数组
    ArcNode* p;
    for (i = 0; i < G.vexnum; i++)
    {
        visited[i] = 0;
    }
    for (i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
        {
            cout << G.vertices[i].data << '\t';//访问当前节点 
            visited[i] = TRUE;//将当前节点标记成已访问结点
            p = G.vertices[i].firstarc;
            while (p) //依次搜索vi的邻接点 
            {
                if (!visited[p->adjvex]) DFS_AdjList(G, p);
                p = p->nextarc;//查找下一个邻接节点
            }
        }
    }
    cout << endl << endl;
}

void BFSTraverse_AdjList(ALGraph G)
{//邻接表的广度优先遍历
    int i, j;
    queue<int> Q;
    ArcNode* p;
    for (i = 0; i < G.vexnum; i++)
    {
        visited[i] = 0;
    }
    for (i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
        {
            cout << G.vertices[i].data << '\t';//输出当前结点 
            visited[i] = 1;//将已访问的结点标志成1
            Q.push(i);//将已访问结点入队 
            while (!Q.empty())
            {
                j = Q.front();
                Q.pop();
                //接下来访问节点j的邻接节点 
                p = G.vertices[j].firstarc;
                while (p) {
                    if (!visited[p->adjvex]) {
                        cout << G.vertices[p->adjvex].data << '\t';//访问当前节点 
                        visited[p->adjvex] = TRUE;//将当前节点标记成已访问结点
                        Q.push(p->adjvex);
                    }
                    p = p->nextarc;
                }
            }
        }
    }
    cout << endl << endl;
}
int  main()
{
    system("color F0");
    MGraph  G1;
    ALGraph G2;
    CreateUDN_AdjMatrix(G1);
    cout << "所有顶点为：" << endl;
    for (int i = 0; i < G1.vexnum; i++)
    {
        cout <<setw(5)<<setfill(' ')<< i + 1 << "." << G1.vexs[i];
        if ((i+1)% 10 == 0) cout << endl;
    }
    cout << endl;
    CreateUDN_AdjList(G1, G2);
    PrintAdjMatrix(G1);//打印邻接矩阵
    PrintAdjList(G2);//打印邻接表
    cout << "邻接矩阵的深度优先遍历" << endl;
    DFSTraverse_AdjMatrix(G1);//邻接矩阵的深度优先遍历
    cout << "邻接矩阵的广度优先遍历" << endl;
    BFSTraverse_AdjMatrix(G1);//邻接矩阵的广度优先遍历
    cout << "邻接表的深度优先遍历" << endl;
    DFSTraverse_AdjList(G2);//邻接表的深度优先遍历
    cout << "邻接表的广度优先遍历" << endl;
    BFSTraverse_AdjList(G2);//邻接表的广度优先遍历
    system("pause");
    return 0;
}

 

弗朗凌戈
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
华中科技大学数据结构实验
12-16
华中科技大学数据结构实验 欢迎下载 。
华中科技大学数据结构实验报告
02-04
华中科技大学 大二 上学期 数据结构 上机实验 报告 一共6次实验 包含表 队列 图 树等内容
华中科技大学计算机学院数据结构实验报告及源代码
03-31
华中科技大学计算机学院数据结构实验报告及源代码。。。
华中科技大学数据结构与算法分析实验-内部排序实验报告
04-05
《内部排序算法实践与分析——华中科技大学数据结构与算法实验报告》 内部排序是计算机科学中的重要领域，涉及各种算法的设计与优化。本实验旨在深入理解并掌握常见内部排序算法，包括直接插入排序、冒泡排序、简单...
华中科技大学四次数据结构实验源代码和exe文件.zip
11-21
华中科技大学的这个实验项目涵盖了数据结构的基础概念和重要实现，包括线性表、链表、二叉树和邻接表。这些知识点在计算机算法设计、软件开发和系统分析等领域具有广泛的应用。 1. **线性表**：线性表是最基本的...
2011年华中科技大学数据结构与算法分析考研试题1
08-03
数据结构与算法是计算机科学的基础，对于理解和解决复杂的计算问题是至关重要的。华中科技大学2011年的研究生入学考试试题涵盖了这些关键领域的多个知识点。 1. **线性表**：线性表是一种基本的数据结构，它由有限...
华中科技大学数据结构实验4次源程序和报告都是齐全的，欢迎下载
11-15
首先，需要定义函数的返回状态。这些状态包括正确、错误、可行、运行非法、不可实行和溢出。这些状态分别用TRUE、FALSE、OK、ERROR、INFEASTABLE和OVERFLOW表示。 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASTABLE -1 #define OVERFLOW -2 其次，需要定义线性表的初始大小以及线性表满后所需要的增加量。分别用LIST_INIT_SIZE和LISTINCREMENT表示。
bellman算法流程
qq_56202771的博客
03-13 934
迪杰斯特拉的算法正如我们所知道的，该算法虽然时间复杂度低，但是只适用于无负权值的图 所以当我们遇到有负值的图呢？ 前提 是无负值的环 同时做了很多的无用工 这时候就需要bellman-ford算法 先说说bellman-ford算法的流程吧 1.首先一个边集合（记录边的起点，终点，权值） struct bian（记录每一条边） { int v;//起点 int w;//终点 int quan;//权值 }; 然后就是我们的常客dis[]兄弟了（记录源点到终点的距离的）...
华中科技大学计算机学院数据结构前三次实验全部，及第四实验报告，及课程设计SAT问题.zip
最新发布
02-24
华中科技大学计算机学院数据结构前三次实验全部，及第四实验报告，及课程设计SAT问题
华科计科第一次数据结构实验源代码
05-20
华科计算机科学与技术学院数据结构课程第一次实验的源代码，本人亲自完成。
华科数据结构实验报告
12-16
代码和文档打包下载。
华科数据结构实验报告代码和文档
12-16
华科数据结构实验合辑。。。。。。。。。。。。。。。。，顺序表，二叉树，图。。。
计算机算法基础的课件和答案 (华中科技大学计算机学院 王多强)
11-18
配套 余祥宣等《计算机算法基础》华中科技大学出版社教材的课件和答案！
简单算法-bellman最短路
weixin_57544905的博客
10-04 250
一、什么是bellman-ford算法？ 上篇讲到了Floyd算法，它是多源最短路径算法。这里讲的bellman 则是单源最短路径算法。该算法优化了Floyd那样广撒网的形式，一定程度上减小了时间复杂度。能够计算更大图，但缺点是一次只能计算一个结点到各结点对距离。 二、算法思维 先初始化单源点到其他结点的距离为INF（无穷大），比如我们想要到达一个地方，但我们并不知道有多远，但我们知道去下个地点的距离，我们是不是可以询问下个地点的人去我们要去的地点的距离，也许他也不知道，但他...
华科2020算法设计与分析 (POJ)做(shua)题(shui)记录（未完）
zyf2000
10-16 1555
CCSP就要打铁了好烦啊->CCSP果然打铁了好烦啊
设计两个具体子类来继承抽象类，分别实现矩形和圆形的面积和周长的计算
weixin_46597615的博客
03-21 1000
设计两个具体子类来继承抽象类，分别实现矩形和圆形的面积和周长的计算。矩形：Rectangle 宽：width 高：height。计算周长：calculatePerimeter。计算面积：calculateArea。圆形：Shape 半径：radius。//定义矩形类继承形状属性。
Linux必知必会,答应我拿下这些Linux必备技能
热门推荐
小杰312的博客
04-24 1万+
Linux必知必会,这些Linux知识你确定掌握清楚了吗
华中科技大学硕士研究生数据结构与算法考试答案解析
“华中科技大学招收硕士研究生入学考试试题答案，包含数据结构与算法分析历年试题及部分解答。” 本文主要讨论的是华中科技大学硕士研究生入学考试中的数据结构与算法分析部分的试题答案。这个资料集包含了从二OO六...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值