第六章 图 —— 邻接矩阵/邻接表构造图实现BFS/DFS/Dijkstra算法

最新推荐文章于 2022-11-27 19:13:33 发布
最新推荐文章于 2022-11-27 19:13:33 发布
阅读量1.1k 收藏 10
点赞数 3
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Deam_swan_goose/article/details/106251645
版权

第六章 图 —— 邻接矩阵/邻接表构造图实现BFS/DFS/Dijkstra算法

要求：
（1）采用邻接矩阵/邻接表建立图；
（2）采用深度优先/广度优先搜索方式遍历图；
（3）编程实现Dijkstra最短路径算法。

此处均以无向图为例

邻接矩阵：

在这里插入图片描述代码如下：

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<bits/stdc++.h>
#define MaxVerNum 100 //顶点最大数目值
#define VexType char //顶点数据类型
#define EdgeType int //边数据类型,无向图时邻接矩阵对称，有权值时表示权值，没有时1连0不连
#define INF 0x3f3f3f3f//作为最大值
using namespace std;
//图的数据结构
typedef struct Graph
{
    VexType Vex[MaxVerNum];//顶点表
    EdgeType Edge[MaxVerNum][MaxVerNum];//边表
    int vexnum, arcnum;//顶点数、边数
} Graph;
//迪杰斯特拉算法全局变量
bool S[MaxVerNum]; //顶点集
int D[MaxVerNum];  //到各个顶点的最短路径
int Pr[MaxVerNum]; //记录前驱

//初始化函数
void InitGraph(Graph& G)
{
    memset(G.Vex, '#', sizeof(G.Vex));//初始化顶点表
    //初始化边表
    for (int i = 0; i < MaxVerNum; i++)
        for (int j = 0; j < MaxVerNum; j++)
            G.Edge[i][j] = INF;
    G.arcnum = G.vexnum = 0;          //初始化顶点数、边数
}

//插入顶点函数
bool InsertNode(Graph& G, VexType v)
{
    if (G.vexnum < MaxVerNum)
    {
        G.Vex[G.vexnum++] = v;
        return true;
    }
    return false;
}

//插入边函数
bool InsertEdge(Graph& G, VexType v, VexType w, int weight)
{
    int p1, p2;//v,w两点下标
    p1 = p2 = -1;//初始化
    for (int i = 0; i < G.vexnum; i++)//寻找顶点下标
    {
        if (G.Vex[i] == v)
            p1 = i;
        if (G.Vex[i] == w)
            p2 = i;
    }
    if (-1 != p1 && -1 != p2)//两点均可在图中找到
    {
        G.Edge[p1][p2] = G.Edge[p2][p1] = weight;//无向图邻接矩阵对称
        G.arcnum++;
        return true;
    }
    return false;
}

//判断是否存在边(v,w)函数
bool Adjancent(Graph G, VexType v, VexType w)
{
    int p1, p2;//v,w两点下标
    p1 = p2 = -1;//初始化
    for (int i = 0; i < G.vexnum; i++)//寻找顶点下标
    {
        if (G.Vex[i] == v)
            p1 = i;
        if (G.Vex[i] == w)
            p2 = i;
    }
    if (-1 != p1 && -1 != p2)//两点均可在图中找到
    {
        if (G.Edge[p1][p2] == 1)//存在边
        {
            return true;
        }
        return false;
    }
    return false;
}

bool visited[MaxVerNum];//访问标记数组，用于遍历时的标记

//广度遍历函数
void BFS(Graph G, int start)
{
    queue<int> Q;//辅助队列
    cout << G.Vex[start];//访问结点
    visited[start] = true;
    Q.push(start);//入队
    while (!Q.empty())//队列非空
    {
        int v = Q.front();//得到队头元素
        Q.pop();//出队
        for (int j = 0; j < G.vexnum; j++)//邻接点
        {
            if (G.Edge[v][j] < INF && !visited[j])//是邻接点且未访问
            {
                cout << "->";
                cout << G.Vex[j];//访问结点
                visited[j] = true;
                Q.push(j);//入队
            }
        }
    }//while
    cout << endl;
}

