图的基础(C++)

最新推荐文章于 2024-07-23 16:25:03 发布
最新推荐文章于 2024-07-23 16:25:03 发布
阅读量1.4k 收藏
点赞数 2
分类专栏： c++ ——— 图算法 ——— C++ 学习 文章标签： c++ 图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013486414/article/details/62237646
版权

DenseGraph.h

#ifndef DENSEGRAPH_H_INCLUDED
#define DENSEGRAPH_H_INCLUDED

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cassert>
#include <ctime>

using namespace std;

//稠密图-邻接矩阵
class DenseGraph{
private:
    int n,m;//点和边
    bool directed;//有向无向
    vector<vector<bool> >g;
public:
    DenseGraph(int n,bool directed){
        this->n=n;
        this->m=0;
        this->directed=directed;
        for(int i=0;i<n;i++){
            g.push_back(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++;
    }

    bool hasEdge(int v,int w){
        assert(v>=0&&v<n);
        assert(w>=0&&w<n);
        return g[v][w];
    }

    void show(){
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++)
                cout<<g[i][j]<<"\t";
            cout<<endl;
        }
    }

    class adjIterator{//相邻边的迭代器
    private:
        DenseGraph &G;
        int v;
        int index;//指示当前迭代到的位置
    public:
        adjIterator(DenseGraph &graph,int v):G(graph){//迭代的是哪个图的哪个点相邻的边
            this->v=v;
            this->index=-1;
        }

        int begin(){//要迭代的第一个元素
           index=-1;//不见得第一个就是，而是应该找第一个为ture的元素
           return next();
        }

        int next(){//从当前迭代的元素偏移，找下一个元素
            for(index+=1;index<G.V();index++)
                if(G.g[v][index])
                return index;
            return -1;
        }

        bool end(){//观察迭代是否终止
            return index>=G.V();
        }
    };
};
/*
//稠密图遍历
int main()
{
    int N=20;
    int M=100;
    DenseGraph g(N,false);
    for(int i=0;i<M;i++){
        int a=rand()%N;
        int b=rand()%N;
        g.addEdge(a,b);
    }

    //O(V^2)
    for(int v=0;v<N;v++){
        cout<<v<<" : ";
        DenseGraph::adjIterator adj(g,v);
        for(int w=adj.begin();!adj.end();w=adj.next())
            cout<<w<<" ";
        cout<<endl;
    }
    return 0;
}

*/
#endif // DENSEGRAPH_H_INCLUDED

SparseGraph.h

#ifndef SPARSEGRAPH_H_INCLUDED
#define SPARSEGRAPH_H_INCLUDED

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cassert>
#include <ctime>

using namespace std;

//稀疏图-邻接表
class SparseGraph{
private:
    int n,m;
    bool directed;
    vector<vector<int> >g;

public:
    SparseGraph(int n,bool directed){
        this->n=n;
        this->m=0;
        this->directed=directed;
        for(int i=0;i<n;i++){
            g.push_back(vector<int >());
        }
    }

    ~SparseGraph(){

    }

    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++;
    }

    bool hasEdge(int v,int w){//最坏O(n)
        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;
        }
    }

    void show(){
        for(int i=0;i<n;i++){
            cout<<"vertex"<<i<<":\t";
            for(int j=0;j<g[i].size();j++)
                cout<<g[i][j]<<"\t";
            cout<<endl;
        }
    }

    class adjIterator{//相邻边的迭代器
    private:
        SparseGraph &G;
        int v;
        int index;//指示当前迭代到的位置
    public:
        adjIterator(SparseGraph &graph,int v):G(graph){//迭代的是哪个图的哪个点相邻的边
            this->v=v;
            this->index=0;
        }

        int begin(){//要迭代的第一个元素
            index=0;
            if(G.g[v].size())
                return G.g[v][index];
            return -1;
        }

        int next(){//从当前迭代的元素偏移，找下一个元素
            index++;
            if(index<G.g[v].size())
                return G.g[v][index];
            return -1;
        }

        bool end(){//观察迭代是否终止
            return index>=G.g[v].size();
        }
    };
};

/*

//稀疏图遍历
int main()
{
    int N=20;
    int M=100;
    srand(time(NULL));

    SparseGraph g1(N,false);
    for(int i=0;i<M;i++){
        int a=rand()%N;
        int b=rand()%N;
        g1.addEdge(a,b);
    }

    //O(E)
    for(int v=0;v<N;v++){
        cout<<v<<" : ";
        SparseGraph::adjIterator adj(g1,v);
        for(int w=adj.begin();!adj.end();w=adj.next())
            cout<<w<<" ";
        cout<<endl;
    }
    cout<<endl;
    return 0;

}
*/


#endif // SPARSEGRAPH_H_INCLUDED

