数据结构入门——图的相关算法（一）

最新推荐文章于 2024-05-02 23:45:54 发布
最新推荐文章于 2024-05-02 23:45:54 发布
阅读量3.7k 收藏 18
点赞数 3
分类专栏： 数据结构 文章标签： 最短路径 数据结构 Dijkstra Floyd SPFA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lushuangning/article/details/83451612
版权

写在前面

距离19年研究生考试越来越近了，专业课的算法设计题考数据结构中的图的部分。感觉这部分比较困难，我大学没参加过ACM，之前也从来没写过图的代码，照着王道的书花了一天撸了四百行代码，着实费劲。。函数名、变量名甚至代码结构都和王道的相关代码相似。包括BFS和DFS, 分别用邻接矩阵和邻接表实现了，还有SPFA, Floyd, Dijkstra，这些算法都用题目验证过，可以保证正确性。在此附上完整代码，可以直接copy运行。由于王道书上已经写了不少注释了，故这些代码的注释我写得很少，看不懂的地方请在下方评论，我尽可能回复。
spfa算法是受博主 xunalove 转发的这篇文章 最快最好用的——spfa算法 的启发写出来的。

#include <bits/stdc++.h>

#define MaxNum 200

using namespace std;

typedef int VertexType;
typedef int EdgeType;

//顺序栈
typedef struct{
    int data[MaxNum];
    int top;
}SqStack;

//顺序队列
typedef struct{
    int data[MaxNum];
    int rear,head;
}SqQueue;

//图的邻接矩阵表示法
typedef struct{
    VertexType vertex[MaxNum];
    EdgeType edge[MaxNum][MaxNum];
    int vexNum,arcNum;
}MGraph;

//图的邻接表表示法
typedef struct ArcNode{
    int adjvex;
    struct ArcNode* next;
}ArcNode;

typedef struct VNode{
    VertexType vex;
    ArcNode *first;
}VNode,AdjList[MaxNum];

typedef struct{
    AdjList verticies;
    int vexNum,arcNum;
}ALGraph;

//输入数据并存储到邻接矩阵中
void MGReadData(MGraph &G);
//输入数据并存储到邻接表中
void ALGReadData(ALGraph &G);

//采用邻接矩阵存储的广度优先搜索
void MGBFSTraverse(MGraph G);
void MGBFS(MGraph G,int u);
//采用邻接矩阵存储的深度优先搜索
void MGDFSTraverse(MGraph G);
void MGDFS(MGraph G,int u);
//采用邻接表存储的广度优先搜索
void ALGBFSTraverse(ALGraph G);
void ALGBFS(ALGraph G,int u);
//采用邻接表存储的深度优先搜索
void ALGDFSTraverse(ALGraph G);
void ALGDFS(ALGraph G,int u);
void visit(int v);

//从u开始执行迪杰斯特拉求最短路
void Dijkstra(MGraph G,int u,int path[],int dist[]);
//打印最短路
void printPath(int v);
//从u开始执行SPFA求最短路
void SPFA(MGraph G,int u,int paht[],int dist[]);
//弗洛伊德算法求任意两点最短路
void Floyd(MGraph G);

int MGFirstNeighbor(MGraph G,int k);
int MGNextNeighbor(MGraph G,int k,int n);
int ALGNextNeighbor(ALGraph G,int k,int w);
int ALGFirstNeighbor(ALGraph G,int k);

int path[MaxNum];
int dist[MaxNum];
int u,v;    //u是起点，v是终点
int visited[MaxNum] = {0};
int mp[MaxNum][MaxNum];

int main(){
    //MGraph G;
    //ALGraph ALG;

    //MGReadData(G);
    //ALGReadData(ALG);

    //MGBFSTraverse(G);
    //MGDFSTraverse(G);
    //ALGBFSTraverse(ALG);
    //ALGBFSTraverse(ALG);

    //printf("请输入起点和终点，以空格隔开\n");
    //scanf("%d%d",&u,&v);
    //Dijkstra(G,u,path,dist);
    //SPFA(G,u,path,dist);
    //printPath(v);
    //Floyd(G);
    //printf("从1到3的最短路径距离为：%d",mp[1][3]);

    return 0;
}

