数据结构图的两种存储结构（邻接矩阵和邻接表）

数据结构中图有多种存储结构，这里我就来说其中较简单的两种，邻接矩阵以及邻接表。

邻接矩阵：用一个n*n的矩阵来表示一张图，矩阵的横纵坐标均表示图的点，例如矩阵第i行第j列数字为1，在无向图中表示点i与点j之间有一条连线，而在有向图中表示在图中有一条由i指向j的边。这个点数字为几，代表有几条边。

邻接表：用链表的形式来表示图，这个表头结点所对应的顶点存在相邻顶点，则把相邻顶点依次存放于表头结点所指向的单向链表中。

下面分别给出了有向图的邻接矩阵以及无向图的邻接表实现方法。

邻接矩阵：

//数据结构链接矩阵
#include<iostream>
#define MAXN 100
using namespace std;
typedef struct{
    char vexs[MAXN];
    int map[MAXN][MAXN],visit[MAXN],degree[MAXN];
    int vexnum,arcnum;
}AMGraph;

int LocateVex(AMGraph &G,char e)
{
    for(int i=0; i<G.vexnum; ++i)
    {
        if(G.vexs[i] == e)
        {
            return i;
        }
    }
}

void InitMap(AMGraph &G)//建立邻接矩阵
{
    cout<<"请输入点数和边数：";
    cin>>G.vexnum>>G.arcnum;
    cout<<"请输入各点的名称："; 
    for(int i=0; i<G.vexnum; ++i)
    {
        cin>>G.vexs[i];
        G.visit[i] = 0; //初始化标记为0 
        G.degree[i] = 0; //初始化度为 0 
    }
    
    for(int i=0; i<G.vexnum; ++i)
        for(int j=0; j<G.vexnum; ++j)
            G.map[i][j] = 0;

    char v1,v2;
    cout<<"请输入每一条边："<<endl;
    for(int i=0; i<G.arcnum; ++i)
    {
        cin>>v1>>v2;
        int x,y;
        x = LocateVex(G,v1);//找到 v1的位置
        y = LocateVex(G,v2);//找到 v2的位置
        G.degree[x]++; //v1的度++
        G.degree[y]++; //v2的度++
        G.map[x][y] = 1;
    }
}

void DFS(AMGraph &G,int e)
{
    cout<<G.vexs[e]<<' ';
    for(int i=0; i<G.vexnum; ++i)
    {
        if(!G.visit[i] && G.map[e][i])
        {
            G.visit[i] = 1;
            DFS(G,i);
        }
    }
}

void BFS(AMGraph &G,int e)
{
    for(int i=0; i<G.vexnum; ++i)//初始化标记为0 
        G.visit[i] = 0;
    G.visit[e] = 1;//起点标记走过 
    
    int que[MAXN];
    int rear=0,front=0,t;
    que[rear++] = e;

    while(rear != front)
    {
        t = que[front++];
        front %= MAXN;
        cout<<G.vexs[t]<<' ';
        for(int i=0; i<G.vexnum; ++i)
        {
            if(!G.visit[i] && G.map[t][i])
            {
                que[rear++] = i;
                rear %= MAXN;
                G.visit[i] = 1;
            }
        }
    }
}

int main()
{
    AMGraph G;
    InitMap(G);
    cout<<"邻接矩阵为："<<endl;
    for(int i=0; i<G.vexnum; ++i)
    {
        for(int j=0; j<G.vexnum; ++j)
        {
            cout<<G.map[i][j]<<' ';
        }
        cout<<endl;
    }
    char a;
    bool flag = false;
    cout<<"请输入搜索的起点："<<endl;
    cin>>a;
    for(int i=0; i<G.vexnum; ++i)
    {
        if(G.vexs[i] == a)
        {
            flag = true;
            G.visit[i] = 1;
            cout<<"深度优先遍历结果：";
            DFS(G,i);//深搜
            cout<<endl;
            
            cout<<"广度优先遍历结果：";
            BFS(G,i);//广搜
            cout<<endl;
            cout<<"每个点的度分别为：";
            for(int j=0; j<G.vexnum; ++j)
                cout<<G.degree[j]<<' ';
            break;
        }
    }
    if(!flag)
        cout<<"无名字为"<<a<<"的点"<<endl;
    return 0;
}
 