ReadGraph.h

#ifndef READGRAPH_H_INCLUDED
#define READGRAPH_H_INCLUDED

//C++文件读取
//可同时作用在稀疏图和稠密图上
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <cassert>

using namespace std;

template <typename Graph>
class ReadGraph{

public:
    ReadGraph(Graph &graph,const string &filename){
        ifstream  file ( filename );
        string line;
        int V,E;

        assert(file.is_open());

        assert(getline(file,line));
        stringstream ss(line);
        ss>>V>>E;

        for(int i=0;i<E;i++){

            assert(getline(file,line));
            stringstream ss(line);

            int a,b;
            ss>>a>>b;//把ss中的内容赋给a,b
            assert(a>=0&&a<V);
            assert(b>=0&&b<V);
            graph.addEdge(a,b);
        }

    }
};
/*
int main()
{
    string filename= "testG1.txt";
    SparseGraph g1(13,false);
    ReadGraph<SparseGraph> readGraph1(g1,filename);
    g1.show();
    cout<<endl;

    DenseGraph g2(13,false);
    ReadGraph<DenseGraph> readGraph2(g2,filename);
    g2.show();

    return 0;
}
*/
#endif

Component.h

#ifndef COMPONENT_H_INCLUDED
#define COMPONENT_H_INCLUDED
#include <iostream>
#include <cassert>
using namespace std;

template <typename Graph>
class Component{
private:
    Graph &G;
    bool *visited;
    int ccount;
    int *id;

    void dfs(int v){
        visited[v]=true;
        id[v]=ccount;
        typename Graph::adjInterator adj(G,v);
        for(int i=adj.begin();!adj.end();i=adj.next()){
            if(!visited[i])
                dfs(i);
        }
    }
public:
    Component(Graph &graph):G(graph){
        visited=new bool[G.V()];
        id=new int[G.V()];
        ccount=0;
        for(int i=0;i<G.V();i++){
             visited[i]=false;
             id[i]=-1;
        }

            for(int i=0;i<G.V();i++)
            if(!visited[i]){
                dfs(i);
                ccount++;
            }
    }

    ~Component(){
        delete[] visited;
        delete[] id;
    }

    int count(){
        return ccount;
    }

    bool isConnected(int v,int w){
        assert(v>=0&&v<G.V());
        assert(w>=0&&w<G.V());
        return id[v]==id[w];
    }
};


#endif // COMPONENT_H_INCLUDED

Path.h

#ifndef PATH_H_INCLUDED
#define PATH_H_INCLUDED

template <typename Graph>
class Path{//寻找图中从一个点到另外一个点的路径
private:
    Graph &G;
    int s;
    bool* visited;
    int* from;//记录访问的当前节点的前一个节点

     void dfs(int v){
        visited[v]=true;
        typename Graph::adjInterator adj(G,v);
        for(int i=adj.begin();!adj.end();i=adj.next()){
            if(!visited[i]){
                from[i]=v;
                dfs(i);
            }
        }
    }
public:
    Path(Graph &graph,int s):G(graph){
        //算法初始化
        assert(s>=0&&s<G.V());
        visited=new bool[G.V()];
        from=new int[G.V()];
        for(int i=0;i<G.V();i++){
            visited[i]=false;
            fron[i]=-1;
        }
        this->s=s;

        //寻路算法
        dfs(s);

    }

    ~Path(){
        delete [] visited;
        delete [] from;
     }

     bool hasPath(int w){//s->w是否有路
        assert(w>=0&&w<G.V());
        return visited[w];
     }

     void path(int w,vector<int >&vec){//s->w的路径
        stack<int >s;
        int p=w;
        while(p!=-1){
            s.push(p);
            p=from(p);
        }

        vec.clear();
        while(!s.empty()){
            vec.push_back(s.top());
            s.pop();
        }
     }

     void showPath(int w){//打印路径
        vector<int >vec;
        path(w,vec);
        for(int i=0;i<vec.size();i++){
            cout<<vec[i];
            if(i==vec.size()-1)
                cout<<endl;
            else
                cout<<" -> ";
        }
     }
};

/*
int main()
{
    string filename="testG2.txt";
    SparseGraph g=SparseGraph(7,false);
    ReadGraph<SparseGraph> readGraph(g,filename);

    Path<SparseGraph>dfs(g,0);
    cout<<"DFS: ";
    dfs.showPath(6);

    return 0;
}
*/
#endif // PATH_H_INCLUDED

ShortestPath.h

#ifndef SHORTESTPATH_H_INCLUDED
#define SHORTESTPATH_H_INCLUDED

