C++图论基础--图的两种表示实现及迭代

最新推荐文章于 2024-07-10 20:24:45 发布
最新推荐文章于 2024-07-10 20:24:45 发布
阅读量920 收藏 3
点赞数
分类专栏： 算法与数据结构 C/C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39276337/article/details/123605414
版权

邻接矩阵存在的问题

如果我们的每一个顶点所连接的顶点只是周围的几个点， 那么形成的图是一个稀疏图，而我们生活中研究的大多数问题都是稀疏图问题， 比我我们研究的导航路径问题就是一个典型的稀疏图

邻接表

使用邻接矩阵方式实现一个稠密图

DenseGraph.cpp

#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
// 使用邻接矩阵方式实现一个稠密图
class DenseGraph{
private:
    int n, m;// 节点数和边数
    bool directed; // 是否为有向图
    vector<vector<bool>> g; // 图的具体数据
public:
    // 构造函数
    DenseGraph(int n, bool directed){
        assert(n >=0);
        this->n = n;
        this->m = 0;  // 初始化没有任何边
        this->directed = directed;
        // g初始化为n*n的布尔矩阵, 每一个g[i][j]均为false, 表示没有任和边
        g =  vector<vector<bool>>(n, vector<bool>(n, false));
    }
    ~DenseGraph(){};
    int V(){return n;}  // 返回节点个数
    int E(){return m;}  // 返回边的个数
    // 向图中添加一个边
    void addEdge(int v, int w){
        assert(v >=0 && v < n);
        assert(w >=0 && w < n);
        if (hasEdge(v, w))
            return;
        g[v][w] = true;
        if (!directed)
            g[w][v] = true;
        m++;
    }

    // 验证图中是否有从v到w的边
    bool hasEdge(int v, int w){
        assert(v >=0 && v < n);
        assert(w >=0 && w < n);
        return g[v][w];
    }
};
int main (){
     DenseGraph graph1(1, 1);
     DenseGraph graph2(3, 1);
    return 0;
}

使用邻接表方式实现一个稀疏图

#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
// 使用邻接表方式实现一个稀疏图
class SparseGraph{
private:
    int n, m;// 节点数和边数
    bool directed; // 是否为有向图
    vector<vector<int>> g; // 图的具体数据
public:
    // 构造函数
    SparseGraph(int n, bool directed){
        assert(n >=0);
        this->n = n;
        this->m = 0;  // 初始化没有任何边
        this->directed = directed;
        // g初始化为n*n的布尔矩阵, 每一个g[i][j]均为false, 表示没有任和边
        g =  vector<vector<int>>(n, vector<int>());
    }
    ~SparseGraph(){};
    int V(){return n;}  // 返回节点个数
    int E(){return m;}  // 返回边的个数
    // 向图中添加一个边
    void addEdge(int v, int w){
        assert(v >=0 && v < n);
        assert(w >=0 && w < n);
        g[v].push_back(w);
        if (v != w && !directed)
            g[w].push_back(v);
        m++;
    }

    // 验证图中是否有从v到w的边
    bool hasEdge(int v, int w){
        assert(v >=0 && v < n);
        assert(w >=0 && w < n);
        for (int i = 0; i < g[v].size(); i++) {
            if (g[v][i] == w)
                return true;
        }
        return false;
    }
};
int main (){
    SparseGraph graph1(1, 1);
    SparseGraph graph2(3, 1);
    return 0;
}

通过迭代器实现邻接表方式和邻接矩阵方式迭代(遍历)统一接口

vector的迭代器

#include <iostream>
#include <vector>
using namespace std;
int main (){
    // STL
    vector<int> v;
    for (int i = 0; i < 5; i++) {
        v.push_back(i);
    }
    // 1 遍历;
    for (int i = 0; i < v.size(); i++) {
        cout<< v[i] <<", ";
    }
    cout <<endl;
    // 2 迭代器
    for (vector<int>::iterator it = v.begin(); it != v.end() ;it++) {
        cout<< *it <<endl;
    }
    return 0;
}

邻接表的方式实现迭代并测试