//深度遍历函数（递归形式）
void DFS(Graph G, int start)
{
    cout << G.Vex[start];//访问
    visited[start] = true;
    for (int j = 0; j < G.vexnum; j++)
    {
        if (G.Edge[start][j] < INF && !visited[j])//是邻接点且未访问
        {
            cout << "->";
            DFS(G, j);//递归深度遍历
        }
    }
}

//最短路径 - Dijkstra算法 参数：图G、源点v
void Dijkstra(Graph G, int v)
{
    //初始化
    int n = G.vexnum;//n为图的顶点个数
    for (int i = 0; i < n; i++)
    {
        S[i] = false;
        D[i] = G.Edge[v][i];
        if (D[i] < INF)
            Pr[i] = v; //v与i连接，v为前驱
        else
            Pr[i] = -1;
    }
    S[v] = true;
    D[v] = 0;
    //初始化结束,求最短路径，并加入S集
    for (int i = 1; i < n; i++)
    {
        int min = INF;
        int temp;
        for (int w = 0; w < n; w++)
            if (!S[w] && D[w] < min) //某点temp未加入s集，且为当前最短路径
            {
                temp = w;
                min = D[w];
            }
        S[temp] = true;
        //更新从源点出发至其余点的最短路径 通过temp
        for (int w = 0; w < n; w++)
            if (!S[w] && D[temp] + G.Edge[temp][w] < D[w])
            {
                D[w] = D[temp] + G.Edge[temp][w];
                Pr[w] = temp;
            }
    }
}

//输出最短路径
void Path(Graph G, int v)
{
    if (Pr[v] == -1)
        return;
    Path(G, Pr[v]);
    cout << G.Vex[Pr[v]] << "->";
}

//打印图的顶点表
void PrintVex(Graph G)
{
    cout<<"图中的顶点为：";
    for (int i = 0; i < G.vexnum; i++)
    {
        cout << G.Vex[i] << " ";
    }
    cout << endl;
}

//打印图的边矩阵
void PrintEdge(Graph G)
{
    cout<<"邻接矩阵为："<<endl;
    for (int i = 0; i < G.vexnum; i++)
    {
        for (int j = 0; j < G.vexnum; j++)
        {
            if (G.Edge[i][j] == INF)
                cout << "∞ ";
            else
                cout << G.Edge[i][j] << " ";
        }
        cout << endl;
    }
}

//创建图功能实现函数
void CreateGraph(Graph& G)
{
    VexType v, w;
    int vn, an;//顶点数，边数
    cout << "请输入顶点数目:" << endl;
    cin >> vn;
    cout << "请输入边数目:" << endl;
    cin >> an;
    cout << "请输入所有顶点名称:" << endl;
    for (int i = 0; i < vn; i++)
    {
        cin >> v;
        if (InsertNode(G, v))
            continue;//插入点
        else
        {
            cout << "输入错误！" << endl;
            break;
        }
    }
    cout << "请输入所有边（每行输入边连接的两个顶点及权值）:" << endl;
    for (int j = 0; j < an; j++)
    {
        int weight;
        cin >> v >> w >> weight;
        if (InsertEdge(G, v, w, weight))
            continue;//插入边
        else
        {
            cout << "输入错误！" << endl;
            break;
        }
    }
    PrintVex(G);
    cout<<endl;
    PrintEdge(G);
}

//广度遍历功能实现函数
void BFSTraverse(Graph G)
{
    for (int i = 0; i < MaxVerNum; i++)//初始化访问标记数组
    {
        visited[i] = false;
    }
    for (int i = 0; i < G.vexnum; i++)//对每个连通分量进行遍历
    {
        if (!visited[i])
            BFS(G, i);
    }
}

