邻接矩阵与邻接表的相互转换

1. 编写一个程序，输出带权图的邻接矩阵，并能将该邻接矩阵转换成相应的邻接表，并输出该邻接表，带权图如下图所示。
2. 

具体效果如下：

2.1.编写一个算法，实现由已知的邻接表产生对应的邻接矩阵，并输出。
具体效果如下：

#include 
#include
#define MAXV 100
#define MaxSize 100
#define INF 327676
using namespace std;
typedef char InfoType;
typedef char ElemType;

//邻接矩阵声明
typedef struct
{
    int no;
    InfoType info;
} VertexType;
typedef struct
{
    int edges[MAXV][MAXV];
    int n,e;
    VertexType vexs[MAXV];
} MatGraph;
//邻接表声明
typedef struct ANode
{
    int adjvex;
    struct ANode *nextarc;
    int weight;
} ArcNode;
typedef struct Vnode
{
    InfoType info;
    ArcNode *firstarc;
} VNode;
typedef struct
{
    VNode adjlist[MAXV];
    int n,e;
} AdjGragh;
//创建邻接矩阵
void CreatrMat(MatGraph &g,int A[MAXV][MAXV],int n,int e)
{
    int i,j;
    g.n=n;
    g.e=e;
    for(i=0; i<g.n; i++)
        for(j=0; j<g.e; j++)
            g.edges[i][j]=A[i][j];
}
//输出邻接矩阵
void DispMat(MatGraph g)
{
    int i,j;
    for(i=0; i<g.n; i++)
    {
        for(j=0; j<g.e; j++)
        {
            if(g.edges[i][j]!=INF)
                printf("%4d",g.edges[i][j]);
            else
                printf("%4s","∞");
        }
        cout<<endl;
    }
}
//邻接矩阵转换为邻接表
void MatToList(MatGraph g,AdjGragh *&G)
{
    int i,j;
    ArcNode *p;
    G=(AdjGragh *)malloc(sizeof(AdjGragh));
    for(i=0; i<g.n; i++)
        G->adjlist[i].firstarc=NULL;
    for(i=0; i<g.n; i++)
    {
        for(j=g.e-1; j>=0; j--)
        {
            if(g.edges[i][j]!=0&&g.edges[i][j]!=INF)
            {
                p=(ArcNode *)malloc(sizeof(ArcNode));
                p->adjvex=j;
                p->weight=g.edges[i][j];
                p->nextarc=G->adjlist[i].firstarc;
                G->adjlist[i].firstarc=p;
            }
        }
    }
    G->n=g.n;
    G->e=g.e;
}
//输出邻接表
void DispAdj(AdjGragh *G)
{
    int i;
    ArcNode *p;
    for(i=0; i<G->n; i++)
    {
        p=G->adjlist[i].firstarc;
        printf("%3d: ",i);
        while(p!=NULL)
        {
            printf("%3d(%d) ",p->adjvex,p->weight);
            p=p->nextarc;
        }
        cout<<endl;
    }
}
//邻接表转换成邻接矩阵
void ListToMat(AdjGragh *G,MatGraph &g)
{
    int i;
    ArcNode *p;
    for(i=0; i<G->n; i++)
    {
        p=G->adjlist[i].firstarc;
        while(p!=NULL)
        {
            g.edges[i][p->adjvex]=p->weight;
            p=p->nextarc;
        }
    }
    g.n=G->n;
    g.e=G->e;
}
//主函数
int main()
{
    MatGraph g;
    AdjGragh *G;
    int A[MAXV][MAXV]= {{0,5,INF,7,INF,INF},{INF,0,4,INF,INF,INF},
                        {8,INF,0,INF,INF,9},{INF,INF,5,0,INF,6},
                        {INF,INF,INF,5,0,INF},{3,INF,INF,INF,1,0}
                        };
    printf("有向图G的邻接矩阵：\n");
    CreatrMat(g,A,6,6);
    DispMat(g);
    printf("图G的邻接矩阵转换成邻接表：\n");
    MatToList(g,G);
    DispAdj(G);
    printf("图G的邻接表转换成邻接矩阵：\n");
    ListToMat(G,g);
    DispMat(g);
    printf("图G的邻接表：\n");
    MatToList(g,G);
    DispAdj(G);
    return 0;
}