图的存储结构

最近在复习数据结构

今天把图的一些数据结构重写了遍

现在拿出来给大家分享 也是能记录我复习的一个过程

中间有错误的地方请大家指出

---

 

我们知道图有好几种分法,

当然最重要的一种就是有向图和无向图

这里主要介绍下无向图的数据结构

这里推荐2中方式的数据结构

一个是邻接矩阵一个是邻接表

邻接矩阵就是用矩阵来存放图,   2点间有边的在矩阵中就为1 否则为0

 

而邻接表其实是用链式的方式,把每一个点做为链头,然后把和他有关连的点连在一个链中

这里邻接矩阵是唯一的表示 而邻接表的表示不唯一.

 

#include <stdio.h>
#include <stdlib.h>
#define MAX 100

typedef struct   //邻接图每个点的结构
{
    int no;      //点的编号
    int info;    //点的信息 假定为一个数,在这里程序中暂不使用
}Vertex;

typedef struct   //邻接图的结构
{ 
    int edges[MAX][MAX];   //邻接图
    int vernum,arcnum;//顶点数和弧数
    Vertex vers[MAX];  //每个点的内容 点的信息,暂不使用
}MGraph;

void CreateMGraph(MGraph *&m,int map[][3],int ver,int arc)  //由输入来建立邻接图
{
    m=(MGraph*)malloc(sizeof(MGraph));
    m->arcnum=arc;
    m->vernum=ver;
    int i,j;
    for(i=0;i<ver;i++)
        for(j=0;j<ver;j++)
            m->edges[i][j]=0;
    for(i=0;i<arc;i++)
    {
        m->edges[map[i][0]][map[i][1]]=1;
        m->edges[map[i][1]][map[i][0]]=1;
    }
    for(i=0;i<ver;i++)
    {
        for(j=0;j<ver;j++)
            printf("%d",m->edges[i][j]);
        printf(" ");
    }
    return;
}

typedef struct ANode   //邻接表 每个节点的结构
{
    int adjvex;        //该点的编号
    struct ANode *next; //指向下个点
    int info;
}Arcnode;

typedef struct Vnode   //每个点的邻接表 
{                           
    Vertex *data;       //起始点的结构
    Arcnode *firstart; //起始点后的节点
}VNode;

//typedef VNode AdjList[MAX];

typedef struct   //邻接表的结构
{
    VNode *adjlist[MAX];  //由每个邻接点的邻接表构成一个大的邻接表
    int ver,arc;    //VER是点的个数, ARC是边的个数
}ALGraph;

void CreateALGraph(ALGraph *&m,int map[][3],int ver,int arc)  //由输入来建立邻接表
{
    int i,j;
    int a,b;
    m=(ALGraph*)malloc(sizeof(ALGraph));
    m->ver=ver;
    m->arc=arc;
    for(i=0;i<ver;i++)
    {
        VNode *g;
        g=(VNode*)malloc(sizeof(Vnode));  //这里我本想用g->firstart=NULL好象这样不行 可书上是这样写 
        g->firstart=NULL;  //最后还是这样写比较好点
        m->adjlist[i]=g;
    }
    for(i=0;i<arc;i++)
    {
        for(j=0;j<2;j++)  
        {
            if(j==0)
            {
                a=map[i][0];
                b=map[i][1];
            }
            else           //这里是为了建立表时 使无向图的两个顶点都能建立相对的节点
            {
                a=map[i][1];
                b=map[i][0];
            }

            m->adjlist[a]->data->no=a;
            VNode *q;
            q=(VNode*)malloc(sizeof(VNode));
            Arcnode *p;
            p=(Arcnode*)malloc(sizeof(Arcnode));
            q=m->adjlist[a];
            if(q->firstart==NULL)
            {
                p->adjvex=b;
                p->next=NULL;
                q->firstart=p;        
            }
            else
            {
                p=q->firstart;
                while(p->next!=NULL)
                    p=p->next;
                Arcnode *k;
                k=(Arcnode*)malloc(sizeof(Arcnode));
                k->adjvex=b;
                k->next=NULL;
                p->next=k;
            }
        }
    }

    Arcnode *z;
    z=(Arcnode*)malloc(sizeof(Arcnode));
    for(i=0;i<ver;i++)
    {
        printf("!!%d",m->adjlist[i]->data->no);
        z=m->adjlist[i]->firstart;
        while(z!=NULL)
        {
            printf("--->%d",z->adjvex);
            z=z->next;
        }
        printf(" ");
    }
    return;
}

