hnust 1964: 邻接表表示法

最新推荐文章于 2024-08-06 17:42:20 发布

祈念.

最新推荐文章于 2024-08-06 17:42:20 发布

阅读量649

点赞数 14

分类专栏： hnust程序测评AC代码（讲解）文章标签：图论算法 c++ c语言数据结构

本文链接：https://blog.csdn.net/weixin_50950742/article/details/140364548

版权

hnust程序测评AC代码（讲解）专栏收录该内容

38 篇文章 0 订阅

订阅专栏

hnust 1964: 邻接表表示法

题目描述
输入一个图，用邻接表存储，并实现一些操作。
拷贝下面的代码，按要求完成其中的FirstAdjVex，NextAdjVex，sort和CreateUDG操作，其他地方不得改动。

//图的邻接表存储表示

#include <iostream>
#include <iomanip>
using namespace std;

#define MVNum 100         //最大顶点数
#define OK 1

typedef string VerTexType; //顶点信息
typedef int OtherInfo;    //和边相关的信息

//- - - - -图的邻接表存储表示- - - - -
typedef struct ArcNode {                //边结点
   int adjvex;                          //该边所指向的顶点的位置
   struct ArcNode *nextarc;          //指向下一条边的指针
   OtherInfo info;                      //和边相关的信息
} ArcNode;

typedef struct VNode {
   VerTexType data;                    //顶点信息
   ArcNode *firstarc;                //指向第一条依附该顶点的边的指针
} VNode, AdjList[MVNum];                //AdjList表示邻接表类型

typedef struct {
   AdjList vertices;                  //邻接表
   int vexnum, arcnum;              //图的当前顶点数和边数
} Graph;

//得到顶点i的数据
VerTexType Vertexdata(const Graph &g, int i)
{
   return g.vertices[i].data;
}

int LocateVex(const Graph &g, VerTexType v)
{
   //确定点v在G中的位置
   for(int i = 0; i < g.vexnum; ++i)
      if(g.vertices[i].data == v)
         return i;
   return -1;
}//LocateVex

//返回v的第一个邻接顶点。若顶点在G中没有邻接表顶点，则返回-1。
int FirstAdjVex(const Graph &g, int v)
{
   /****在此下面完成代码***************/


   /***********************************/
}

// 返回v的（相对于w的）下一个邻接顶点。
int NextAdjVex(const Graph &g, int v, int w)
{
  /****在此下面完成代码***************/


   /***********************************/
}

//对每个顶点的链表排序，按顶点编号从小到大排列
void sort(ArcNode *arclist)
{
   /****在此下面完成代码***************/


   /***********************************/
}

int CreateUDG(Graph &g)
{
   //采用邻接表表示法，创建无向图G
   /****在此下面完成代码***************/


   /***********************************/
   for(i = 0; i < g.vexnum; ++i) {           
      sort(g.vertices[i].firstarc); 保证有序，不依赖输入次序
   }//for
   return OK;
}//CreateUDG

void DestroyUDG(Graph &g)
{
   //you should do this
}

int main()
{
   Graph g;
   CreateUDG(g);
   //输出各个顶点的邻接点
   for(int i = 0; i < g.vexnum; i++) {
      cout << Vertexdata(g, i) << ":";
      for(int w = FirstAdjVex(g, i); w >= 0; w = NextAdjVex(g, i, w)) {
         cout << ' ' << Vertexdata(g, w);
      }
      cout << endl;
   }
   DestroyUDG(g);
   return 0;
}//main

输入
输入的第一行是两个整数，分别是图的总顶点数n和总边数e
第二行是n个空格分开的字符串，是顶点的名字，依次对应编号0~n-1。
随后有e行，每行两个空格分开的顶点名字，表示一条边的两个顶点。
具体见样例。
输出
输出n行，每行是第i个顶点的邻接顶点（要求按序号从小到大排列）。
具体见样例。
样例输入 Copy
8 9
v1 v2 v3 v4 v5 v6 v7 v8
v1 v2
v1 v3
v2 v4
v2 v5
v3 v6
v3 v7
v4 v8
v5 v8
v6 v7
样例输出 Copy
v1: v2 v3
v2: v1 v4 v5
v3: v1 v6 v7
v4: v2 v8
v5: v2 v8
v6: v3 v7
v7: v3 v6
v8: v4 v5