#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
// 使用邻接表方式实现一个稀疏图
class SparseGraph{
private:
    int n, m;// 节点数和边数
    bool directed; // 是否为有向图
    vector<vector<int>> g; // 图的具体数据
public:
    // 构造函数
    SparseGraph(int n, bool directed){
        assert(n >=0);
        this->n = n;
        this->m = 0;  // 初始化没有任何边
        this->directed = directed;
        // g初始化为n*n的布尔矩阵, 每一个g[i][j]均为false, 表示没有任和边
        g =  vector<vector<int>>(n, vector<int>());
    }
    ~SparseGraph(){};
    int V(){return n;}  // 返回节点个数
    int E(){return m;}  // 返回边的个数
    // 向图中添加一个边
    void addEdge(int v, int w){
        assert(v >=0 && v < n);
        assert(w >=0 && w < n);
        if (hasEdge(v, w))
            return;
        g[v].push_back(w);
        if (v != w && !directed)
            g[w].push_back(v);
        m++;
    }

    // 验证图中是否有从v到w的边
    bool hasEdge(int v, int w){
        assert(v >=0 && v < n);
        assert(w >=0 && w < n);
        for (int i = 0; i < g[v].size(); i++) {
            if (g[v][i] == w)
                return true;
        }
        return false;
    }

    // 邻边迭代器, 传入一个图和一个顶点,
    // 迭代在这个图中和这个顶点向连的所有顶点
    class adjIterator{
    private:
        SparseGraph &G; // 图G的引用
        int v; // 顶点数
        int index; // 表示索引
    public:
        // 构造函数
        adjIterator(SparseGraph &graph, int v): G(graph){
            this->v = v;
            this->index = 0;
        }
        ~adjIterator(){}
        // 返回图G中与顶点v相连接的第一个顶点
        int begin(){
            index = 0;
            if (G.g[v].size())
                return  G.g[v][index];
            // 若没有顶点和v相连接, 则返回-1
            return -1;
        }
        int next(){
            index++;
            if (index < G.g[v].size())
                return  G.g[v][index];
            // 若没有顶点和v相连接, 则返回-1
            return -1;
        }
        //查看是否已经迭代完了图G中与顶点v相连接的所有顶点
        bool end(){
            return index >= G.g[v].size();
        }
    };
};
int main (){
    int N = 20, M = 100;  // 20个顶点 100个边
    SparseGraph graph(N, false);
    for (int i = 0; i < M; i++) {
        int a = rand()%N;
        int b = rand()%N;
        graph.addEdge(a, b);
    }
    // 遍历
    for (int v = 0; v < N; v++) {
        cout<< v << " : ";
        SparseGraph::adjIterator adj(graph, v);
        for (int w = adj.begin(); !adj.end(); w = adj.next()) {
            cout<< w <<" ";
        }
        cout<<endl;

    }
    return 0;
}

在这里插入图片描述

邻接矩阵的方式实现迭代并测试


#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
// 使用邻接矩阵方式实现一个稠密图
class DenseGraph{
private:
    int n, m;// 节点数和边数
    bool directed; // 是否为有向图
    vector<vector<bool>> g; // 图的具体数据
public:
    // 构造函数
    DenseGraph(int n, bool directed){
        assert(n >=0);
        this->n = n;
        this->m = 0;  // 初始化没有任何边
        this->directed = directed;
        // g初始化为n*n的布尔矩阵, 每一个g[i][j]均为false, 表示没有任和边
        g =  vector<vector<bool>>(n, vector<bool>(n, false));
    }
    ~DenseGraph(){};
    int V(){return n;}  // 返回节点个数
    int E(){return m;}  // 返回边的个数
    // 向图中添加一个边
    void addEdge(int v, int w){
        assert(v >=0 && v < n);
        assert(w >=0 && w < n);
        if (hasEdge(v, w))
            return;
        g[v][w] = true;
        if (!directed)
            g[w][v] = true;
        m++;
    }

    // 验证图中是否有从v到w的边
    bool hasEdge(int v, int w){
        assert(v >=0 && v < n);
        assert(w >=0 && w < n);
        return g[v][w];
    }