void MGReadData(MGraph &G){
    int i,j,k;
    scanf("%d%d",&G.vexNum,&G.arcNum);
    for(i = 1;i <= G.vexNum;i++){
        for(j = 1;j <= G.vexNum;j++){
            G.edge[i][j] = 1e9;
        }
    }

    for(k = 1;k <= G.arcNum;k++){
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        G.edge[x][y] = z;

        //对于无向图，邻接矩阵是个对称矩阵，下边的一行代码应打开
        //G.edge[y][x] = z;
    }
}

void ALGReadData(ALGraph &G){
    int i,j;
    ArcNode *s,*p;
    scanf("%d%d",&G.vexNum,&G.arcNum);
    //初始化顶点表
    for(i = 1;i <= G.vexNum;i++){
        G.verticies[i].vex = i;
        G.verticies[i].first = NULL;
    }
    //初始化边表
    for(j = 1;j <= G.arcNum;j++){
        int x,y;
        scanf("%d%d",&x,&y);
        if(G.verticies[x].first == NULL){
            s = (ArcNode *)malloc(sizeof(ArcNode));
            s->adjvex = y;
            s->next = NULL;
            G.verticies[x].first = s;
        }else{
            p = G.verticies[x].first;
            while(p->next){ //找到链尾
                p = p->next;
            }
            s = (ArcNode *)malloc(sizeof(ArcNode));
            s->adjvex = y;
            s->next = NULL;
            p->next = s;
        }
    }
}

void MGBFSTraverse(MGraph G){
    int i;

    for(i = 1;i <= G.vexNum;i++){
        if(!visited[i]){
            MGBFS(G,i);
        }
    }
}

void MGBFS(MGraph G,int u){
    int w;
    SqQueue que;
    int rear = 0,head = 0;

    visit(u);
    visited[u] = 1;
    que.data[rear++] = u;

    while(head < rear){
        int k = que.data[head++];
        for(w = MGFirstNeighbor(G,k);w >= 0;w = MGNextNeighbor(G,k,w)){
            if(!visited[w]){
                visit(w);
                visited[w] = 1;
                que.data[rear++] = w;
            }
        }
    }
}

void MGDFSTraverse(MGraph G){
    int i;
    for(i = 1;i <= G.vexNum;i++){
        if(!visited[i]){
            MGDFS(G,i);
        }
    }
}

void MGDFS(MGraph G,int u){
    int w;
    visit(u);
    visited[u] = 1;
    for(w = MGFirstNeighbor(G,u);w >= 0;w = MGNextNeighbor(G,u,w)){
        if(!visited[w]){
            MGDFS(G,w);
        }
    }
}

int MGFirstNeighbor(MGraph G,int k){
    int i;
    for(i = 1;i <= G.vexNum;i++){
        if(G.edge[k][i] < 1e9){
            return i;
        }
    }

    return -1;
}

int MGNextNeighbor(MGraph G,int k,int n){
    int i;
    for(i = n+1;i <= G.vexNum;i++){
        if(G.edge[k][i] < 1e9){
            return i;
        }
    }

    return -1;
}

void visit(int v){
    printf("%d ",v);
}

void ALGBFSTraverse(ALGraph G){
    int i;
    for(i = 1;i <= G.vexNum;i++){
        if(!visited[i]){
            ALGBFS(G,i);
        }
    }
}

void ALGBFS(ALGraph G,int u){
    SqQueue que;
    int rear = 0,head = 0;
    int w;

    visit(u);
    visited[u] = 1;
    que.data[rear++] = u;
    while(head < rear){
        int k = que.data[head++];
        for(w = ALGFirstNeighbor(G,k);w >= 0;w = ALGNextNeighbor(G,k,w)){
            if(!visited[w]){
                visit(w);
                visited[w] = 1;
                que.data[rear++] = w;
            }
        }
    }
}

void ALGDFSTraverse(ALGraph G){
    int i;
    for(i = 1;i <= G.vexNum;i++){
        if(!visited[i]){
            ALGDFS(G,i);
        }
    }
}

void ALGDFS(ALGraph G,int u){
    int w;

    visit(u);
    visited[u] = 1;
    for(w = ALGFirstNeighbor(G,u);w >= 0;w = ALGNextNeighbor(G,u,w)){
        if(!visited[w]){
            ALGDFS(G,w);
        }
    }
}

int ALGFirstNeighbor(ALGraph G,int k){

    if(G.verticies[k].first != NULL){
        return G.verticies[k].first->adjvex;
    }

    return -1;
}

