图--图的存储【做题记录】c++

已于 2024-06-06 19:36:42 修改
阅读量594 收藏 18
点赞数 27
文章标签： c++ 算法 开发语言
于 2024-05-10 21:04:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79790771/article/details/138680847
版权

使用邻接矩阵存储无向图

【题目要求】

完成一个无向图的类，实现无向图的的创建和输出。

【输入输出】

第一行输入顶点的个数n

第二行输入n个顶点的信息，为字符型。

第三行输入边的条数m

下面m行输入边的起点下标，终点下标和权值

第一行输出图的顶点信息

第二行输出图的边的信息，边按照起点下标升序排列，边的起点坐标小于终点坐标，输出一次即可。

【测试数据】

输入：

4

A B C D

4

0 1

0 2

2 3

3 0

输出：

图的顶点有：A B C D

图的边有：A-B A-C A-D C-D

【代码】

/**使用邻接矩阵存储图--有向网*/
#include<iostream>
#include<limits.h>
#define MAX_V_NUM 20  //顶点的最大个数
using namespace std;
/**图类*/
template <class T>
class MGraph
{
private:
    T vertex[MAX_V_NUM];//图元素的一维数组
    int arc[MAX_V_NUM][MAX_V_NUM];//图的邻接矩阵，二维数组
    int vexNum, arcNum;//元素个数，边的个数
public:
    MGraph()//构造函数
    {
        cin >> vexNum;
        for (int i = 0; i < vexNum; i++)
        {
            cin >> vertex[i];  //输入图元素的一维数组
        }
        for (int i = 0; i < vexNum; i++)
        {
            for (int j = 0; j < vexNum; j++)
                arc[i][j] = 0;
        }
        cin >> arcNum;
        for (int i = 0; i < arcNum; i++)
        {
            int start, end;
            cin >> start >> end;
            arc[start][end] = 1;
            arc[end][start] = 1;
        }
    }
    
    ~MGraph() {};
    void DFSTraverse(int v);
    void BFSTraverse(int v);
    void printMG()
    {
        cout << "图的顶点有：";
        for (int i = 0; i < vexNum; i++)
            cout << vertex[i] << " ";
        cout << endl;
        cout << "图的边有：";
        for (int i = 0; i < vexNum; i++)
        {
            for (int j = i+1; j < vexNum; j++)
            {
                if (arc[i][j] == 1)
                    cout << vertex[i] << "-" << vertex[j]<<" ";
            }
        }
    }
};


int main()
{
    MGraph<char> graph;
    graph.printMG();
    return 0;
}

无向图的基本计算

【题目要求】

采用邻接矩阵存储有无向图后，如何计算图中有多少条边（不直接读arcNum属性）？输入i、j两个顶点的值（不是下标），判断两个顶点i到j是否有边相连？输入任意一个顶点，输出它的度？

【代码】

 /**使用邻接矩阵存储--无向图*/
#include<iostream>
#include<limits.h>
#define MAX_V_NUM 20  //顶点的最大个数
using namespace std;
/**图类*/
template <class T>
class MGraph
{
private:
    T vertex[MAX_V_NUM];//图元素的一维数组
    int arc[MAX_V_NUM][MAX_V_NUM];//图的邻接矩阵，二维数组
    int vexNum, arcNum;//元素个数，边的个数
public:

    MGraph()
    {
        cin>>vexNum;
        int i,j;
        for(i=0;i<vexNum;i++)
        {
            cin>>vertex[i];//图元素的一维数组
        }
        for(i=0;i<vexNum;i++)
            for(j=0;j<vexNum;j++)
            arc[i][j]=0;//初始化邻接矩阵
        cin>>arcNum;
        for(i=0;i<arcNum;i++)
        {
            int start,endi;
            cin>>start>>endi;
            arc[start][endi]=1;//对称矩阵
            arc[endi][start]=1;
        }
    }
    ~MGraph( ) {};
    void DFSTraverse(int v);
    void BFSTraverse(int v);
    void printMG()
    {
    cout<<"图的顶点有：";
    int i,j;
    for(i=0;i<vexNum;i++)
    {
        cout<<vertex[i]<<" ";
    }
    cout<<endl;
    cout<<"图的边有：";
    for(i=0;i<vexNum;i++)//
    {
        for(j=i+1;j<vexNum;j++)//
        {
            if(arc[i][j]==1)
            {
                cout<<vertex[i]<<"-"<<vertex[j]<<" ";
            }
        }
    }
    cout<<endl;
}
    int computeArcNum();//计算边的条数
    bool isConnected(T v1,T v2);//判断两个顶点是否有边相连
    int getIndex(T vertex);//获得顶点的下标
    int getDegree(T vertex);//求顶点的度

};

