數據結構圖的兩種存儲結構（鄰接矩陣和鄰接表）

數據結構中圖有多種存儲結構，這里我就來說其中較簡單的兩種，鄰接矩陣以及鄰接表。

鄰接矩陣：用一個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
*/