void MtoL(MGraph *m,ALGraph *&g)  //这里是邻接图转邻接表的过程
{                                                        //这个包括下面的邻接表转邻接图的过程 都可以转成他们自己建立的过程
    int i,j;                           //这里专门写他们直接转换, 而不是通过转换成一个数组,是为了学习的原因
    int ver,arc;
    g=(ALGraph*)malloc(sizeof(ALGraph));
    ver=m->vernum;
    arc=m->arcnum;
    for(i=0;i<ver;i++)
    {
        VNode *p;
        p=(VNode*)malloc(sizeof(VNode));
        p->firstart=NULL;
        g->adjlist[i]=p;
    }
    for(i=0;i<ver;i++)
    {
        g->adjlist[i]->data->no=i;
        for(j=0;j<ver;j++)
        {
            if(m->edges[i][j]!=0)
            {
                VNode *p;
                p=(VNode*)malloc(sizeof(VNode));
                Arcnode *q;
                q=(Arcnode*)malloc(sizeof(Arcnode));
                p=g->adjlist[i];
                if(p->firstart==NULL)
                {
                    q->adjvex=j;
                    q->next=NULL;
                    p->firstart=q;
                }
                else
                {
                    q=p->firstart;
                    while(q->next!=NULL)
                        q=q->next;
                    Arcnode *z;
                    z=(Arcnode*)malloc(sizeof(Arcnode));
                    z->adjvex=j;
                    z->next=NULL;
                    q->next=z;
                }
            }
        }
    }
    Arcnode *k;
    k=(Arcnode*)malloc(sizeof(Arcnode));
    for(i=0;i<ver;i++)
    {
        printf("!!%d",g->adjlist[i]->data->no);
        k=g->adjlist[i]->firstart;
        while(k!=NULL)
        {
            printf("--->%d",k->adjvex);
            k=k->next;
        }
        printf(" ");
    }
}

void LtoM(MGraph *&m,ALGraph *g)  //邻接表转邻接图
{
    int i,j,ver,arc;
    int k;
    ver=g->ver;
    arc=g->arc;
    m=(MGraph*)malloc(sizeof(MGraph));
    for(i=0;i<ver;i++)
        for(j=0;j<ver;j++)
            m->edges[i][j]=0;

    for(i=0;i<ver;i++)
    {
        Arcnode *p;
        p=g->adjlist[i]->firstart;
        while(p!=NULL)
        {
            k=p->adjvex;
            p=p->next;
            m->edges[i][k]=1;
        }
    }
    for(i=0;i<ver;i++)
    {
        for(j=0;j<ver;j++)
            printf("%d",m->edges[i][j]);
        printf(" ");
    }
}
int main()
{
    MGraph *m;
    ALGraph *am;
    int map[MAX][3];
    int i,j;
    int ver,arc;
    printf(" input ver arc ");
    scanf("%d%d",&ver,&arc);   //输入 图有多少点 和多少 边
    for(i=0;i<arc;i++)
        scanf("%d %d",&map[i][0],&map[i][1]);  //把有连线的点输进来, 中间要有空格   
    /*   //这里可以根据不同需要选用不同函数
                     CreateMGraph(m,map,ver,arc);
    CreateALGraph(am,map,ver,arc);
    MtoL(m,am);
    LtoM(m,am);
                    */
    return 0;
}

 关与图的存储结构就先写到这

慢慢会上传更多的关于数据结构的程序