圖的儲存方式：

1.圖的陣列（鄰接矩陣）儲存表示，其中無向圖的儲存方式為對稱矩陣陣列，有向圖的儲存方式為非對稱矩陣陣列。求最短路徑時常常採用陣列儲存表示各點間的路徑。

2.邊集方法                    

例如：

edge[3].u=3,edge[0].v=4,edge[0].weight=5

3.圖的鄰接表儲存表示法

➢鄰接表是圖的一種鏈式儲存結構；

➢對圖中每個頂點建立一個單鏈表，第i個單鏈表中的結點表示依附於頂點vi的邊；由此通過遍歷每個頂點所對應的連結串列就可以遍歷所有的邊。

詳解以及陣列實現：https://www.cnblogs.com/ECJTUACM-873284962/p/6905416.html

但使用連結串列來實現鄰接表對於痛恨指標的的朋友來說，這簡直就是噩夢。於是便有了以結構體陣列形式來實現的方法，又稱

鏈式前向星。

4.鏈式前向星（鄰接表儲存的結構體陣列實現方法）

const int M=105;  //結點數
const int oo=100000000;
struct node {
       int to,next,weight;
} edge[M*100]; //M*100為邊數
int head[2*M]; //頭結點

構圖：
void add(int a, int b, int c) {
    	edge[tot].to=b;    edge[tot].weight=c;    edge[tot].next=head[a];    head[a]=tot++;
    } 

tot表示全域性變數，鄰接邊邊數；

head[a]儲存結點a的第一個邊的陣列edge下標，表示這條邊從a到edge[head[a]].to

edge[tot].next表示與這條邊相鄰的結點，初始化head[i]為-1，表示一開始沒有相鄰結點。

圖來源：https://www.cnblogs.com/LQ-double/p/5971323.html

如果要遍歷所有的點則for兩層迴圈就可以了。

—————————————————————————————我是分割線———————————————————————————————

圖的遍歷方式：

DFS（深度優先搜尋）：從某個狀態開始，不斷遍歷可以到達的狀態直到狀態無法轉移，然後回退到前一步的狀態，然後繼續轉移到其他狀態，如此不斷重複，直到到達指定的狀態或求出解。

1.找到初始點V0，訪問此結點。

2.依次找到所有與V0鄰接的未被訪問的結點並進行深度優先搜尋遍歷圖。

3.直到所有與V0相通的點都被訪問。

圖解：

先看一幅有向圖

可以發現，其遍歷的順序為

0->3->1->2->4

           其的概念就是一條路走到黑之後回頭到上一個路口換條路走

圖的表示方法包括鄰接表，鄰接矩陣等，鄰接矩陣表示的是用一個二維陣列表示圖的聯通，其中i行j列表示了i結點和j結點的聯通情況，如果其為1，說明是聯通的，如果其為0，反之；鄰接表表示的是一個一維陣列，但是陣列中每個列表包含著是連結串列；

看個圖加深理解：

其中a是有向圖／原圖，b是鄰接表表示圖，c是鄰接矩陣表示圖；

圖解來源：https://www.cnblogs.com/George1994/p/6399889.html

虛擬碼

遞迴實現

1. 訪問陣列初始化：visited[n] = 0
訪問頂點：visited[v] = 1
取v的第一個鄰接點w；
迴圈遞迴：
    while(w存在)
        if(w未被訪問過)
            從頂點w出發遞迴執行;
        w = v的下一個鄰接點;

非遞迴實現（使用棧的資料結構）

1.  棧初始化：visited[n] = 0
訪問頂點：visited[v] = 1
入棧
while(棧不為空)
    x = 棧的頂元素，並且出棧;
    if (存在並找到未被訪問的x的鄰接點w)
        訪問w：visited[w] = 1
        w進棧

實現程式碼（計算距離）

using namespace std;
struct node{
	int to,nex,val;
}edge[200005];
int head[100005],cnt;//head[i]代表  以i結點開始的第一條邊的下標 
void add(int u,int v,int w){
	edge[cnt].to=v;
	edge[cnt].val=w;
	edge[cnt].nex=head[u];
	head[u]=cnt;
	cnt++; 
}
void dfs(int t,int f,int w){
	for(int i=head[t];~i;i=edge[i].nex){
		int v=edge[i].to;
		if(v==f)continue;    //這裡的f代指父親結點，用來防止搜回去
		dis[v]=w+edge[i].val;
		dfs(v,t,w+edge[i].val);
	}
}
int main(){
	int n,m,i,j;
	memset(head,-1,sizeof(head));
	cin>>n>>m;
	for(i=1;i<=m;i++){
		int x,y,w;
		cin>>x>>y;
		w=1;
		add(x,y,w);
		add(y,x,w); 		//根據無向圖和有向圖兩種情況進行選擇性註釋此行
	}
	dfs(1,1,0);
	return 0;
}

BFS（寬度優先搜尋）：從某狀態開始訪問，不斷遍歷從該狀態訪問可以直接到達的狀態，然後從這些狀態出發，不斷訪問這些狀態可以直接到達的狀態，直到所有可以直接或間接到達的狀態都被訪問。（這種訪問方式需要藉助佇列實現）

先看一幅有向圖

可以發現，其遍歷的順序為

0->3->4->1->2

虛擬碼

非遞迴實現

1. 初始化佇列：visited[n] = 0
2. 訪問頂點：visited[v] = 1
3. 頂點v加入佇列
4. 迴圈：
    while(佇列是否為空)
        v = 佇列頭元素
        w = v的第一個鄰接點
        while(w存在)
            if(如果w未訪問)
                visited[w] = 1;
                頂點w加入佇列
                w = 頂點v的下一個鄰接點

上面的尋找下一個鄰接點，是尋找之前結點的下一個鄰接點，而不是當前的，否則就變成DFS了；

實現程式碼：

struct node{
	int to,nex,val;
}edge[200005];
int head[100005],cnt;//head[i]代表以i結點開始的第一條邊的下標 
void add(int u,int v,int w)
{
	edge[cnt].to=v;
	edge[cnt].val=w;
	edge[cnt].nex=head[u];
	head[u]=cnt;
	cnt++; 
}
int vis[100005];
queue<int>tp;
int main(){
	int n,m,i,j;
	memset(head,-1,sizeof(head));
	cin>>n>>m;
	for(i=1;i<=m;i++)
	{
		int x,y,w;
		cin>>x>>y;
		w=1;
		add(x,y,w);
//		add(y,x,w);		//根據無向圖和有向圖兩種情況進行選擇性註釋此行
	}
	vis[1]=1;
	tp.push(1);
	while(!tp.empty()){
		int f=tp.front();
		tp.pop();
		for(i=head[f];~i;i=edge[i].nex)
		{
			int v=edge[i].to;
			if(vis[v]) continue;
			vis[v]=vis[f]+1;
			tp.push(v);
		}
	}
	return 0;
}

鏈式前向星的優點在於可以通過該表示式:for(int i=head[u];~i;i=edge[i].next)，很好的對各個點所連有的點進行遍歷。通常在題目中只需執行起始頂點的相應bfs/dfs函式，即可完成對整個圖的遍歷。