    // 邻边迭代器, 传入一个图和一个顶点,
    // 迭代在这个图中和这个顶点向连的所有顶点
    class adjIterator{
    private:
        DenseGraph &G; // 图G的引用
        int v; // 顶点数
        int index; // 表示索引
    public:
        // 构造函数
        adjIterator(DenseGraph &graph, int v): G(graph){
            this->v = v;
            this->index = -1;
        }
        // 返回图G中与顶点v相连接的第一个顶点
        int begin(){
            // 索引从-1开始, 因为每次遍历都需要调用一次next()
            index = -1;
            return next();
        }
        // 返回图G中与顶点v相连接的下一个顶点
        int next(){
            // 从当前index开始向后搜索, 直到找到一个g[v][index]为true
            for (index += 1; index < G.V(); index++) {
                if (G.g[v][index])
                    return index;
            }
            return -1;
        }
        //查看是否已经迭代完了图G中与顶点v相连接的所有顶点
        bool end(){
            return index >= G.V();
        }
    };
};
int main (){
    int N = 20, M = 100;  // 20个顶点 100个边
    DenseGraph graph(N, false);
    for (int i = 0; i < M; i++) {
        int a = rand()%N;
        int b = rand()%N;
        graph.addEdge(a, b);
    }
    // 遍历  On^2
    for (int v = 0; v < N; v++) {
        cout<< v << " : ";
        DenseGraph::adjIterator adj(graph, v);
        for (int w = adj.begin(); !adj.end(); w = adj.next()) {
            cout<< w <<" ";
        }
        cout<<endl;

    }

    return 0;
}

在这里插入图片描述

我们可以看出邻接矩阵迭代的时间赋值读为On^2 而 邻接表为 On

