将一个无向图的邻接矩阵转换为邻接表

最新推荐文章于 2023-07-17 17:35:27 发布
最新推荐文章于 2023-07-17 17:35:27 发布
阅读量6.6k 收藏 64
点赞数 7
分类专栏： 学习笔记 数据结构 文章标签： 数据结构 算法 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/easygoing45/article/details/121465459
版权
本文介绍了无向图的概念，详细阐述了邻接矩阵的存储方式，并通过实例展示了如何进行深度优先遍历和广度优先遍历。同时，提供了将邻接矩阵转换为邻接表的算法，以及相关C++代码实现，帮助理解图的遍历和数据结构转换。
摘要由CSDN通过智能技术生成

将一个无向图的邻接矩阵转换为邻接表

什么是无向图？

图是一种基本的数据结构，在离散数学中有详细介绍过。

邻接矩阵？

图的邻接矩阵（Adjacency Matrix)存储方式是用两个数组来表示图。一个一维的数组存储图中顶点信息，一个二维数组（称为邻接矩阵）存储图中的边或弧的信息。

设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为：

在这里插入图片描述

来看一个实例

在这里插入图片描述

注意索引问题！！！

图的遍历

图的遍历：从图的某个顶点出发，依次访问图中所有的顶点，每个顶点被访问一次且仅访问一次。
防止多次访问某一个顶点的思路：设置辅助数组visited[n],用来标记每个被访问的顶点，
初始化状态为visited[n]=0;如果顶点被访问到，则修改辅助数组的值 ：visited[i]=1

深度优先遍历

DFS，Depth First Search

假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。

看一张图：

640?wx_fmt=png

上述由7个顶点构成的图的深度优先遍历顺序应该为？

答案是:

ACBEDFG

图的深度优先遍历技术需要借助栈结构，由于递归本身就使用了函数栈的特性，所以无需额外使用其余的栈。

void MGraph::DFTraverse(int v)
{
    cout<<vertex[v]<<" ";
    visited[v]=1;
    for(int j=0;j<vertexNum;j++)
    {
        if(edge[v][j]==1 && visited[j]==0)
        {
            DFTraverse(j);
        }
    }
}

广度优先遍历

BFS，Breadth First Search

广度优先搜索思想：从图中某顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问，直至图中所有已被访问的顶点的邻接点都被访问到。如果此时图中尚有顶点未被访问，则需要另选一个未曾被访问过的顶点作为新的起始点，重复上述过程，直至图中所有顶点都被访问到为止。

640?wx_fmt=png

上述图的广度优先遍历序列为：

ABECDFGH

void MGraph::BFTraverse(int v)
{
    int w,j,Q[MaxSize];     //顺序队列，有点取巧
    int front=-1,rear=-1;
    cout<<vertex[v]<<" ";
    visited[v]=1;
    Q[++rear]=v;
    while(front!=rear)
    {
        //当队列非空时为循环条件
        w=Q[++front];
        for(j=0;j<vertexNum;j++)
        {
            if(edge[w][j]==1 && visited[j]==0)
            {
                cout<<vertex[j]<<" ";
                visited[j]=1;
                Q[++rear]=j;
            }
        }
    }
}

图类的设计

class MGraph
{
private:
    /* data */
    char vertex[MaxSize];            //数组-用于存放图中顶点
    int edge[MaxSize][MaxSize];     //数组-用于存放图中的边
    int vertexNum,edgeNum;          //图的顶点数和边数

    VertexNode adjlist[MaxSize];        //存放顶点表的数组
    int visited[MaxSize]={0};
public:
    MGraph(char a[],int n,int e);    //构造函数
    void showVertex();
    void showEdge();
    ~MGraph();                      //虚构函数
    void DFTraverse(int v);         //深度优先遍历图
    void BFTraverse(int v);         //广度优先遍历图
    void init();                    //遍历后重新初始化visited
    void Turn();                    //将邻接矩阵转换为邻接表
    void showList();                //展示邻接表
};

邻接矩阵转邻接表算法

void MGraph::Turn()
{
    //初始化指针数组
    for(int i=0;i<MaxSize;i++)
    {
        this->adjlist[i].firstEdge=nullptr;
    }

    //将邻接矩阵转换为邻接表
    EdgeNode *s1=nullptr;   //工具指针

    //先初始化vertex数组  点表 adjlist
    for(int i=0;i<vertexNum;i++)
    {
        //初始化顶点表
        adjlist[i].vertex=vertex[i];
    }

    //转换边表
    for(int i=0;i<vertexNum;i++)
    {
        for(int j=0;j<vertexNum;j++)
        {
            if(edge[i][j]==1)
            {
                cout<<"["<<i<<","<<j<<"]"<<"值为1"<<endl;   //输出方便看到过程
                //如果有边的话就转换成邻接表
                s1=new EdgeNode;
                s1->adjvex=j;
                s1->next=adjlist[i].firstEdge;  //插入表头
                adjlist[i].firstEdge=s1;

            }
        }
    }
}