/*
0 1
0 2
0 3
1 4
2 4
2 5
3 5
4 6
5 6
*/

邻接表：

#include<iostream>
#define MAXN 100
using namespace std;
typedef struct ArcNode{
    char adjvex;
    struct ArcNode *next;
}ArcNode;
typedef struct VNode{
    char data;
    ArcNode *frist;
}VNode,AdjList[MAXN];
typedef struct{
    AdjList vertices;
    int vexnum,arcnum;
    int visit[MAXN],degree[MAXN];
}ALGraph;

int LocateVex(ALGraph &G,char e)
{
    for(int i=0; i<G.vexnum; ++i)
        if(G.vertices[i].data == e)
            return i;
}

void InitMap(ALGraph &G)
{
    cout<<"请输入点数和边数：";
    cin>>G.vexnum>>G.arcnum;
    cout<<"请输入各点的名称：";
    for(int i=0; i<G.vexnum; ++i)
    {
        cin>>G.vertices[i].data;
        G.visit[i] = 0;
        G.degree[i] = 0;
        G.vertices[i].frist = NULL;
    }
    
    char v1,v2;
    cout<<"请输入每一条边："<<endl;
    for(int i=0; i<G.arcnum; ++i)
    {
        cin>>v1>>v2;
        int x,y;
        x = LocateVex(G,v1);
        y = LocateVex(G,v2);
        
        G.degree[x]++;
        G.degree[y]++;
        
        ArcNode *p1 = new ArcNode;
        p1->adjvex = y;
        p1->next = G.vertices[x].frist;
        G.vertices[x].frist = p1;
        
        ArcNode *p2 = new ArcNode;
        p2->adjvex = x;
        p2->next = G.vertices[y].frist;
        G.vertices[y].frist = p2;
    }
}

void DFS(ALGraph &G,int e)
{
    cout<<G.vertices[e].data<<' ';
    G.visit[e] = 1;
    ArcNode *p = new ArcNode;
    p = G.vertices[e].frist;
    while(p != NULL)
    {
        if(!G.visit[p->adjvex])
            DFS(G,p->adjvex);
        p = p->next;
    }
    delete p;
}

void BFS(ALGraph &G,int e)
{
    for(int i=0; i<G.vexnum; ++i)
        G.visit[i] = 0;
    G.visit[e] = 1;
    
    int rear = 0, front = 0,t;
    int que[MAXN];
    que[rear++] = e;
    while(rear != front)
    {
        t = que[front++];
        front %= MAXN;
        cout<<G.vertices[t].data<<' ';
        ArcNode *p = new ArcNode;
        p = G.vertices[t].frist;
        while(p != NULL)
        {
            if(!G.visit[p->adjvex])
            {
                G.visit[p->adjvex] = 1;
                que[rear++] = p->adjvex;
                rear %= MAXN;
            }
            p = p->next;
        }
    }
}

int main()
{
    ALGraph G;
    InitMap(G);
    char a;
    cout<<"请输入搜索的起点：";
    cin>>a;
    for(int i=0; i<G.vexnum; ++i)
    {
        if(G.vertices[i].data == a)
        {
            cout<<"深度优先遍历结果：";
            DFS(G,i);
            cout<<endl;
            
            cout<<"广度优先遍历结果：";
            BFS(G,i);
            cout<<endl;
            break;
        }
    }
    cout<<"每个点的度分别为：";
    for(int i=0; i<G.vexnum; ++i)
        cout<<G.degree[i]<<' ';
    cout<<endl;
    return 0;
}

/*
5 6
01234
0 1
0 3
1 2
1 4
2 3
2 4
*/