存储结构转换问题

SweetCinderella

已于 2022-06-17 19:12:38 修改

阅读量145

点赞数

分类专栏：数据结构文章标签：图论动态规划算法 c++

于 2022-05-19 18:27:19 首次发布

本文链接：https://blog.csdn.net/qq_63982145/article/details/124862841

版权

数据结构专栏收录该内容

19 篇文章 1 订阅

订阅专栏

该博客介绍了如何使用C++实现有向图的邻接矩阵存储结构，并将其转换为邻接表。程序首先创建有向图的邻接矩阵，然后通过邻接矩阵构建邻接表。同时，讨论了无向图和网的转换方法。在无向图的情况下，邻接矩阵的每个元素需要双向考虑；而对于网，程序已经考虑了权值的存在。

摘要由CSDN通过智能技术生成

1.问题描述：

以图的邻接矩阵方式创建一有向图，然后根据此存储，求出此有向图的邻接表存储方式，并输出邻接表。

2.实验要求：

（1）定义图的邻接矩阵、邻接表的存储结构。

（2）按图的邻接矩阵结构创建图。

（3）根据图的邻接矩阵存储，求出邻接表存储。

（4）输入：有向图。

（5）输出：图的邻接矩阵和邻接表。

3.程序实现：

(1)代码：

#include <iostream>
using namespace std;
const int MaxVexNum = 10;//最大顶点个数
typedef char VerTexData;//顶点数据类型
typedef int EdgeData;//边上权值类型
typedef struct
{
    VerTexData VexList[MaxVexNum];//顶点表
    EdgeData edge[MaxVexNum][MaxVexNum];//邻接矩阵
    int n, e;//图中当前的顶点数和边数
}MTGraph;


typedef struct node//边节点
{
    int dest;//目标节点位置
    EdgeData cost;//边的权值
    struct node* link;//下一边链接指针
}EdgeNode;
typedef struct//顶点结点
{
    VerTexData data;//顶点数据域
    EdgeNode* adj;//边链表头指针
}VerTexNode;
typedef struct//图的邻接表
{
    VerTexNode VexList[MaxVexNum];//邻接表
    int n, e;//图中当前的顶点个数与边数
}AdjGraph;


void CreatGraph(MTGraph* g)//创建有向图的邻接矩阵
{
    cout << "顶点个数和边个数分别为:\t";
    cin >> g->n >> g->e;
    cout << "请输入节点信息:\n";
    for (int i = 0; i < g->n; i++)
    {
        cin >> &(g->VexList[i]);
    }
    for (int i = 0; i < g->n; i++)//初始化邻接矩阵
        for (int j = 0; j < g->n; j++)
        {
            g->edge[i][j] = 0;
        }
    int i, j, w;
    for (int k = 0; k < g->e; k++)
    {
        cout << "输入边(vi,vj)的下标i,下标j和权重w:\t";
        cin >> i >> j >> w;
        g->edge[i][j] = w;
    }
}
void ShowGraph(MTGraph g)//输出有向图的邻接矩阵
{
    cout << "输出图的邻接矩阵为:\n";
    for (int i = 0; i < g.n; i++)
    {
        for (int j = 0; j < g.n; j++)
        {
            cout << g.edge[i][j] << "\t";
            if (j == g.n - 1) cout << "\n";
        }
    }
}


void Turn(MTGraph* g, AdjGraph& G)//邻接矩阵转为邻接表
{
    CreatGraph(g); G.n = g->n; G.e = g->e;
    for (int i = 0; i < g->n; i++)
    {
        G.VexList[i].data = g->VexList[i];
        G.VexList[i].adj = NULL;
    }
    for (int i = 0; i < g->n; i++)
    {
        for (int j = 0; j < g->n; j++)
        {
            if (g->edge[i][j] != 0)
            {
                EdgeNode* p = new EdgeNode;
                p->dest = j; p->cost = g->edge[i][j];
                p->link = G.VexList[i].adj;
                G.VexList[i].adj = p;
            }
        }
    }
}

void ShowGraph(AdjGraph G)//输出邻接表
{
    cout << "邻接矩阵转为邻接表运行结果为:\n";
    for (int i = 0; i < G.n; i++)
    {
        cout << G.VexList[i].data;
        EdgeNode* p = G.VexList[i].adj;
        while (p != NULL)
        {
            cout << " -> (" << p->dest << "," << p->cost << ")";
            p = p->link;
        }
        cout << "\n";
    }
}

int main()
{
    MTGraph g; AdjGraph G;
    Turn(&g, G);//执行了创建邻接矩阵以及转换存储结构
    ShowGraph(g);
    ShowGraph(G);
    return 0;
}

4.测试与运行：

5.思考题：

（1）如果是无向图，应如何修改程序？
将源程序中有向图的类定义，初始化修改为无向图的。无向图的邻接矩阵转换为邻接表算法如下：

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;

            }
        }
    }
}

原文链接：https://blog.csdn.net/EASYGOING45/article/details/121465459

（2）如果是网，应如何修改程序？

源程序中已经考虑了权值的存在。