展示邻接表

void MGraph::showList()
{
    //展示邻接表
    for(int i=0;i<vertexNum;i++)
    {
        cout<<"编号为:"<<i<<",数据信息为:"<<adjlist[i].vertex<<"的顶点的边表信息:";
        EdgeNode *p=adjlist[i].firstEdge;
        while(p!=nullptr)
        {
            cout<<p->adjvex<<","<<adjlist[p->adjvex].vertex<<" ";
            p=p->next;
        }
        cout<<endl;
    }
}

展示邻接矩阵

void MGraph::showEdge()
{
    cout<<"邻接矩阵："<<endl;
    for(int i=0;i<vertexNum;i++)
    {
        for(int j=0;j<vertexNum;j++)
        {
            cout<<edge[i][j]<<" ";
            if(j==vertexNum-1)
            {
                cout<<endl;
            }
        }
    }
}

源代码

MGraph.h

/*
*图的C++实现
*邻接矩阵存储法
*/
#include<iostream>
using namespace std;

const int MaxSize=7;   //最大顶点个数

//邻接表相关声明
struct EdgeNode     //定义边表结点
{
    int adjvex;     //临接点域(编号)
    EdgeNode *next;
};

struct VertexNode   //顶点表结点
{
    char vertex;
    EdgeNode *firstEdge;
};


class MGraph
{
private:
    /* data */
    char vertex[MaxSize];            //数组-用于存放图中顶点
    int edge[MaxSize][MaxSize];     //数组-用于存放图中的边
    int vertexNum,edgeNum;          //图的顶点数和边数

    VertexNode adjlist[MaxSize];        //存放顶点表的数组
    int visited[MaxSize]={0};
public:
    MGraph(char a[],int n,int e);    //构造函数
    void showVertex();
    void showEdge();
    ~MGraph();                      //虚构函数
    void DFTraverse(int v);         //深度优先遍历图
    void BFTraverse(int v);         //广度优先遍历图
    void init();                    //遍历后重新初始化visited
    void Turn();                    //将邻接矩阵转换为邻接表
    void showList();                //展示邻接表
};

因为要转换为邻接表，所以把邻接表的两个结点声明也给搬过来了

MGraph.cpp

#include"MGraph.h"

MGraph::MGraph(char a[],int n,int e)
{
    int i,j,k;
    vertexNum=n;
    edgeNum=e;

    for(i=0;i<vertexNum;i++)
    {
        vertex[i]=a[i];     //存储顶点
    }

    for(i=0;i<vertexNum;i++)
    {
        for(j=0;j<vertexNum;j++)
        {
            edge[i][j]=0;   //初始化邻接矩阵
        }
    }

    for(k=0;k<edgeNum;k++)
    {
        cout<<"请输入有临边关系的两个点的代号:";
        cin>>i>>j;
        edge[i][j]=1;
        edge[j][i]=1;
    }

}

MGraph::~MGraph()
{
    cout<<"析构基于邻接矩阵的图"<<endl;
}

void MGraph::DFTraverse(int v)
{
    cout<<vertex[v]<<" ";
    visited[v]=1;
    for(int j=0;j<vertexNum;j++)
    {
        if(edge[v][j]==1 && visited[j]==0)
        {
            DFTraverse(j);
        }
    }
}

void MGraph::BFTraverse(int v)
{
    cout<<"广度优先遍历：";
    int w,j,Q[MaxSize];     //顺序队列，有点取巧
    int front=-1,rear=-1;
    cout<<vertex[v]<<" ";
    visited[v]=1;
    Q[++rear]=v;
    while(front!=rear)
    {
        //当队列非空时为循环条件
        w=Q[++front];
        for(j=0;j<vertexNum;j++)
        {
            if(edge[w][j]==1 && visited[j]==0)
            {
                cout<<vertex[j]<<" ";
                visited[j]=1;
                Q[++rear]=j;
            }
        }
    }
}

void MGraph::init()
{
    cout<<"归零visited数组"<<endl;
    //每次遍历结束后重新初始化visited数组
    for(int i=0;i<MaxSize;i++)
    {
        this->visited[i]=0;
    }

    // for(int i=0;i<MaxSize;i++)
    // {
    //     cout<<visited[i]<<endl;
    // }
}