__Miracle__
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++图论
PanDaoxi
12-26 475
C++图论！
图的遍历——DFS与BFS
qq_28053699的博客
04-03 250
图的遍历 图的遍历(Traversing Grapb)(Traversing\ Grapb )(Traversing Grapb)：从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次，这一过程就叫做图的遍历 。 无向图的邻接矩阵储存结构代码 class Undirected_Graph_Matrix(object): #Adjacency Matrix de...
BFS和DFS模板
Black—Horse的专栏
12-31 3327
#include #define N 100 /**DFS深度优先搜索是从图中的某个顶点出发，先访问初始点，然后访问其邻接点u（没有被访问过，下同）， 再访问u的邻接点，一直到深入访问*/ //邻接表结构 typedef struct Anode { int adj; //终点位置 struct Anode *next;//下一条边 }ArcNode; typedef struct { A
c++基础算法（认识图论）
最新发布
sjzwer_的博客
07-10 851
图论是数学中的一个分支，研究图的性质和图的相关问题。图是由节点和连接节点的边组成的结构，节点表示对象，边表示对象之间的关系。
数据结构——图的遍历（dfs和bfs）
qq_52115728的博客
12-13 437
#include<iostream> using namespace std; const int N = 1000; //图的遍历 int visit[N]; int edge[N][N]; int v[N]; int n,e,x,y; void dfs(int num) { cout<<v[num]; visit[num]=1; for(int i=1;i<=n;i++) { if(edge[num][i]==1&&
搜索：图的遍历DFS\BFS
youshengjier的博客
05-05 272
P5318 【深基18.例3】查找文献 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) 图的存储：邻接表—稀疏图、邻接矩阵—稠密图 int n,m;//结点数 边数 const int N=100010; //邻接表 vector<int>G[N]; //标记数组 bool mark[N]; //队列 queue<int>q; /* 邻接表： 0-> 1->2 3 4 2->5 6 3->7 4->7 8 5-> 6
在c++编程语言- AllAlgorithms/cpp中实现所有算法
01-27
在C++编程语言中，实现各种算法是一项基本且重要的技能，因为算法是解决问题的核心。AllAlgorithms/cpp项目致力于提供一个全面的C++算法库，它覆盖了数据结构和算法的多个方面，对于学习和实践C++编程以及提高算法...
c++-c++编程基础之leetcode题解第70题爬楼梯.zip
04-16
本压缩包文件“c++-c++编程基础之leetcode题解第70题爬楼梯.zip”显然是针对LeetCode的第70题——"Climbing Stairs"（爬楼梯）的解决方案。这道题目属于动态规划问题，是C++初学者到进阶者常常会遇到的经典算法题。 ...
最短路径算法实现 k-shortest-paths之c++源码
05-14
这两个文件包含了Dijkstra算法的实现，可能是作为计算单个最短路径的基础。 3. **YenTopKShortestPathsAlg.cpp/h**: Yen算法是在找到一条最短路径后，寻找额外的k-1条路径的优化算法。它基于迭代过程，每次迭代中，...
图论算法(C++版).ppt
01-13
图论是计算机科学中一种重要的理论基础，它研究如何用图来抽象和解决实际问题。在C++中，实现图论算法通常涉及到数据结构的选择和特定的编程技巧。以下是关于图论及其C++实现的关键知识点： 1. **图的基本概念**： ...
蓝桥杯c++-蓝桥杯竞赛练习之算法提高题交换Easy.zip
04-12
- "c++"：这表示涉及的知识点主要为C++编程语言，包括语法、数据类型、控制结构、函数、类等。 - "蓝桥杯"：这是一个重要的编程竞赛，参赛者需要熟悉算法和数据结构，并能快速解决问题。 - "算法"：说明了资源的核心...
图论基础_C++_学习_C++图论_图论方法c++_
10-02
c++入门——图论基础，带标程，带习题，赶紧下载吧
c++图论
setprecisiona的博客
11-06 1562
图论
最小生成树
evsqiezi
10-23 408
prim算法简单描述 1).输入：一个加权连通图，其中顶点集合为V，边集合为E； 2).初始化：Vnew = {x}，其中x为集合V中的任一节点（起始点），Enew = {},为空； 3).重复下列操作，直到Vnew = V： a.在集合E中选取权值最小的边，其中u为集合Vnew中的元素，而v不在Vnew集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之
C++ 图论（写到手软）
weixin_66767924的博客
10-04 1171
图由点和边组成的。有向图、有向边，是有方向的。度是一点所关联的边数。出度有向图中，从一个点出去的边数；入度有向图中，从一个点进来的边数。自环，邪恶的东西，能寄掉一些算法，需要特殊处理，一条边两端连着同一个点。路径，从一个点走到另一个点（可含环）；简单路径，就是不含环的路径。环，从一点出发在绕回这个点的路径有向无环图（DAG），若设动态规划状态为点，转移为为边，这一定是DAG。需要用邻接接矩阵。表示从 j 走到 k 经过的点的编号小于等于 i 的最短路。通过一个点，将周围所有点最短路变短。
C++图论（第二弹）
PanDaoxi
01-02 715
元旦快乐呀！ 祝大家2022心想事成、工作顺利！ 今天我们继续来学习图论，和弗洛伊德算法。
图的广度优先遍历
jiutianmuzi的博客
09-14 835
图的bfs和树的bfs类似。与树不同图可能包含环，所以可能再次访问同一顶点。为了避免访问同一顶点多次，我们用一个布尔数组标志顶点是否被访问过。为了简化，我们假定从起始顶点可达所有顶点。 如下图，我们从顶点2开始遍历。当我们遍历到顶点0，查找他的所有相邻顶点。2也是0的一个相邻顶点。如果不标记访问过得顶点，那么顶点2将被再次处理，遍历将变得不可终止。下图的广度优先遍历的结果为2,0,3,1。 下面是广度优先遍历的一个简单实现。图用邻接表表示。List用来存储相邻节点，广度优先遍历需要一个队列。 packag
C/C++算法实现：数论与图论算法详解
文档提供了两种求解方法，分别是欧几里得算法（用于GCD）和迭代方法（用于LCM）。 - 素数判断：素数是大于1且只有1和其本身两个正因数的自然数。文档分别给出了小范围判断和大范围求素数表的方法。小范围判断采用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值