圖的儲存

圖的儲存一般有兩種方式：鄰接矩陣和鄰接表

鄰接矩陣

設圖G(V,E)的頂點標號為0,1，……n-1，則令二維陣列G[n][n]的兩維分別表示圖的頂點標號。
即如果G[i][j]等於1，指頂點i和頂點j之間有邊，如果G[i][j]等於0，指頂點i和頂點j之間沒有邊，
如果為有權圖，則令G[i][j]存放邊權。
但如果題目中頂點數過大，可能會造成記憶體超限。

鄰接表

圖的常用儲存結構之一，由表頭結點和表結點兩部分組成，其中表頭結點儲存圖的各頂點，
表結點用單向連結串列儲存表頭結點所對應頂點的相鄰頂點（也就是表示了圖的邊）。
在有向圖裡表示表頭結點指向其它結點（a->b）,無向圖則表示與表頭結點相鄰的所有結點（a—b）

//表頭結點（表示圖的頂點）  
struct vnode{  
       char data;             //頂點資料，這裡用字元表示  
       struct arcnode * firstarc;   //指標指向第一條邊   
};  
//表結點（表示圖的邊）  
struct arcnode{  
       int wt;           //權重  
       int adjvex;     //頂點下標  
       struct arcnode *nextarc;   //指標指向下一條邊  
};  
typedef struct arcnode * Arc;  
//圖  
 

struct mgraph{  
       struct vnode vexs[100];  
       int vexsnum,arcnum;     //頂點數，邊數  
} *g;  
typedef struct mgraph* Graph;  

圖的遍歷

用DFS遍歷圖

沿著一條路徑直到無法繼續前進，才退回到路徑上離當前頂點最近的還存在未訪問分支頂點的岔道口，並前往訪問那些未訪問的分支節點，直至遍歷完成
* 連通分量：在無向圖中，如果兩個頂點可以互相到達，則稱這兩個頂點連通，如果圖G（V，E）的任意兩個頂點都連通，則稱圖G為連通圖，
否則，稱圖G為非連通圖，且稱其中的極大連通子圖為連通分量。
* 強連通分量：在有向圖中，如果兩個頂點可以各自通過一條有向路徑到達另一個頂點，則稱這兩個頂點強聯通。如果一個圖的任意兩個頂點都強聯通，
則稱這個圖為強連通圖；否則這個圖為非強連通圖，且稱其中的極大連通子圖為強聯通分量。

虛擬碼
DFS(u){
    vis[u]=true;
    for(從u出發能到達的所有頂點v)
        if(vis[v]==false)
        DFS(v);
}
DFSTrave(G){
    for(G的所有頂點u)
        if(vis[u]==false)
        DFS(u);
}
鄰接矩陣實現
const int maxv=1000;
const int inf=1000000;
int n,G[maxv][maxv];
bool vis[maxv]={false};
void dfs(int u,int depth){
    vis[u]=true;
    for(int v=0;v<n;v++){
        if(vis[v]==false&&G[u][v]!=inf){
            dfs(v,depth+1);
        }
    }
}
void dfstrave(){
    for(int u=0;u<n;u++){
        if(vis[u]==false){
            dfs(u,1);
        }
    }
}
鄰接表實現
vector<int> Adj[maxv];
int n;
bool vis[maxv] = {false};
void dfs(int u,int depth){
    vis[u] =true;
    for(int i=0;i<Adj[u].size();i++){
        int v=Adj[u][i];
        if(vis[v]==false){
            dfs(v,depth+1);
        }
    }
}
void dfstrave(){
    for(int u=0;u<n;u++){
        if(vis[u]==false){
            dfs(u,1);
        }
    }
}

用BFS遍歷圖

類似樹的遍歷，遍歷圖需要使用一個佇列，通過反覆取出隊首頂點，將該頂點可到達的未曾加入過佇列的頂點全部入隊，直到佇列為空時遍歷結束。

虛擬碼
BFS(u){
    queue q;
    inq[u]=true;
    while(q非空){
        取出q的隊首元素加以訪問;
        for(從u出發能到達的所有頂點v)
        if(inq[v]==false){
            將v入隊;
            inq[v]=true;
        }
    }
}
BFSTrave(G){
    for(G的所有頂點u)
        if(inq[u]==false)
    {
        BFS(u);
    }
}
鄰接矩陣實現
int n,G[maxv][maxv];
bool inq[maxv]={false};
void BFS(int u){
    queue<int> q;
    q.push(u);
    inq[u]=true;
    while(!q.empty()){
        int u.q.front();
        q.pop();
        for(int v=0;v<n;v++){
            if(inq[v]==false&&G[u][v]!=inf){
                q.push(v);
                inq[v]=true;
            }
        }
    }
}
void BFSTrave(){
    for(int u=0;u<n;u++){
        if(inq[u]==false){
            BFS(q);
        }
    }
}
鄰接表實現
vector<int> Adj[maxv];
int n;
bool inq[maxv]={false};
void BFS(int u){
    queue<int> q;
    q.push(u);
    inq[u]=true;
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=0;i<Adj[u].size();i++){
            int v=Adj[u][i];
            if(inq[v]==false){
                q.push(v);
                inq[v]=true;
            }
        }
    }
}
void BFSTrave(){
    for(int u=0;u<n;u++){
        if(inq[u]==false){
            BFS(q);
        }
    }
}

例子：

#include<bits/stdc++.h>  
using namespace std;  
typedef struct  
{  
    int edges[100][100];///鄰接矩陣  
    int n;  
    int e;  
}graph;  
bool vis[100];///訪問陣列  
void creategraph(graph &G)  
{  
    int i,j;  
    int s,t;  
    int v;  
    for(i=0;i<G.n;i++)  
    {  
        for(j=0;j<G.n;j++)  
        {  
            G.edges[i][j]=0;///鄰接表初始化  
        }  
        vis[i]=false;///訪問陣列初始化  
    }  
    for(i=0;i<G.e;i++)  
    {  
        cin>>s>>t>>v;///讀入頂點數邊數和權值  
        G.edges[s][t]=v;///賦值  
    }  
}  
void dfs(graph G,int v)  
{  
    int i;  
    printf("%d ",v);  
    vis[v]=true;///訪問第v個定點，並將訪問陣列置為true  
    for(i=0;i<G.n;i++)  
    {  
        if(G.edges[v][i]!=0&&vis[i]==false)  
        {  
            dfs(G,i);///如果i未被訪問遞迴呼叫dfs  
        }  
    }  
}  
void bfs(graph G,int v)  
{  
    queue<int>Q;  
    printf("%d ",v);  
    vis[v]=true;  
    Q.push(v);  
    while(!Q.empty())  
    {  
        int i,j;  
        i=Q.front();///取隊頭元素  
        Q.pop();///隊頭元素出隊  
        for(j=0;j<G.n;j++)  
        {///檢查所有鄰接點  
            if(G.edges[i][j]!=0&&vis[j]==false)  
            {  
                printf("%d ",j);  
                vis[j]=true;  
                Q.push(j);  
            }  
        }  
    }  
}  
int main()  
{  
    int n,e;  
    while(1)  
    {  
        puts("輸入圖的頂點數和邊數：");  
        cin>>n>>e;  
        graph G;  
        G.n=n;  
        G.e=e;  
        creategraph(G);  
        puts("輸出深度優先遍歷序列：");  
        dfs(G,0);  
        puts("\n");  
        creategraph(G);  
        puts("輸出廣度優先遍歷序列：");  
        bfs(G,0);  
        puts("\n");  
    }  
    return 0;  
}