template <class T>
/**计算边的条数*/
int MGraph<T>::computeArcNum()
{
    int count=0;
    int i,j;
    for(i=0;i<vexNum;i++)
    {
        for(j=0;j<vexNum;j++)
        {
            if(arc[i][j]==1)
                count++;
        }
    }
    return count/2;
}

template <class T>
/**获取对应值的下标*/
int MGraph<T>::getIndex(T vertex1)
{
    int i;
    for(i=0;i<vexNum;i++)
    {
        if(vertex[i]==vertex1)
        {
            return i;
        }
    }
    return -1;//找不到对应的顶点
}

template <class T>
/** 判断两个顶点是否连接 */
bool MGraph<T>::isConnected(T v1,T v2)
{
    int index1=getIndex(v1);
    int index2=getIndex(v2);
    if(index1==-1||index2==-1)
    {
        return false;//如果有一个顶点不存在，返回false
    }
    return arc[index1][index2]==1;//根据邻接矩阵判断两个顶点是否相连
}

template <class T>
/**求顶点的度*/
int MGraph<T>::getDegree(T vertex)//求度
{
    int i;
    int index=getIndex(vertex);
    if(index==-1)
    {
        return -1;
    }
    int degree=0;
    for(i=0;i<vexNum;i++)
    {
        if(arc[index][i]==1)
        {
            degree++;
        }
    }
    return degree;
}


int main()
{

    MGraph<char> graph;
    //graph.printMG();

    cout<<"The number of edges: "<<graph.computeArcNum()<<endl;
    //cout<<"\n判断顶点是否相连，请输入两个顶点的值：";
    char v1,v2;
    cin>>v1>>v2;
    if(graph.isConnected(v1,v2))
        cout<<v1<<" and "<<v2<<" is connected."<<endl;
    else
        cout<<v1<<" and "<<v2<<" is not connected."<<endl;
    //cout<<"输出顶点的度，输入一个顶点";
    cin>>v1;
    cout<<v1<<" degree: "<<graph.getDegree(v1);
    return 0;
}

使用邻接表存储有向网

vertex：数据域，存放顶点信息。

firsteArc：指针域，指向边表中第一个结点。

adjvex：邻接点域，边的终点在顶点表中的下标。

nextArc：指针域，指向边表中的下一个结点。

边表还可以有权值域weight

【题目要求】

使用邻接表存储一个有向网，输出图的基本信息。构成链表时可以使用头插法

【输入输出】

第一行输入顶点的个数

第二行输入顶点的内容，为字符型

第三行输入边的条数

下面多行输入每条边的起点下标，终点下标和权值。

第一行输出图的顶点。

第二行输出图的边，输出权值。

【测试数据】

输入：

4

0 1 2 3

4

0 1 2

0 2 5

2 3 8

3 0 7

输出：

图的顶点有：0 1 2 3

图的边有：0-2:[5] 0-1:[2] 2-3:[8] 3-0:[7]

【代码】

#include<iostream>
#define  MAX_VERTEX_NUM 20//最大顶点个数
using namespace std;

/**边表的结构体*/
struct ArcNode
{
    int adjvex;//邻接点在数组中的位置下标
    struct ArcNode* nextArc;//指向下一个邻接点的指针
    int weight;//权值，网才有权值
};

/**顶点的结构体*/
template <class T>
struct VNode
{
    T vertex;//顶点的数据域
    ArcNode* firstArc;//指向邻接点的指针
};

/**邻接表类*/
template <class T>
class ALGraph
{
private:
    VNode<T> AdjList[MAX_VERTEX_NUM];//顶点表的数组
    int vexNum, arcNum;//记录图中顶点数和边或弧数
public:
    ALGraph();//构造函数
    ~ALGraph() {}; //析构函数
    void printALG();//打印函数
    void createDN();//构造有向网
    int getOutDegreeDN(T vertex);//根据指定的值求出度
    int getInDegreeDN(T vertex);//根据指定的值求入度
    void setVertex(int index, T value);
    void incrementVexNum();
};