提示
样例对应教材6.5的图G4

解题过程

邻接表表示法(链式)
顶点：按编号顺序将顶点数据存储在一维数组中。
关联同一顶点的边：用线性链表存储。
如果有边\弧的信息，还可以在表结点中增加一项，

无向图的邻接表
特点：
邻接表不唯一
若无向图中有n个顶点、e条边，则其邻接表需要n个头结点和2e个表结点。适宜存储稀疏图。
无向图中顶点v i 的度为第i个单链表中的结点数。

有向图的邻接表
邻接表特点：
顶点 v i 的出度为第i个单链表中的结点个数。
顶点v i 的入度为整个单链表中邻接点域值是i-1的结点个数。
找出度易，找入度难

逆邻接表特点：
顶点 v i 的入度为第i个单链表中的结点个数。
顶点v i 的出度为整个单链表中邻接点域值是i-1的结点个数。
找入度易，找出度难
当邻接表的存储结构形成后，图便唯一确定。

这段C++代码实现了无向图的邻接表表示、创建、遍历和销毁。以下是对代码的详细解析：

1. 头文件和命名空间

包含<iostream>和<iomanip>，提供输入输出流和格式化功能。
使用using namespace std;简化代码。

2. 宏定义和类型定义

MVNum定义了最大顶点数。
VerTexType定义顶点信息的数据类型为string。
OtherInfo定义边相关信息的数据类型为int。

3. 图的邻接表结构

ArcNode结构体定义了边结点，包含邻接顶点索引、指向下一条边的指针和边的相关信息。
VNode结构体定义了顶点，包含顶点信息和指向第一条依附该顶点的边的指针。
Graph结构体定义了图，包含邻接表数组和图的顶点数、边数。

4. 函数定义

Vertexdata：获取顶点的数据。
LocateVex：确定顶点在图中的位置，如果找到则返回索引，否则返回-1。
FirstAdjVex：返回顶点的第一个邻接顶点的索引，如果没有邻接点则返回-1。
NextAdjVex：返回顶点相对于给定邻接顶点的下一个邻接顶点的索引，如果没有则返回-1。
sort：对邻接链表进行排序，按顶点编号从小到大排列。

5. 图的创建函数`CreateUDG`

读取顶点数和边数。
读取顶点信息并初始化邻接表。
循环读取边的信息，使用LocateVex找到顶点的索引，并创建边结点添加到邻接表中。
调用sort函数对所有顶点的邻接链表进行排序。

6. 图的销毁函数`DestroyUDG`

该函数需要实现释放图占用的内存资源，但当前代码为空。

7. 主函数`main`

创建图g并调用CreateUDG函数。
遍历所有顶点，输出每个顶点及其邻接点。
调用DestroyUDG函数销毁图。

代码逻辑分析

代码使用邻接表表示无向图，允许多个顶点共享相同的邻接链表。
使用CreateUDG函数根据用户输入创建图，包括顶点和边的信息。
使用FirstAdjVex和NextAdjVex函数遍历每个顶点的邻接点。
使用sort函数对邻接链表进行排序，以便于输出和后续操作。

潜在问题

DestroyUDG函数未实现，没有释放图占用的内存。
sort函数中的排序逻辑可能不正确，因为它只是简单地交换了邻接点的索引，而没有考虑链表的结构。

改进建议

实现DestroyUDG函数，以正确释放图占用的内存资源。
优化sort函数，确保邻接链表可以正确排序。
考虑使用std::vector代替固定大小的数组，以提高代码的灵活性和安全性。
对输入数据进行有效性检查，确保它们在预期的范围内，并且是有效的图数据。

AC代码

#include <iostream>
#include <iomanip>
using namespace std;
  
#define MVNum 100         //最大顶点数
#define OK 1
typedef string VerTexType; //顶点信息
typedef int OtherInfo;    //和边相关的信息
  
