邻接表表示法

题目描述
输入一个图，用邻接表存储，并实现一些操作。
拷贝下面的代码，按要求完成其中的FirstAdjVex，NextAdjVex，sort和CreateUDG操作，其他地方不得改动。
//图的邻接表存储表示
#include
#include
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个顶点的邻接顶点（要求按序号从小到大排列）。
具体见样例。

样例输入

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

样例输出

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

FirstAdjVex()函数

 ArcNode* p = g.vertices[v].firstarc;
     if (p)
    {
        return p->adjvex;
    }
    return -1;

NextAdjVex()函数

ArcNode* p = g.vertices[v].firstarc;
    while (p)//先找到w顶点
    {
        if (p->adjvex == w)break;
        p = p->nextarc;
    }
    if (p->nextarc)return p->nextarc->adjvex;//若存在
    return -1;//顶点不存在

sort()函数

ArcNode* p1, * p2;
    int temp;
    for (p1 = arclist; p1; p1 = p1->nextarc)
    {
        for (p2 = p1->nextarc; p2; p2 = p2->nextarc)
        {
            if (p1->adjvex > p2->adjvex)
            {
                temp = p1->adjvex;
                p1->adjvex = p2->adjvex;
                p2->adjvex = temp;
            }
        }
    }

CreateUDG

 //采用邻接表表示法，创建无向图G
    /****在此下面完成代码***************/
    int i; int j; int k; string v1, v2;
    cin >> g.vexnum >> g.arcnum;
    for (i = 0; i < g.vexnum; i++)
    {
        cin >> g.vertices[i].data;
        g.vertices[i].firstarc = NULL;//初始化表头结点为空
    }
    for (k = 0; k < g.arcnum; k++)
    {
        cin >> v1 >> v2;
        i = LocateVex(g, v1); j = LocateVex(g, v2);//确定在g中的位置
        ArcNode *p1 = new ArcNode;//建立新的边结点
        p1->adjvex = j; p1->nextarc =g.vertices[i].firstarc;
        g.vertices[i].firstarc = p1;
        ArcNode* p2 = new ArcNode;//建立新的边结点
        p2->adjvex = i; p2->nextarc = g.vertices[j].firstarc;
        g.vertices[j].firstarc = p2;
    }
    /***********************************/
    for (i = 0; i < g.vexnum; ++i) {
        sort(g.vertices[i].firstarc); 保证有序，不依赖输入次序
    }//for
    return OK;

DestroyUDG()函数

 for(int i = 0; i < g.vexnum; ++i)
    {
        ArcNode *p =  g.vertices[i].firstarc;
        while(p)
        {
            ArcNode *r = p;
            p = p->nextarc;
            free(r);
        }
        g.vertices[i].firstarc = NULL;
    }
    g.vexnum = 0; g.arcnum = 0;

完整代码

#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)
{
    /****在此下面完成代码***************/
    ArcNode* p = g.vertices[v].firstarc;
    if (p)
    {
        return p->adjvex;
    }
    return -1;

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

// 返回v的（相对于w的）下一个邻接顶点。
int NextAdjVex(const Graph& g, int v, int w)
{
    /****在此下面完成代码***************/
    ArcNode* p = g.vertices[v].firstarc;
    while (p)
    {
        if (p->adjvex == w)break;
        p = p->nextarc;
    }
    if (p->nextarc) return p->nextarc->adjvex;
    return -1;


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

//对每个顶点的链表排序，按顶点编号从小到大排列
void sort(ArcNode* arclist)
{
    /****在此下面完成代码***************/
    ArcNode* p1, * p2;
    int temp;
    for (p1 = arclist; p1; p1 = p1->nextarc)
    {
        for (p2 = p1->nextarc; p2; p2 = p2->nextarc)
        {
            if (p1->adjvex > p2->adjvex)
            {
                temp = p1->adjvex;
                p1->adjvex = p2->adjvex;
                p2->adjvex = temp;
            }
        }
    }

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

int CreateUDG(Graph& g)
{
    //采用邻接表表示法，创建无向图G
    /****在此下面完成代码***************/
    int i; int j; int k; string v1, v2;
    cin >> g.vexnum >> g.arcnum;
    for (i = 0; i < g.vexnum; i++)
    {
        cin >> g.vertices[i].data;
        g.vertices[i].firstarc = NULL;//初始化表头结点为空
    }
    for (k = 0; k < g.arcnum; k++)
    {
        cin >> v1 >> v2;
        i = LocateVex(g, v1); j = LocateVex(g, v2);//确定在g中的位置
        ArcNode *p1 = new ArcNode;//建立新的边结点
        p1->adjvex = j; p1->nextarc =g.vertices[i].firstarc;
        g.vertices[i].firstarc = p1;
        ArcNode* p2 = new ArcNode;//建立新的边结点
        p2->adjvex = i; p2->nextarc = g.vertices[j].firstarc;
        g.vertices[j].firstarc = p2;
    }
    /***********************************/
    for (i = 0; i < g.vexnum; ++i) {
        sort(g.vertices[i].firstarc); 保证有序，不依赖输入次序
    }//for
    return OK;
}//CreateUDG

void DestroyUDG(Graph& g)
{
    //you should do this
    for (int i = 0; i < g.vexnum; ++i)
    {
        ArcNode* p = g.vertices[i].firstarc;
        while (p)
        {
            ArcNode* r = p;
            p = p->nextarc;
            free(r);
        }
        g.vertices[i].firstarc = NULL;
    }

    g.vexnum = 0;g.arcnum = 0;
}

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