void MGraph::showVertex()
{
    cout<<"图的顶点编号为:";
    for(int i=0;i<vertexNum;i++)
    {
        cout<<vertex[i]<<" ";
    }
    cout<<endl;
}

void MGraph::showEdge()
{
    cout<<"邻接矩阵："<<endl;
    for(int i=0;i<vertexNum;i++)
    {
        for(int j=0;j<vertexNum;j++)
        {
            cout<<edge[i][j]<<" ";
            if(j==vertexNum-1)
            {
                cout<<endl;
            }
        }
    }
}

void MGraph::Turn()
{
    //初始化指针数组
    for(int i=0;i<MaxSize;i++)
    {
        this->adjlist[i].firstEdge=nullptr;
    }

    //将邻接矩阵转换为邻接表
    EdgeNode *s1=nullptr;

    //先初始化vertex数组  点表 adjlist
    for(int i=0;i<vertexNum;i++)
    {
        //初始化顶点表
        adjlist[i].vertex=vertex[i];
    }

    //转换边表
    for(int i=0;i<vertexNum;i++)
    {
        for(int j=0;j<vertexNum;j++)
        {
            if(edge[i][j]==1)
            {
                cout<<"["<<i<<","<<j<<"]"<<"值为1"<<endl;
                //如果有边
                s1=new EdgeNode;
                s1->adjvex=j;
                s1->next=adjlist[i].firstEdge;  //插入表头
                adjlist[i].firstEdge=s1;

                int o=adjlist[i].firstEdge->adjvex;
                cout<<adjlist[i].firstEdge->adjvex<<" "<<adjlist[o].vertex<<endl;

            }
        }
    }
}

void MGraph::showList()
{
    //展示邻接表
    for(int i=0;i<vertexNum;i++)
    {
        cout<<"编号为:"<<i<<",数据信息为:"<<adjlist[i].vertex<<"的顶点的边表信息:";
        EdgeNode *p=adjlist[i].firstEdge;
        while(p!=nullptr)
        {
            cout<<p->adjvex<<","<<adjlist[p->adjvex].vertex<<" ";
            p=p->next;
        }
        cout<<endl;
    }
}

main.cpp

#include"MGraph.h"

//第一题
int main()
{
    cout<<"基于邻接矩阵的无向图"<<endl;
    //常规版本
    char data[]={'A','B','C','D','E'};
    MGraph m1(data,5,4);
    m1.showVertex();
    m1.showEdge();
    m1.init();
    cout<<"深度优先遍历：";
    m1.DFTraverse(0);
    cout<<endl;
    m1.init();
    m1.BFTraverse(0);


    cout<<"转换为邻接表"<<endl;
    m1.Turn();
    cout<<endl;

    m1.showList();


    system("pause");
    return 0;
}

测试

image-20211122093856737

这样的一个图

image-20211122093924172