//- - - - -图的邻接表存储表示- - - - -
typedef struct ArcNode                  //边结点
{
    int adjvex;                          //该节点指向的对应顶点是谁，即回答自己是谁
    struct ArcNode *nextarc;          //指向下一条边的指针
    OtherInfo info;                      //和边相关的信息
} ArcNode;
  
typedef struct VNode
{
    VerTexType data;                    //顶点信息
    ArcNode *firstarc;                //指向第一条依附该顶点的边的指针
} VNode, AdjList[MVNum];                //AdjList表示邻接表类型
  
typedef struct
{
    AdjList vertices;                  //邻接表
    int vexnum, arcnum;              //图的当前顶点数和边数
} Graph;
  
//得到顶点i的数据
VerTexType Vertexdata(const Graph &g, int i)
{
    return g.vertices[i].data;
}
  
int LocateVex(const Graph &g, VerTexType v)
{
    //确定点v在G中的位置
    for(int i = 0; i < g.vexnum; ++i)
        if(g.vertices[i].data == v)
            return i;
    return -1;
}//LocateVex
  
//返回v的第一个邻接顶点。若顶点在G中没有邻接表顶点，则返回-1。
int FirstAdjVex(const Graph &g, int v)
{
    /****在此下面完成代码***************/
    if(g.vertices[v].firstarc)return   g.vertices[v].firstarc->adjvex;
    return -1;
    /***********************************/
}
  
// 返回v的（相对于w的）下一个邻接顶点。
int NextAdjVex(const Graph &g, int v, int w)
{
    /****在此下面完成代码***************/
    ArcNode *p1=g.vertices[v].firstarc;
    while(p1->adjvex!=w)p1=p1->nextarc;
    if(p1->nextarc)return p1->nextarc->adjvex;
    return -1;
  
    /***********************************/
}
  
//对每个顶点的链表排序，按顶点编号从小到大排列
void sort(ArcNode *arclist)
{
    /****在此下面完成代码***************/
    ArcNode *p1,*p2;
    for(p1=arclist; p1; p1=p1->nextarc)
    {
        for(p2=p1->nextarc; p2; p2=p2->nextarc)
        {
            if(p1->adjvex>p2->adjvex)swap(p1->adjvex,p2->adjvex);
        }
  
    }
  
    /***********************************/
}
  
int CreateUDG(Graph &g)
{
    //采用邻接表表示法，创建无向图G
    /****在此下面完成代码***************/
    cin>>g.vexnum>>g.arcnum;
    for(int i=0; i<g.vexnum; i++)
    {
        cin>>g.vertices[i].data;
        g.vertices[i].firstarc=NULL;
    }
    while(g.arcnum--)
    {
        string v1,v2;
        cin>>v1>>v2;
        int h1=LocateVex(g,v1),h2=LocateVex(g,v2);
        if(h1!=-1&&h2!=-1)
        {
            ArcNode*p1=new ArcNode;
            p1->adjvex=h2;
            p1->nextarc=g.vertices[h1].firstarc;
            g.vertices[h1].firstarc=p1;
            ArcNode*p2=new ArcNode;
            p2->adjvex=h1;
            p2->nextarc=g.vertices[h2].firstarc;
            g.vertices[h2].firstarc=p2;
        }
  
    }
  
    /***********************************/
    for(int i = 0; i < g.vexnum; ++i)
    {
        sort(g.vertices[i].firstarc); 
    }//for
    return OK;
}//CreateUDG
  
void DestroyUDG(Graph &g)
{
    //you should do this
}
  
int main()
{
    Graph g;
    CreateUDG(g);
    //输出各个顶点的邻接点
    for(int i = 0; i < g.vexnum; i++)
    {
        cout << Vertexdata(g, i) << ":";
        for(int w = FirstAdjVex(g, i); w >= 0; w = NextAdjVex(g, i, w))
        {
            cout << ' ' << Vertexdata(g, w);
        }
        cout << endl;
    }
    DestroyUDG(g);
    return 0;
}//main