template <typename Graph>
class ShortestPath{//bfs求无权图的最短路径

private:
    Graph &G;
    int s;
    bool *visited;
    int *from;
    int *ord;//记录从s到每一个节点的最短距离

public:
    ShortestPath(Graph &graph,int s):G(graph){

        //算法初始化
        assert(s>=0&&s<graph.V());
        visited=new bool[graph.V()];

        from=new int[graph.V()];
        ord=new int[graph.V()];
        for(int i=0;i<graph.V();i++){
            visited[i]=false;
            from[i]=-1;
            ord[i]=-1;
        }
        this->s=s;
        queue<int>q;

        //无向图的最短路径算法
        q.push(s);
        visited[s]=true;
        ord[s]=0;
        while(!q.empty()){
            int v=q.front();
            q.pop();

            typename Graph::adjIterator(G,v);
            for(int i=adj.begin();!adj.end();i=adj.next())
            if(!visited[i]){
                q.push(i);
                visited[i];
                from[i]=v;
                ord[i]=ord[v]+1;
            }
        }
    }

    ~ShortestPath(){
        delete [] visited;
        delete [] from;
        delete [] ord;
    }

    bool hasPath(int w){//s->w是否有路
        assert(w>=0&&w<G.V());
        return visited[w];
     }

     void path(int w,vector<int >&vec){//s->w的路径
        stack<int >s;
        int p=w;
        while(p!=-1){
            s.push(p);
            p=from(p);
        }

        vec.clear();
        while(!s.empty()){
            vec.push_back(s.top());
            s.pop();
        }
     }

     void showPath(int w){//打印路径
        vector<int >vec;
        path(w,vec);
        for(int i=0;i<vec.size();i++){
            cout<<vec[i];
            if(i==vec.size()-1)
                cout<<endl;
            else
                cout<<" -> ";
        }
     }

     int length(int w){
        assert(w>=0&&w<G.V())
        return ord[w];
     }

};