CTENET
关注
专栏目录
6-77 无向图的邻接矩阵表示转换为邻接表表示
燕朝铭的博客
01-15 962
编写算法LGraph matriToadj (MGraph gn)实现：把无向图的邻接矩阵表示转换为邻接表表示。LGraph为采用 邻接表作为存储结构的无向图，MGraph为采用 邻接矩阵作为存储结构的无向图。(提示：链表插入结点采用头插法)
图的邻接矩阵和邻接表的转换
01-09
C语言程序 图的邻接表和矩阵的转换 。。。。。。。。。。。。。
基于邻接矩阵的无向图
EASYGOING45的博客
11-08 4776
基于邻接矩阵的无向图 什么是无向图？ 图是一种基本的数据结构，在离散数学中有详细介绍过。 邻接矩阵？ 图的邻接矩阵（Adjacency Matrix)存储方式是用两个数组来表示图。一个一维的数组存储图中顶点信息，一个二维数组（称为邻接矩阵）存储图中的边或弧的信息。 设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为： 来看一个实例 注意索引问题！！！ 图的遍历 图的遍历：从图的某个顶点出发，依次访问图中所有的顶点，每个顶点被访问一次且仅访问一次。 防止多次访问某一个顶点的思路：设置辅助数组visit
将无向图的邻接矩阵转为对应邻接表
进阶的小宋
11-03 2687
//以下定义邻接矩阵类型 typedef struct { int vexs[MAXV]; int arcs[MAXV][MAXV]; int vexnum,arcnum; } MGraph; //以下定义邻接表类型 typedef struct ANode { int adjvex;
设计一个算法将无向图的邻接矩阵转为对应邻接表的算法
Smallactive
07-03 1万+
typedef struct {int vertex[m]; int edge[m][m];}gadjmatrix; typedef struct node1{int info;int adjvertex; struct node1 *nextarc;}glinklistnode; typedef struct node2{int vertexinfo;glinklistnode *firstar...
数据结构：无向图邻接矩阵转换为邻接表
weixin_43893363的博客
02-15 1万+
无向图邻接矩阵转换为邻接表 代码如下（C）： #include <stdio.h> #include<stdlib.h> #define MAXV 100 //以下定义邻接矩阵类型 typedef struct { int vexs[MAXV]; int arcs[MAXV]...
将一个无向图的邻接表转换为邻接矩阵算法.doc.doc
05-18
将一个无向图的邻接表转换为邻接矩阵算法.doc.doc
数据结构学习--图的邻接矩阵和邻接表存储
06-25
对于无向图，邻接矩阵是对称的，即如果顶点i和顶点j之间有一条边，那么矩阵中的元素`arcs[i][j]`和`arcs[j][i]`都为1（或非零值，表示权重）。对于有向图，邻接矩阵通常是非对称的，只有`arcs[i][j]`可能为1，表示从...
邻接表或者邻接矩阵为存储结构实现连通无向图的深度优先和广度优先遍历
12-06
总之，这个程序设计任务要求我们理解并实现无向图的两种主要遍历方法，以及如何利用邻接表或邻接矩阵存储图。通过这些方法，我们可以有效地探索图的结构，找出路径，解决许多实际问题，如搜索、最短路径计算等。
邻接矩阵储存无向图
09-01
采用邻接矩阵实现无向图的存储，并输入输出邻接矩阵。实现图的广度优先遍历和深度优先遍历。
Python根据已知邻接矩阵绘制无向图操作示例
09-20
主要介绍了Python根据已知邻接矩阵绘制无向图操作,涉及Python使用networkx、matplotlib进行数值运算与图形绘制相关操作技巧,需要的朋友可以参考下
无向图的邻接矩阵转邻接表
qq_44186550的博客
10-19 646
无向图的邻接矩阵转邻接表
无向图邻接矩阵转邻接表
m0_46104664的博客
11-19 1068
#define SIZE 10 //邻接矩阵表示 typedef struct{ int e_num; //边数 int v_num; //顶点个数 int links[SIZE][SIZE]; //邻接矩阵 char vexs[SIZE]; }Graph1; //邻接表表示 typedef struct edgeNode{ //边节点 char vex; int value; struct edgeNode *next; }edge
将无向图的邻接矩阵转为对应邻接表的算法，使用c语言
最新发布
m0_61862494的博客
07-17 531
【代码】将无向图的邻接矩阵转为对应邻接表的算法，使用c语言。
将无向图的邻接矩阵转化为邻接表
vener_的博客
09-25 5360
typedef struct { int vertex[max]; int arc[max][max]; int vexnum,aecnum; }MGraph; typedef struct ArcNode{ int adjvex; struct ArcNode *next; }ArcNode; typedef struct VNode { int data; ArcNode *first; }VNode,AdjList[max]; typedef struct { AdjList ver.
java 邻接矩阵_邻接矩阵无向图(三)之 Java详解
weixin_36418862的博客
02-12 460
邻接矩阵无向图的介绍邻接矩阵无向图是指通过邻接矩阵表示的无向图。上面的图G1包含了"A,B,C,D,E,F,G"共7个顶点，而且包含了"(A,C),(A,D),(A,F),(B,C),(C,D),(E,G),(F,G)"共7条边。由于这是无向图，所以边(A,C)和边(C,A)是同一条边；这里列举边时，是按照字母先后顺序列举的。上图右边的矩阵是G1在内存中的邻接矩阵示意图。A[i][j]=1表示第i...
根据邻接矩阵绘制无向图
zxhy0123的博客
02-02 936
from igraph import * import numpy as np import matplotlib.pyplot as plt def matrixgraph(matrix): G = Graph()#无向图 n = len(matrix) print(n) lielist=np.sum(matrix, axis=0) # 每一列的和 for i in range(n): if lielist[i]>0:
数据结构-使用邻接矩阵创建无向图
热门推荐
晨钟暮鼓林中径，晚风花间寺中人
12-01 2万+
1.邻接矩阵 邻接矩阵（Adjacency Matrix)是表示顶点之间相邻关系的矩阵。 2.程序分析 W i,j表示边上的权值；∞表示计算机允许的，大于所有边权值的数。 用邻接矩阵表示法表示图，除了用一个存储邻接矩阵的二维数组外，还需要用一个一维数组来存储顶点信息。 //采用邻接矩阵表示法创建无向网 #include <iostream> using namespace std; #define MaxInt 32767 //表示极大值，即∞ #de
邻接矩阵转邻接表
10-09 217
#include <iostream> using namespace std; const int inf = 99999999; int arr[100][100]; typedef struct ArcNode{ int adjvex; int weight; ArcNode *next; }ArcNode; typedef struct VertexNode{ ...
实现将一个无向图邻接矩阵转换成邻接表
06-28
### 回答1： 将无向图的邻接矩阵转换成邻接表可以按照以下步骤进行： 1. 创建一个空的邻接表，包含与无向图中顶点数相同的链表。 2. 遍历邻接矩阵，对于每个非零元素，将其对应的两个顶点加入到它们对应的链表中。 3. 对于每个链表，按照顶点编号的大小进行排序，以便后续操作。 4. 输出邻接表，每个链表中的顶点即为该顶点所连接的其他顶点。 例如，对于以下无向图的邻接矩阵： ``` 1 1 1 1 1 1 1 1 1 1 ``` 将其转换成邻接表后，可以得到如下结果： ``` -> 1 -> 2 1 -> -> 2 -> 3 2 -> -> 1 -> 3 3 -> 1 -> 2 ``` 其中，每个链表中的数字表示该顶点所连接的其他顶点的编号。 ### 回答2： 邻接矩阵是一种表示图的方式，其中矩阵的每个元素表示两个顶点之间是否有边相连，即该矩阵为一个n*n的二维数组，其中n为图的结点数。而邻接表则是另一种表示图的方式，将每个结点与所有与之相连的结点及其边表示出来。 邻接表是由一个数组和若干个链表组成的数据结构。数组中每个元素表示一个结点，而该结点所对应的链表则记录了与该结点相连的所有结点及其边。 将邻接矩阵转换成邻接表的过程可以通过以下步骤实现： 1. 创建一个大小为n的数组，其中n为无向图的结点数。 2. 遍历邻接矩阵的每一个元素，对于值为1的元素（表示两个结点之间有边相连），将对应数组中的结点与相连结点添加到对应的链表中。 3. 遍历每个结点的链表，将链表中的所有边按照顺序输出即可。 需要注意的是，在邻接表中，每条边需要保存两个信息：起点和终点结点。 邻接表相对于邻接矩阵的优势在于可以减少存储空间的需求。当图的结点数量很大，但连接不是很繁密时，用邻接表存储图的信息可以显著地减少所需存储空间。而邻接矩阵则需一直维护一个n*n的矩阵，无论是否有相连的边存在。 因此，将无向图邻接矩阵转换成邻接表，可以在存储图的信息的同时，提升程序的运行效率，减少空间的浪费。 ### 回答3： 无向图是指没有方向的图，邻接矩阵是一种图的表示方法，它可以将一个无向图表示为一个二维的矩阵。在邻接矩阵中，每行和每列分别代表每一个节点，若两个节点之间有边相连，则该位置的数值为1，否则为0。 将无向图的邻接矩阵转换为邻接表的过程，是将每一个节点以及与之相邻的节点之间的关系，表示成一张链表的形式。具体的步骤如下： 1. 创建一个大小为n（n为节点数量）的链表数组，数组中的每一个元素代表一个节点； 2. 对于邻接矩阵中第i行（或第i列）的元素，若其值为1，则在第i个节点的链表中添加一个指向第j个节点的指针； 3. 对于对称矩阵中的每一个元素，即邻接矩阵中的上三角或下三角区域，都需相应地在两个节点的链表中添加指向对方节点的指针。 以上三个步骤可以简单地用两个循环完成。代码如下： ``` //邻接矩阵转换为邻接表 vector<vector<int>> matrix_to_list(vector<vector<int>> matrix) { int n = matrix.size(); vector<vector<int>> list(n, vector<int>()); //创建链表数组 for (int i = 0; i < n; i++) { for (int j = i; j < n; j++) { //对称矩阵只需操作一半 if (matrix[i][j] == 1) { list[i].push_back(j); //在i的链表中添加j list[j].push_back(i); //在j的链表中添加i } } } return list; } ``` 以上代码中，使用了STL中的vector作为动态数组，依次遍历邻接矩阵的每个元素，在对应的两个节点的链表中添加指向对方节点的指针。最终返回的是一个链表数组，每一个元素都代表一个节点。这个节点的链表就是与之相邻的所有节点。 转换后的邻接表左右对称，占用空间相对邻接矩阵更小，并且可以更方便地进行节点相邻关系的访问和修改。因此，在处理无向图时，一般都会采用邻接表的方式来进行表示和计算。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值