template <class T>
ALGraph<T>::ALGraph() {
    // 将顶点数和边数初始化为0
    vexNum = 0;
    arcNum = 0;
    // 顶点表的数组初始化
    for (int i = 0; i < MAX_VERTEX_NUM; i++) {
        AdjList[i].firstArc = NULL;
    }
}
// 输出函数
template <class T>
void ALGraph<T>::printALG() {
    cout << "图的顶点有：";
    // 依次遍历顶点表，输出顶点
    for (int i = 0; i < vexNum; i++) {
        cout << AdjList[i].vertex << " ";
    }
    cout << endl;
    // 遍历边表
    cout << "图的边有：";
    for (int i = 0; i < vexNum; i++) {
        ArcNode* p = AdjList[i].firstArc; //定义一个p指针，初始化指向顶点表的第一个指向邻接表的指针
        // 遍历边表，p不为空的话
        while (p) {
            cout << AdjList[i].vertex << "-" << AdjList[p->adjvex].vertex << ":[" << p->weight << "] ";  //就输出边表对应的数据：起始位置-终点位置：【权值】
            p = p->nextArc; //p移到下一位
        }
    }
    cout << endl;
}
// 构建有向图
template <class T>
void ALGraph<T>::createDN() {
    int u, v, w;
    // 输入起点下标，终点下标，权值
    cin >> u >> v >> w; 
    ArcNode* p = new ArcNode; //定义邻接表的p指针
    p->adjvex = v; //传入邻接点在数组中的终点位置下标
    p->weight = w; //传入对应的权值
    // 头插法插入新的数据
    p->nextArc = AdjList[u].firstArc; 
    AdjList[u].firstArc = p;
    arcNum++; //边数增加
}

//更改顶点表的数据域，传入下标和数据
template <class T>
void ALGraph<T>::setVertex(int index, T value) {
    if (index >= 0 && index < MAX_VERTEX_NUM) {
        AdjList[index].vertex = value;
    }
}
//vexNum为私有属性，不能直接访问
template <class T>
void ALGraph<T>::incrementVexNum() {
    if (vexNum < MAX_VERTEX_NUM) {
        vexNum++;
    }
}
int main() {
    ALGraph<char> graph;
    int n, m;
    // 输入顶点的个数
    cin >> n;
    // 输入顶点
    for (int i = 0; i < n; i++) {
        char v;
        cin >> v;
        graph.setVertex(i, v);
        graph.incrementVexNum();
    }
    // 输入边的个数
    cin >> m;
    // 输入边的起点下标，终点下标和权值。
    for (int i = 0; i < m; i++) {
        graph.createDN();
    }
    // 打印输出
    graph.printALG();
    return 0;
}

构造函数可以像下面这样写，会更简洁。这样大部分输入操作就在构造函数中完成，不用再在主函数中输入，也就不需要

void setVertex(int index, T value);

void incrementVexNum();

这两个函数来传值。