//深度遍历功能实现函数
void DFSTraverse(Graph G)
{
    for (int i = 0; i < MaxVerNum; i++)//初始化访问标记数组
    {
        visited[i] = false;
    }
    for (int i = 0; i < G.vexnum; i++)//对每个连通分量进行遍历
    {
        if (!visited[i])
        {
            DFS(G, i);
            cout << endl;
        }
    }
}

//调用最短路径-Dijkstra算法
void Shortest_Dijkstra(Graph& G)
{
    char vname;
    int v = -1;
    cout << "请输入源点名称:" << endl;
    cin >> vname;
    for (int i = 0; i < G.vexnum; i++)
    {
        if (G.Vex[i] == vname)
            v = i;
    }

    if (v == -1)
    {
        cout << "没有找到输入点！" << endl;
        return;
    }
    Dijkstra(G, v);
    cout << "目标点" << "\t" << "最短路径值" << "\t" << "最短路径" << endl;
    for (int i = 0; i < G.vexnum; i++)
    {
        if (i != v)
        {
            cout << "  " << G.Vex[i] << "\t" << "        " << D[i] << "\t";
            Path(G, i);
            cout << G.Vex[i] << endl;
        }
    }
}

//菜单
void menu()
{
    cout<<"1.创建图" << endl;
    cout<<"2.广度遍历"<<endl;
    cout<<"3.深度遍历" << endl;
    cout<<"4.迪杰斯特拉"<<endl;
    cout<<"5.退出" << endl;
}

//主函数
int main()
{
    int choice = 0;
    Graph G;
    InitGraph(G);
    while (1)
    {
        menu();
        cout<<"请输入菜单序号: "<<endl;
        cin>>choice;
        if (5 == choice)
            break;
        switch (choice)
        {
        case 1:
            CreateGraph(G);
            break;
        case 2:
            BFSTraverse(G);
            break;
        case 3:
            DFSTraverse(G);
            break;
        case 4:
            Shortest_Dijkstra(G);
            break;
        default:
            printf("输入错误！！！\n");
            break;
        }
        cout<<endl;
    }
    return 0;
}

邻接表

在这里插入图片描述
代码如下：

#include <bits/stdc++.h>
using namespace std;
#define MAXSIZE 100
int v[MAXSIZE];//标志位，判断该结点有没有被访问

typedef struct ArcNode //定义边节点
{
    int adjvex;//该节点在图中的位置
    int weight;//权值
    struct ArcNode *next;//指向下一条边的指针
} ArcNode;

typedef struct VNode //定义顶点信息
{
    char data;
    ArcNode *firstarc;//指向第一条依附于顶点的边的指针
} VNode,AdjList[MAXSIZE];//AdjList表示邻接表类型

typedef struct //定义邻接表
{
    int vexnum,arcnum;//顶点数和边数
    AdjList vertices;
} ALGraph;

//定位函数（将点的名称转化为点的位置）
int LocateVex(ALGraph G,char u)
{
    int i;
    for(i=1; i<=G.vexnum; ++i)
        if(u==G.vertices[i].data)
            return i;
    return -1;
}


void CreatUDG(ALGraph &G)//构建无向图
{
    int i,n,m,p1,p2;
    char a,b;
    ArcNode *s;
    cout<<"请输入顶点数和边数："<<endl;
    cin>>n>>m;
    G.vexnum=n;
    G.arcnum=m;
    cout<<"输入顶点名称："<<endl;
    for(i=1; i<=G.vexnum; i++)
    {
        cin>>G.vertices[i].data;
        G.vertices[i].firstarc=NULL;//一开始都指向NULL
    }
    cout<<"输入一条边对应的两个顶点："<<endl;
    for(i=0; i<G.arcnum; i++)
    {
        cin>>a>>b;
        p1 = LocateVex(G,a);
        p2 = LocateVex(G,b);//将名称转化为位置
        s=new ArcNode[sizeof(ArcNode)];//生成一个新的边结点
        s->adjvex=p2;//邻接点的序号为p2
        s->next=G.vertices[p1].firstarc;
        G.vertices[p1].firstarc=s;//将新结点前插至边表头部

        s=new ArcNode[sizeof(ArcNode)];
        s->adjvex=p1;
        s->next=G.vertices[p2].firstarc;
        G.vertices[p2].firstarc=s;//同上，将新结点前插至边表头部
    }
}