int ALGNextNeighbor(ALGraph G,int k,int w){
    ArcNode *p;
    if(k != -1){
        p = G.verticies[k].first;
        while(p != NULL && p->adjvex != w){
            p = p->next;
        }

        if(p != NULL && p->next != NULL){
            return p->next->adjvex;
        }

    }

    return -1;

}

void Dijkstra(MGraph G,int u,int path[],int dist[]){
    int i,j,k,mini,t;
    int s[MaxNum];

    for(i = 1;i <= G.vexNum;i++){
        s[i] = 0;
        dist[i] = G.edge[u][i];
        if(dist[i] < 1e9){
            path[i] = u;
        }else{
            path[i] = -1;
        }
    }
    s[u] = 1;
    path[u] = -1;

    for(i = 1;i <= G.vexNum;i++){
        mini = 1e9;
        for(j = 1;j <= G.vexNum;j++){
            if(s[j] == 0 && dist[j] < mini){
                t = j;
                mini = dist[j];
            }
        }

        s[t] = 1;
        for(k = 1;k <= G.vexNum;k++){
            if(s[k] == 0 && dist[t] + G.edge[t][k] < dist[k]){
                dist[k] = dist[t] + G.edge[t][k];
                path[k] = t;
            }
        }
    }
}

void printPath(int v){
    if(path[v] != -1){
        printPath(path[v]);
    }
    printf("%d ",v);
}

//SPFA单源最短路，权值可为负
void SPFA(MGraph G,int u,int paht[],int dist[]){
    int i;
    SqQueue que;
    int rear = 0,head = 0;

    for(i = 1;i <= G.vexNum;i++){
        dist[i] = 1e9;
        path[i] = -1;
    }

    dist[u] = 0;
    visited[u] = 1;
    que.data[rear++] = u;

    while(head < rear){
        int k = que.data[head++];
        visited[k] = 0; //释放对k的标记，可以重新入队
        for(int w = MGFirstNeighbor(G,k);w >= 0;w = MGNextNeighbor(G,k,w)){
            if(dist[k] + G.edge[k][w] < dist[w]){   //原理：三角形两边之和大于第三边
                dist[w] = dist[k] + G.edge[k][w];
                path[w] = k;
            }
            if(!visited[w]){
                que.data[rear++] = w;
                visited[w] = 1;
            }
        }
    }
}

//Floyd求全局最短路
void Floyd(MGraph G){
    int i,j,k;
    for(i = 1;i <= G.vexNum;i++){
        for(j = 1;j <= G.vexNum;j++){
            if(i == j)
                mp[i][j] = 0;
            else mp[i][j] = G.edge[i][j];
        }
    }

    for(k = 1;k <= G.vexNum;k++){
        for(i = 1;i <= G.vexNum;i++){
            for(j = 1;j <= G.vexNum;j++){
                mp[i][j] = min(mp[i][j],mp[i][k]+mp[k][j]);
            }
        }
    }
}

下面是各个算法的输入样例，顶点编号都从1开始。

//邻接矩阵的BFS输入样例（2019王道200页第8题图）
//第一行两个数字，分别表示结点数N和边数M
//下面M行表示结点间的连通性，每行由3个数组成
//1 2 1表示从顶点1到顶点2之间有权值为1的路径
6 8
1 2 1
1 4 1
2 5 1
3 5 1
3 6 1
4 2 1
5 4 1
6 6 1
输出结果：1 2 4 5 3 6

//邻接表的BFS输入样例（2019王道200页第8题图）
//第一行的两个数字，分别表示结点数N和边数M
//下面M行表示结点间的连通性
//PS：此处的邻接表的结构体无法存储权值信息
6 8
1 2
1 4
2 5
3 5
3 6
4 2
5 4
6 6
输出结果：1 2 4 5 3 6


//邻接矩阵的DFS输入样例（2019王道200页第8题图）
//第一行两个数字，分别表示结点数N和边数M
//下面M行表示结点间的连通性
6 8
1 2 1
1 4 1
2 5 1
3 5 1
3 6 1
4 2 1
5 4 1
6 6 1
输出结果：1 2 5 4 3 6

//邻接表的DFS输入样例（2019王道200页第8题图）
//第一行两个数字，分别表示结点数N和边数M
//下面M行表示结点间的连通性
6 8
1 2
1 4
2 5
3 5
3 6
4 2
5 4
6 6
输出结果：1 2 5 4 3 6

求最短路的算法，Dijkstra, spfa, floyd用的都是邻接矩阵，方便处理