ALGraph()//构造函数
    {
        vexNum=0;
        arcNum=0;
        int i;
        for(i=0; i<MAX_VERTEX_NUM; i++)
        {
            AdjList[i].firstArc=NULL;//初始化操作
        }
        int n, m;
        cin >> n;
        vexNum=n;
        for (int i = 0; i < n; i++)
        {
            char vertex;
            cin >> vertex;
            AdjList[i].vertex = vertex;
        }
        cin >> m;
        for (int i = 0; i < m; i++)
        {
            int u, v, w;
            cin >> u >> v >> w;
            ArcNode *p = new ArcNode;
            p->adjvex = v;
            p->weight = w;
            p->nextArc = AdjList[u].firstArc;
            AdjList[u].firstArc = p;
        }

有向网的基本计算

【题目要求】

采用邻接表存储有向网后，如何计算图中有多少条边（不直接读arcNum属性）？输入i、j两个顶点的值（不是下标），判断两个顶点i到j是否有边相连？输入任意一个顶点，输出它的入度和出度？

这里提供了以下函数：

  1. int getIndex(T vertex);//获得顶点的下标
  2. int getOutDegreeDN(T vertex);//根据指定的值求出度
  3. int getInDegreeDN(T vertex);//根据指定的值求入度
  4. int computeArcNum();//计算边的条数
  5. bool isConnected(T v1,T v2);//判断两个顶点是否有边相连

【代码】

获得顶点下标
//获取顶点的下标
template <class T>
int ALGraph<T>::getIndex(T vertex) { //传入顶点
    for (int i = 0; i < vexNum; i++) { //遍历顶点表
        if (AdjList[i].vertex == vertex) { //如果顶点表的数据域与传入要查找的顶点相同的话，就返回此时的下标
            return i;
        }
    }
    return -1; //如果没找到，就返回-1
}
根据指定的值求出度
template <class T>
int ALGraph<T>::getOutDegreeDN(T vertex) {
    int index = getIndex(vertex);
    if (index == -1) { //如果传入的数据不属于顶点表，就返回-1
        return -1;
    }
    int count = 0;
    ArcNode* p = AdjList[index].firstArc;
    while (p) {
        count++;
        p = p->nextArc;
    }
    return count;
}
根据指定的值求入度
template <class T>
int ALGraph<T>::getInDegreeDN(T vertex) {
    int count = 0;
    for (int i = 0; i < vexNum; i++) {
        ArcNode* p = AdjList[i].firstArc;
        while (p) {
            if (p->adjvex == getIndex(vertex)) {
                count++;
            }
            p = p->nextArc;
        }
    }
    return count;
}
计算边的条数
template <class T>
int ALGraph<T>::computeArcNum() {
    int count = 0;
    //遍历边表
    for (int i = 0; i < vexNum; i++) {
        ArcNode* p = AdjList[i].firstArc;
        while (p) {
            count++;
            p = p->nextArc;
        }
    }
    return count;
}
判断两个顶点是否有边相连
template <class T>
bool ALGraph<T>::isConnected(T v1, T v2) {
    //获取两个顶点的下标
    int index1 = getIndex(v1);
    int index2 = getIndex(v2);
    if (index1 == -1 || index2 == -1) {
        return false; //如果没找到该顶点，就返回假
    }
    //遍历下标为index1的顶点对应的边表
    ArcNode* p = AdjList[index1].firstArc;
    while (p) {
        if (p->adjvex == index2) { //邻接点在数组中的位置下标等于要找的顶点在数组中的下标，说明能找到这个顶点，所以两个顶点有关联，返回真
            return true;
        }
        p = p->nextArc;
    }
    return false;
}

菜包小姐的先生
关注
  • 27
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++中图的存储
诀别之扉
08-04 2881
几个简单的概念 无向图，ab两个点之间有一条边，可以从a到b，也可以从b到a，就叫做无向。 有向图，ab两个点之间有一条边，仅允许从a到b或者从b到a，就叫做有向。 带权，从a到b需要付出c的代价。   图的存储方式比较常见的2类，邻接矩阵和邻接表 1、邻接矩阵，用一个数组来记录图的情况。 int mp[111][111]; mp[a][b]=1; //有向无权 ...
C++简单的图存储
Blog of SantaOracle
03-29 1329
第一次写博客，格式什么的就不太拘谨，以后会慢慢调整。本文解决的问题： 1.如何在C++中进行图的存储，以及对图进行一些简单操作废话不多说，直接上干货。我的图存储主要有3个类：Graph 图类 Vertex 点类 Edge 边类其中点在图中用数组的形式存储（因为一般情况下，简单的图点数一般不会太多，这里设置一个maxnum = 100常量足够解决一般图的存储问题），边在点类中用vec
图的存储结构的实现(C/C++实现)
weixin_33888907的博客
11-26 718
存档： 1 #include &lt;stdio.h&gt; 2 #include &lt;stdlib.h&gt; 3 #define maxv 10 4 #define max 10 5 typedef char elem; 6 typedef int elemtype; 7 #include "queue.h" 8 #include "mgraph.h" ...
C++实现图的存储和遍历
Beau_Will的博客
05-24 532
许多新手友友在初学算法和数据结构时，会被图论支配过。我这里整理了一下图论常见的存储和遍历方式，仅供参考。如有问题，欢迎大佬们批评指正。存储我将提到四种方式：邻接矩阵、vector实现邻接表、数组模拟单链表实现的前向星实现邻接表、结构体数组直接存储边。遍历我将提到三种方式：dfs、bfs、按照边的权重值大小遍历输出。
图的存储（C++）
smart_jackli的博客
11-16 1411
图的存储及其实现
图的存储结构C++实现
Worthwhile_DUT的博客
11-24 1621
图结构作为一种比线性表和树更为复杂的数据结构，任意两个数据元素之间都有可能相关。在离散数学中有图论一章，就是专门研究图的性质的。
c++-c++编程基础之leetcode题解第18题四数之和.zip
03-18
5. 找到一个解后，我们需要记录下四个数的索引，可以使用`std::vector<int>`来存储结果，并在每次找到解时调用`result.push_back()`。 6. 最后，返回结果数组`result`。 这个解决方案的时间复杂度是`O(n^3)`，因为...
C++入门必做题
11-04
### C++ 入门经典习题解析 #### 题目背景 在学习 C++ 的过程中，通过实际的编程练习可以极大地加深对语言特性的理解并提高编程能力。本篇文章将针对一系列 C++ 入门经典题目进行详细的解析，旨在帮助初学者掌握...
C++与操作系统等面试题15
06-10
本题主要探讨了C++编程语言中两种重要的存储区域——堆(heap)与栈(stack)的区别。这两种存储区域对于理解和掌握C++内存管理至关重要。 #### 描述分析 题目描述简单明了，直接指向了C++与操作系统领域内关于堆和栈的...
C语言考研真题集-内附70多套真题
08-17
它是许多现代编程语言的基石，如C++、Java和Python等。 在C语言的学习中，基础语法是首要掌握的部分，包括变量、数据类型（如int、char、float、double等）、运算符（算术、关系、逻辑等）、流程控制（if-else、...
2021-2022计算机二级等级考试试题及答案No.1397.docx
10-27
- 需求分析阶段主要解决软件系统“做什么”的问题。 ### 16. 数据库系统的特点 **知识点概述：** - 数据库系统具有多种特点，使其在数据管理方面优于传统的文件系统。 - 错误的说法是 **非结构化数据存储**。 - ...
图的建立与遍历c++实现（邻接矩阵存储）
10-14
这是一个关于图的建立与遍历的问题，用的是c++实现，邻接矩阵作为存储
图的存储(C++简单实现) 基于5种基础方式
qq_40059236的博客
07-02 2233
本文主要是对图论的存储方式进行简单的实现，实现方式基于C++，进行简单的算法实现，特别是针对初学者比较友好，代码忽略了过多的类的实现。
实验六 图的基本储存(C++)
weixin_44222391的博客
06-09 1289
1．实验目的 （1）理解图的基本概念、图的结构特性； （2）掌握邻接表表示图的基本方法； （3）掌握连通图遍历的基本的方法。 2．实验内容 （1）用邻接表存储一个图 G。分别设计实现下列要求的算法： 求出图 G 中每个顶点的出度； 求出图 G 中出度最大的一个顶点，输出该顶点的编号； 计算图 G 中出度为 0 的顶点数。 （2）编写一个实现连通图 G 的深度优先遍历（从顶点 V0 出发，以邻接矩阵为 储结构）的递归和非递归函数，分别用这两种方法对图进行深度优先遍历，比较遍历结果。 3.代码 3.1 #ifn
C++知识点总结(51)：图与图的存储
最新发布
joe_g12345的博客
07-23 640
一般情况下，我们会将数据结构分为逻辑结构和物理结构，其中逻辑结构是我们的逻辑下存储的结构，而物理结构是计算机的逻辑下存储的结构。一个图从任意一个顶点可以到另外任意一个顶点（不一定直接联通），则称为。如果在无向图中，任意两个顶点都有一条边直接相连，这时就称该图为。从图中提取出的图（可以是空图、一个顶点、图本身）称作。有些图点和点之间的关系是相互的，这种图被称为。有些图点和点之间的关系是单向的，这种图被称为。图中的边带有某种与之相关的数值，我们称之为。条边的图，其所有顶点的度数之和等于边数的。
C++如何处理图的存储方式
苏州程序大白的博客
03-23 2315
C++如何处理图的存储方式博主介绍邻接矩阵邻接表链式前向星**1、AcWing方式（纯数组）**Acwing图的存储方式案例复杂度 博主介绍 🌊 作者主页：苏州程序大白 🌊 作者简介：🏆CSDN人工智能域优质创作者🥇，苏州市凯捷智能科技有限公司创立人，目前合作公司富士康、歌尔等 邻接矩阵 适用： 稠密图，就是说点数的平方与边数接近的情况，换句话说就是边特别多。 不适用： 稀疏图，就是点数的平方与边数差的特别多，边数少，但点数多，就不行了，因为空间占用太大了。 实现代码 #include <bits
图的存储及基本操作总结（邻接矩阵、邻接表）及C/C++代码实现
z135733的博客
04-22 4308
图是一种比较复杂的数据结构，每个结点之间可以有多种关系。所以，一个图可以呈现出千奇百怪的形式。对于不同的形式的图，我们可以用不同的存储方式来进行存储。对于边比较少而结点很多的图，我们需要把更多的存储空间用于存放顶点的信息，如果两个顶点之间不存在边，那么就不需要花费存储空间来说明这个地方没有边。对于边比较多而顶点相对没那么多的图，在每一个顶点之间，都很有可能存在边，如果每一条边都单独考虑，会显得比较繁琐。对于插入和删除边的操作做的比较多的图。
计算机二级C++上机实战：非素数存储、字符串连接与矩阵运算
4. **统计与筛选**：第54题要求编写一个函数`fun`，找出所有低于平均分的学生记录，并将其存储到另一个数组中。这个题目不仅涉及到简单的数据结构操作，还涉及到平均分的计算以及条件判断。函数通过遍历整个结构体...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值