int FirstAdjVex(ALGraph G,int k)//返回图G中与k相邻且未被访问过的点的编号，如果不存在这样的点返回-1
{
    ArcNode *s;
    s=G.vertices[k].firstarc;
    if(!s)
        return -1;
    while(s&&v[s->adjvex])//如果不空又访问过，就看下一个
        s=s->next;
    if(s)//不空说明找到了
        return s->adjvex;
    else//否则返回-1
        return -1;
}

int NextAdjVex(ALGraph G,int k,int w)//返回图G中与k相邻、除了编号是w之外的未被访问过的点的编号，如果不存在这样的点返回-1
{
    ArcNode *s;
    s=G.vertices[k].firstarc;
    if(!s)
        return -1;
    while(s&&(v[s->adjvex]||s->adjvex==w))//不空，并且要么是访问过，要么是w，这样的点我们统统忽略
        s=s->next;
    if(s)//不空说明找到了
        return s->adjvex;
    else//否则-1
        return -1;
}

void DFS(ALGraph G,int k)//对节点k进行深度优先遍历
{
    int w;
    v[k]=1;//进来就置1
    cout<<G.vertices[k].data<<" ";//遍历输出
    for(w=FirstAdjVex(G,k); w!=-1; w=NextAdjVex(G,k,w)) //找到所有和k相邻的节点的编号，挨个深搜递归
        if(!v[w])
            DFS(G,w);
}

void DFSTraverse(ALGraph G)//对所有点进行深度优先遍历（防止在非连通图中遗漏点）
{
    int i;
    memset(v,0,sizeof(v));
    for(i=1; i<=G.vexnum; i++)
        if(!v[i])
            DFS(G,i);
}

void BFS(ALGraph G)//广度优先遍历
{
    int i,k,w;
    queue<char> q;//定义一个队列存储点的名称
    memset(v,0,sizeof(v));//因为之前深搜过，这里重新置0一下
    for(i=1; i<=G.vexnum; i++) //依次对每个顶点进行考察（此处相当于把BFS和BFSTraverse合并）
        if(!v[i])//只要不空
        {
            v[i]=1;//只要不空，进来第一件事就是置1
            cout<<G.vertices[i].data<<" ";//置1之后马上输出
            q.push(G.vertices[i].data);//输出完了之后就入队
            while(!q.empty())//只要队列不空
            {
                k=LocateVex(G,q.front());//取队首元素
                q.pop();//然后队首出队
                for(w=FirstAdjVex(G,k); w!=-1; w=NextAdjVex(G,k,w)) //将所有和队首邻接的顶点依次入队，入一个，输出一个
                    if(!v[w])
                    {
                        v[w]=1;
                        cout<<G.vertices[w].data<<" ";
                        q.push(G.vertices[w].data);
                    }
            }
        }
}