//Dijkstra、spfa和floyd的输入样例（2019王道210页图5-22）
//第一行两个数字，分别表示结点数N和边数M
//接下来有M行，每行三个数字，分别表示第一个结点，第二个结点，权值
//例如 1 2 10表示结点1到结点2之间的权值是10
//若是无权图，将权值全部赋值为1即可
5 10
1 2 10
1 5 5
2 3 1
2 5 2
3 4 4
4 1 7
4 3 6
5 2 3
5 3 9
5 4 2

请输入起点和终点，以空格隔开
1 3
输出结果：1 5 2 3
卖篇论文娶媳妇
关注
  • 3
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法与数据结构（c语言）——图（Figure，一）
掉了根毛的博客
02-24 685
首先是基本的一些概念，上个图先： 图的定义 图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V(vertex)是图G中顶点的集合，E(edge)是图G中边的集合。 有向边：若从顶点vi到vj的边有方向，则称这条边为有向边。也称为弧(Arc)。用有序偶<vi,vj>来表示，vi称为弧尾（Tail）,vj称为弧头（He...
数据结构与算法——图
Areay_GK的博客
02-19 3757
图 在图中，节点之间的关系是任意的，任意两个节点之间都可能有关系 图的术语巨多无比，接下来给大家总结一下： 图分为有向图、无向图，无向图由定点和边组成，有向图有顶点和弧组成，弧分为弧头、弧尾。 图按照节点和边（弧）的多少分为，稀疏图、稠密图，这两者没有具体界定只是个人感觉概念。任意两个顶点之间都存在边就叫完全图，有向的叫有向完全图，无重复的边或者顶点到自身的边叫简单图。 顶点之间有邻
数据结构--图总结（八大算法）
qq_41409979的博客
05-12 2336
图总结 本章主要讲诉一些图的经典算法以及容易忘记的概念便于以后进行复习。 文章目录图总结一、易混淆的概念二、经典算法1.DFS与BFS2.读入数据总结 一、易混淆的概念 边，弧：顶点到顶点之间有向叫做边，无向叫做弧。 完全图,连通图：任意两个顶点之间都有边是完全图，任意两个顶点之间存在路劲是连通图（如果是有向的话叫强连通图）。 生成树,有向树,生成深林：无向联通图中如果只有n个顶点n-1条边（没有环）叫生成树，有向图中只有一个顶点入度为0，其余顶点入度为1叫做有向树。一个有向图由若干个有向树构成生成深林
数据结构算法--图详解
jy18817386398的博客
01-15 1105
图G由顶点集合V和边集合E组成，记为。：有向图和无向图。，如果，则G’为G的子图。：n(n - 1)条边的有向图。：n(n - 1) / 2条边的无向图。：图的每条边带有权值。：无向图，一条边的两点互为邻接点。：顶点v到顶点v'的边的权值和为路径长度。：无向图G，如果顶点v到顶点v'存在路径，则两顶点连通。G是一个连通图， G中的极大连通子图为连通分量。：有向图G，如果顶点v到顶点v'存在路径，则两顶点强连通。强连通图只有一个连通分量。
2024年大话数据结构--数据结构概述
最新发布
2401_84164721的博客
05-02 1053
抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关。听概念的确不太好理解，前期可以先学着，到后面慢慢用到的时候会有好的理解！
【数据结构与算法】图论及其相关算法
十八岁讨厌编程的博客
05-27 3596
本文涉及图的基本介绍、表示方法、DFS、BFS、解决最小生成树的算法、解决最短路径的算法等内容。
数据结构——图的应用算法详解
ZhangJiawen的博客
10-13 2027
这篇博客重点讲解一下图中几个算法的具体计算过程。 应用 算法 适用的图 备注 最小生成树 Prim 无向图 适合稠密图 最小生成树 Kruskal 无向图 适合稀疏图 最短路径 Dijkstra 有向图 单源点最短路径 最短路径 Floyd 有向图 每一对顶点之间的最短路径 拓扑排序 / 有向无环，AOV网 关键路径 / 有向无环加权，AOE网 1. 最小生成树（MST） 对于一个带权连通无向图，生成树不同，每棵树的权也可能不同。其中权值之和最小的那棵树称为最
数据结构：图(Graph)【详解】
热门推荐
UniqueUnit的博客
03-03 19万+
图 【知识框架】 【考纲内容】 图的基本概念 图的存储及基本操作 邻接矩阵法;邻接表法;邻接多重表;十字链表 图的遍历 深度优先搜索;广度优先搜索 图的基本应用 最小(代价)生成树;最短路径;拓扑排序;关键路径 图的基本概念 在线性表中，数据元素之间是被串起来的，仅有线性关系，每个数据元素只有一个直接前驱和一个直接后继。在树形结构中，数据元素之间有着明显的层次关系，并且每一层上的数据元素可能和下一层中多个元素相关，但只能和上一层中一个元素相关。图是一种较线性表和树更加复杂的数据结构。
Python——数据结构入门算法篇①（冒泡排序）
01-20
排序：不同地点出发最后达到相同的目的，简述为：将一串数据依照特定顺序进行排列的一种算法 冒泡排序（Bubble Sort），有时也称为下沉排序，是一种简单的排序算法，它反复遍历要排序的列表，比较每对相邻的项目，...
数据结构与算法课程的入门教学范例——迷宫问题.pdf
08-07
#资源达人分享计划#
刘汝佳《算法竞赛入门经典——训练指南》源代码
01-26
《算法竞赛入门经典——训练指南》是刘汝佳编著的一本面向算法竞赛初学者的指导书籍，旨在帮助读者快速掌握算法基础知识并提升解决实际问题的能力。这本书涵盖了许多经典的算法和数据结构，如排序、搜索、图论和动态...
数据结构经典算法代码实现
03-18
迪杰斯特拉算法求两点之间最短路径 堆排序 队列的循环和链式存储 二叉树及输出 广度优先搜索 赫夫曼编码 深度优先搜素 图的数组表示及普利姆算法 稀疏矩阵(三元组)及其转置 稀疏矩阵的十字链表 线索二叉树
图的基本算法实现,最小生成树算法（数据结构）
05-30
确定顶点u在G中的位置；建立链接矩阵；队列初始化；确定顶点u在头结点向量中的位置；建立链接表；整个图深度优先遍历；整个图广度优先遍历；构造最小生成树；
算法竞赛入门经典——算法实现.docx
09-13
"算法竞赛入门经典——算法实现" 在信息时代，算法被誉为“程序的灵魂”，它决定了程序的行为和性能。而算法竞赛则是一种衡量算法设计和实现能力的有效方式。那么，什么是算法竞赛？它的意义又是什么呢？ 算法竞赛...
《图解HTTP 彩色版》_continent69b_入门_算法_数据结构_
10-01
在数据结构方面，虽然标题并未直接提及，但描述中提到本书是“一本有关数据结构的好书”，这表明书中可能穿插了一些数据结构的知识。数据结构是计算机科学中的重要概念，它涉及如何在内存中组织和管理数据，以提高...
数据结构中关于图以及相关算法的总结
二哈
06-13 1214
1. 首先我们需要清楚的是有关图的相关概念，定义和相关术语，比如顶点的度、入度、初度、弧、有向完全图和无向完全图、路径和路径长度、简单路径、回路连通、连通图和连通分量、强连通图和强连通分量、权和网 ① 简单路径：序列中顶点不重复的路径称为简单路径 ② 连通图：如果图中任意两个顶点之间都连通那么称该图为连通图 ③ 无向图中的极大连通子图称为连通分量 ④ 强连通图：在有向图中如果对于每一对顶点...
数据结构-关于图以及一些算法
weixin_62697030的博客
08-17 314
/这里几个注意事项,node中的a,代表的是"终点的序号",链表只是为了储存数据,而不是由数据拼成链表.4.边际数组,用数组来储存边的信息,贝尔曼福特算法就是用这个实现的。2.接邻表,类似二叉树中的孩子表示法,链表＋数组的结合模式。1.接邻矩阵,这是最简单的一种,原理其实就是二维矩阵。(ps一些算法可能在前面的博客写完了,请移步)3.十字链表,接邻表的拓展,不常用。2.广度优先遍历BFS;.........
数据结构-图的基础代码
IT1995的博客
12-17 8846
数据结构-图的基础代码
【数据结构】图的快速入门
baidu_33146219的博客
08-18 289
本文主要介绍了图的基本概念、表示方式和快速入门案例。
算法分析：灵魂与核心——数据结构与高效算法
书中强调了数据结构+算法对于程序设计的重要性，并涵盖了一般算法、数据结构入门、动态规划、状态空间搜索等主题。此外，还讨论了算法的组成、表示方式以及如何根据问题规模选择合适的算法。" 正文: 在编程领域，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值