/*
int main()
{
    string filename="testG2.txt";
    SparseGraph g=SparseGraph(7,false);
    ReadGraph<SparseGraph> readGraph(g,filename);

    ShortestPath<SparseGraph>bfs(g,0);
    cout<<"BFS: ";
    bfs.showPath(6);

    return 0;
}
*/
#endif // SHORTESTPATH_H_INCLUDED
Rocky0429
关注
专栏目录
C++ 图基础
牛~
07-17 378
1、分类 无向图 有向图 无权图 有权图 2、简单图 没有自环边与平行边 3、图的表示 邻接矩阵 适合稠密图（完全图） // 稠密图 - 邻接矩阵 class DenseGraph { private: int n, m; bool directed; vector<vector<bool>> g; public: De...
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
图 c++实现
08-13
图，c++实现，可以建立点，插入点，插入向量，并且生成最小生成树
C++知识点总结(51)：图与图的存储
最新发布
joe_g12345的博客
07-23 668
一般情况下，我们会将数据结构分为逻辑结构和物理结构，其中逻辑结构是我们的逻辑下存储的结构，而物理结构是计算机的逻辑下存储的结构。一个图从任意一个顶点可以到另外任意一个顶点（不一定直接联通），则称为。如果在无向图中，任意两个顶点都有一条边直接相连，这时就称该图为。从图中提取出的图（可以是空图、一个顶点、图本身）称作。有些图点和点之间的关系是相互的，这种图被称为。有些图点和点之间的关系是单向的，这种图被称为。图中的边带有某种与之相关的数值，我们称之为。条边的图，其所有顶点的度数之和等于边数的。
图——C++实现
Mind_V的博客
07-25 1万+
基本概念 ​ 图（graph）是用线连接在一起的顶点或节点的集合，即两个要素：边和顶点。每一条边连接个两个顶点，用（i，j）表示顶点为 i 和 j 的边。 ​ 如果用图示来表示一个图，一般用圆圈表示顶点，线段表示边。有方向的边称为有向边，对应的图成为有向图，没有方向的边称为无向边，对应的图叫无向图。对于无向图，边（i， j）和（j，i）是一样的，称顶点 i 和 j 是邻接的，边（i，j
C++之图
zyc2018的博客
06-18 289
#include<iostream> #include<queue> #include<stack> using namespace std; template <class T> class minheap{ // 最小堆类定义 初始化，插入，删除堆顶元素 private: T * heaparray; int currentsiz...
C++【图】
芊樱烛渊的博客
12-22 1017
顶点集合V= {x|x属于某个数据对象集}是有穷非空集合；E = {(x,y)|x,y属于V}或者E = {|x,y属于V && Path(x, y)}是顶点间关系的有穷集合，也叫做边的集合。(x, y)表示x到y的一条双向通路，即(x, y)是无方向的；Path(x, y)表示从x到y的一条单向通路，即Path(x, y)是有方向的。顶点和边：图中结点称为顶点，第i个顶点记作vi。
C++基础入门.pdf
04-10
C++基础入门 C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。 ...
C++数论基础 C++数论基础 C++数论基础.pptx
03-23
这是一套完整的数论学习教材，可供C++数论初学者学习，里面内容丰富，通俗易懂。
C++基础C++基础入门.md
04-10
C++基础C++基础入门.md
零基础C++程序设计
06-19
《零基础C++程序设计》课程旨在为初学者提供一个全面、系统地学习C++编程的平台。C++语言作为一款强大的、通用的编程语言，不仅在学术领域有着广泛的应用，同时也是工业界的重要选择，特别是在游戏开发、系统软件、...
图的C++实现
01-18
利用C++对图进行封装（图类），包括有向图和无向图，提供常用的对图的操作，如：获取图大小、添加节点、打印邻接矩阵、深度遍历和宽度遍历、最小生成树计算（Prim和Kruskal算法）等，并提供了简单的调用示例。
【C++】图
cout0
12-06 1476
主要完成图基本操作的实现，图中顶点的数据类型为char 主要完成下面6个操作： 以邻接矩阵为存储结构，创建有向图 以邻接表为存储结构，创建无向图 在图中查找某个顶点的位置 以邻接矩阵为存储结构，创建有向网 深度遍历图 广度遍历图 使用迪杰斯特拉算法求图中某个顶点到其它顶点的最短路径 #include <iostream> #include <stdlib.h> #inc...
C++ 总结
脚踏实地，仰望星空
11-05 7853
C++ 虽然内容比较多，但是细分下来，可有几大部分组成，每一部分侧重点不同，我在学习过程中按这几大块来理解，发现很有效率，故总结如下。 一、基本语言 C/C++ 声明与定义 C++类型转换 C 指针精要 二、面向过程的编程 函数返回值问题 函数内联 成员函数的重载、覆盖与隐藏 三、STL 四、基于对象的编程 详解C++ friend关键字 详解 C++
C++ 图（邻接矩阵和邻接表结构）
精致的灰的博客
02-20 5215
文章目录图的基本概念图的存储结构邻接矩阵邻接表图的广度优先遍历图的深度优先遍历代码实现最小生成树Kruskal算法Prime算法最短路径 图的基本概念 图的存储结构 因为图中既有节点，又有边(节点与节点之间的关系)，因此，在图的存储中，只需要保存：节点和边关系即可。节点保存比较简单，只需要一段连续空间即可。 其边关系一般采用邻接矩阵或邻接表的方式保存。 邻接矩阵 因为节点与节点之间的关系就是连通与否，即为0或者1，因此邻接矩阵(二维数组)即是：先用一个数组将定点保存，然后采用矩阵来表示节点与
数据结构--图（C++）
m0_49752107的博客
07-30 384
数据结构--图（C++）图的基本概念图结构的存储邻接矩阵邻接矩阵的存储结构创建一个邻接矩阵图邻接表邻接表的存储结构创建一个邻接表十字链表链接多重表图的遍历邻接矩阵的广度优先搜索邻接矩阵的深度优先搜索邻接表的广度优先搜索邻接表的深度优先搜索图的应用最小生成树1.Prim算法2.Kruskal算法最短路径1.Dijkstra算法2.Floyd算法拓扑排序关键路径 图的基本概念 图的定义，图由顶点集V和边集E组成，记为G=(V,E),其中V={v1,v2,v3,……，v（n）}，E={(u,v)|u∈V，v∈V}
数据结构——图（c++）
Passerby_XX的博客
03-09 916
（蒟蒻的第三篇文章，希望dalao勿喷） （希望没问题） 声明： 1.本人变量定义的名称很low 2.本人用的方法也很low 3.但我觉得文章应该不low（盲目自信） 第三篇文章讲讲图的那些事儿 图的定义和概念 图，其实就是在一张纸上（或一个空间内）点上几个点，在将它们用线连接起来，组成的一个图形，就差不多是图，举两个例子： 并且，图也有一些专有名词： 1.有向图：被连通的任意两点只能按规定从一个点到达另一个点，但不能回来 2.无向图：被连通的任意两点可以从一个点到达另一个点，也.
图的遍历 C++
若风
11-22 948
#include #include using namespace std; const int MaxSize = 5; template class MGraph { public: MGraph(T a[], int b[][MaxSize],int n,int e); //构造函数，建立具有n个顶点e条边的图 void dfsTraverse(int v); //深度优先遍
C++语法基础学习指南
“C++语法基础.ppt - 介绍C++编程语言的基础知识，包括数据类型、循环语句、函数、类、继承以及STL。” C++是一种强大的、面向对象的编程语言，由Bjarne Stroustrup博士在20世纪80年代初期发展而成，起初作为C语言...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Rocky0429

一块也是爱

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值