int main()
{
    ALGraph G;
    CreatUDG(G);
    cout<<"DFS:";
    DFSTraverse(G);
    cout<<endl;
    cout<<"BFS:";
    BFS(G);
}
梦里一声何处鸿
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
邻接矩阵/图/DFS/BFS
m0_61548909的博客
06-06 2092
目录1.邻接矩阵的表示2.邻接矩阵的存储3.采用邻接矩阵表示法创建无向网 4.基于邻接矩阵的图上各类操作 5.DFS6.BFS7.测试程序（待完成） 权与网连通分量（强连通分量） 无向图 有向图 网（有权图） 3.采用邻接矩阵表示法创建无向网 创建无向图和有向图的区别 优缺点 声明 广度优先搜索需要的队列（图的遍历） 基于邻接矩阵的图上操作 5.DFS 深度优先搜索属于图算法的一种，是一个针对图和树的遍历算法，英文缩写为DFS即Depth First Search。深度优先搜
数据结构实验：C++实现邻接矩阵创建无向图以及BFS和DFS遍历
qq_45050714的博客
01-02 3041
数据结构实验四：利用邻接矩阵创建无向图，并实现BFS和DFS遍历 1.实验目的 采用邻接矩阵或邻接表进行图的存储 分别完成图的深度优先和宽度优先搜索 2.无向图类 #ifndef graph_h #define graph_h #include<iostream> #include<queue> #include<stack> #include<map> using namespace std; //利用邻接矩阵构造无向图，实现BFS和DFS遍历 clas
无向图DFS+BFS(不全)
m0_51265528的博客
12-11 182
邻接矩阵实现方式 还不完整 #include<iostream> #include<queue> using namespace std; //图的邻接矩阵模式 extern const int maxWeight=9999; const int maxSize = 100; //邻接矩阵存储的图的类定义（无向图） template <class T, class E> class Graphmtx //图的邻接矩阵类定义 { public: Graphmt
C++DFS与BFS实现
weixin_42749137的博客
11-22 4084
C++DFS与BFS实现DFSBFS   BFS使用一个queue实现，每次循环对当前点临近的点，都推进队列中，然后就能根据队列来依次访问临近的点，直到队列中没有点为止。   DFS利用一个stack，首先把start推进stack里面，然后循环每次找到当前stack top的临近的未访问的点，访问后，推进stack里面，以便下次循环进行深度搜索。   以下使用图的遍历算法来举例说明。 DFS BFS 广度优先搜索在进一步遍历图中顶点之前，先访问当前顶点的所有邻接结点。 a .首先选择一个顶点作为起始结点，
算法之路(三)——BFS
nbaDWde的博客
03-25 842
最近由于要忙论文开题的事，还有实习工作也比较忙，所以这个系列的博客好久没有更新了。 BFS是一种基于“队列”这种数据结构的搜索方式，特点是由一个状态拓展出很多状态，然后再由此扩展，直到找到目标状态或者队列中头尾指针相遇，即队列中所有状态都处理完毕。 BFS对于解决最短或最少问题特别有效，而且寻找深度小，但缺点也很明显，内存消耗巨大（因为它需要大量的数组单元用来存储状态）。 下面是实现BFS的
图的邻接矩阵和邻接表实现
11-26
本文将详细探讨图的两种常见存储方式——邻接矩阵和邻接表，以及基于这两种数据结构的深度搜索（DFS）、广度搜索（BFS）和Dijkstra最短路径算法。 首先，邻接矩阵是一种二维数组，用于表示图中所有节点之间的连接...
标准C的图的实现+BFS和DFS遍历+Dijkstra算法+Prim算法+Kruskal算法实现
04-06
在这个项目中，"标准C的图的实现+BFS和DFS遍历+Dijkstra算法+Prim算法+Kruskal算法实现"涵盖了图的多种核心操作和算法。接下来，我们将详细讨论这些知识点。 首先，我们来看图的实现。在标准C语言中，图可以使用...
图的邻接表实现.rar
05-25
在实际应用中，使用邻接表实现的图可以有效地进行深度优先搜索（DFS）和广度优先搜索（BFS），并支持多种图算法，如最短路径计算（Dijkstra算法或Floyd-Warshall算法）、拓扑排序等。此外，由于类模板的使用，此实现...
考研数据结构-图的相关应用算法
11-14
内容包含图的相关算法的关键代码，包含但不限于图的存储结构（邻接矩阵和邻接表）、DFS 和 BFS（含递归和非递归两种形式）、拓扑排序、最小代价生成树（Prim 和 Kruskal 算法）、最短路径（Dijkstra 和 Floyd 算法）...
算法与数据结构课件PPT第六章
07-16
【算法与数据结构课件PPT第六章】主要讲解了图这一重要的数据结构，图是一种非线性的数据结构，由顶点（Vertex）和边（Edge）构成，用于表示对象之间的复杂关系。图的表示通常有两种方式：邻接矩阵和邻接表。 1. **...
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
06-17
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历 数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历.rar
图的操作（c++实现）
路漫漫小菜狗的博客
12-05 1987
（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
邻接矩阵遍历（无向图，邻接矩阵，DFS，BFS）
持续学习，刻意练习
12-12 2158
1、题目：  Problem Description 有多组数据，每组数据第一行有两个整数n、m,(0  Input 分别输出从标号为1点开始深度和广度优先搜索的序列，每个数之后有一个空格。 每组数组分别占一行。  Output 按存储顺序的先后，输出各连通分量中的顶点，每组输出占若干行，每行最后均有一空格，具体格式见样例。  Sampl
图的遍历：BFS和DFS
五山口老法师
09-12 296
前言 图是一种灵活的数据结构，一般作为一种模型用来定义对象之间的关系或联系。对象由顶点（V）表示，而对象之间的关系或者关联则通过图的边（E）来表示。 图可以分为有向图和无向图，一般用G=(V,E)来表示图。经常用邻接矩阵或者邻接表来描述一副图。 在图的基本算法中，最初需要接触的就是图的遍历算法。 根据访问节点的顺序，可分为广度优先搜索（BFS）和深度优先搜索（DFS）。 正文 广度优先搜索...
dijkstra迪杰斯特拉算法（邻接表法）
最新发布
m0_51657509的博客
11-27 2052
使用邻接表法求单源有向图最短路径，djikstra迪杰斯特拉算法（朴素）。
数据结构学习笔记-Dijkstra算法(C语言邻接表实现)
guetWH的博客
05-30 1194
Dijkstra算法是计算有权值图的单源最短路径问题的经典算法 算法核心思想：定义一个顶点集合S{V0，V1，……Vn}，初始条件下集合S中只包含yu
最短路径的Dijkstra算法（邻接表）
jacke121的专栏
02-17 5449
原文：http://blog.csdn.net/axiqia/article/details/50984464描述    以邻接表作为存储结构实现，求解从给定源点到给定结束点的最短路径。 输入从1开始表示第一个节点。第一行输入：顶点数n(2&lt;=n&lt;=100),边数m(2&lt;=m&lt;=100)第二行输入有向边：起始点s1，结束点 s2，边权值 w第三行输入：源点start，终点e...
Dijkstra算法分别用"邻接矩阵图"和"邻接表图"实现
金州饿霸吃不饱的博客
12-18 1096
  一 邻接矩阵图： /** * Java: Dijkstra算法获取最短路径(邻接矩阵) * * @author skywang * @date 2014/04/24 */ import java.io.IOException; import java.util.Scanner; public class MatrixUDG { private int mEdgNu...
4.6 图的邻接矩阵存储及DFS和BFS
dxt_snow的博客
11-18 640
4.6 图的邻接矩阵存储及DFS和BFS介绍代码结果 介绍 DFS：深度优先搜索 BFS：广度优先搜索 代码 import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Arrays; import java.util.Queue; /** * 1. 图的存储 * 2. dfs: 深度优先搜索， 递归实现 * 3. bfs: 广度优先搜索 * @author dxt * */ public class
数据结构（C语言版） 第六章 图 知识梳理 + 习题详解1
08-03
综上所述，《数据结构（C语言版）》第六章图的内容主要包括图的基本概念、存储结构和遍历算法，以及图的应用和习题详解等内容。掌握这些知识对于理解和应用图相关的算法和数据结构具有重要意义。读者可以通过习题的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值