圖的鄰接表存儲及遍歷

Ⅰ 採用鄰接表存儲的圖的深度優先遍歷演算法類似於二叉樹的先序遍歷，為什麼是先序呢

這是因為圖的深度優先遍歷演算法先訪問所在結點，再訪問它的鄰接點。與二叉樹的先序遍歷先訪問子樹的根結點，再訪問它的孩子結點（鄰接點）類似。圖的廣度優先遍歷演算法類似於二叉樹的按層次遍歷。

先序遍歷也叫做先根遍歷、前序遍歷，可記做根左右（二叉樹父結點向下先左後右）。

首先訪問根結點然後遍歷左子樹，最後遍歷右子樹。在遍歷左、右子樹時，仍然先訪問根結點，然後遍歷左子樹，最後遍歷右子樹，如果二叉樹為空則返回。

例如，下圖所示二叉樹的遍歷結果是：ABDECF。

(1)圖的鄰接表存儲及遍歷擴展閱讀：

遍歷種類：

一、NLR：前序遍歷(Preorder Traversal 亦稱（先序遍歷）），訪問根結點的操作發生在遍歷其左右子樹之前。

二、LNR：中序遍歷(Inorder Traversal)，訪問根結點的操作發生在遍歷其左右子樹之中（間）。

三、LRN：後序遍歷(Postorder Traversal)，訪問根結點的操作發生在遍歷其左右子樹之後。

注意：

由於被訪問的結點必是某子樹的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解釋為根、根的左子樹和根的右子樹。NLR、LNR和LRN分別又稱為 先根遍歷、中根遍歷和後根遍歷。

Ⅱ n個頂點e條邊的圖G用鄰接表存儲，則求每個頂點入度的時間復雜度為查了好幾個地方的答案，答案大部分

O(n+e)是對的，O(n*n)是用鄰接矩陣存儲時的時間復雜度。
演算法就是遍歷每一條邊，然後把每條邊的終點的入度+1.
在鄰接表中，就是要依次訪問每個頂點，然後在每個頂點中依次訪問每條邊，把這些邊的終點的入度+1。也就是每個頂點和每條邊依次要各訪問一遍，所以時間復雜度是O(n+e)。
在鄰接矩陣中，演算法需要遍歷鄰接矩陣的每一個點，而鄰接矩陣有n*n個點，所以時間復雜度是O(n*n)。
有什麼不懂的可以追問。

Ⅲ 如下圖表示的是用鄰接表存儲的圖，畫出此圖，並寫出從A點開始按廣度優先演算法遍歷該圖的結果（附上過程）

廣度優先遍歷：ABDFEC
1、A的鄰接點B和D
2、B的鄰接點D和F，D已經遍歷，只訪問F
3、D的鄰接點E
4、F的鄰接點E，已經遍歷
5、E無鄰接點
6、最後掃描所有頭結點C未訪問，再從C開始遍歷，C的鄰接點DA都已遍歷。

Ⅳ 在用鄰接表表示圖時,對圖進行深度優先搜索遍歷的演算法的時間復雜度為()

因為當相鄰矩陣的大部分被破壞時，矩陣中的所有元素都需要掃並追蹤到，且元素個數為n＾2，自然演算法為O（n＾2）。

所以鄰接表只存儲邊或弧，如果掃描鄰接表，當然會得到O（n＋e）其中n是頂點的數量，e的邊或弧的數量。

設有n個點，e條邊

鄰接矩陣：矩陣包含n＾2個元素，在演算法中共n個頂點，對每個頂點都要遍歷n次，所以時間復雜度為O（n＾2）。

鄰接表：包含n個頭結點和e個表結點，演算法中對所有結點都要遍歷一次，所以時間復雜度為O（n+e）順便，對於廣度優先演算法的時間復雜度，也是這樣。

(4)圖的鄰接表存儲及遍歷擴展閱讀：

鄰接表是圖的最重要的存儲結構之一，描述了圖上的每個點。創建一個容器對於每一個圖的頂點（n頂點n容器）和節點在第i個容器包含所有相鄰頂點的頂點Vi。事實上，我們經常使用的鄰接矩陣是一個鄰接表的邊集不離散化每一個點。

在有向圖中，描述每個點與另一個節點連接的邊(在a點->點B)。

在無向圖中，描述每個點上的所有邊（A點和B點的情況）

鄰接表對應的圖存儲方法稱為邊集表。此方法將所有邊存儲在容器中。

Ⅳ 鄰接表存儲時，空間復雜度O( n+e)，還是O(n)

O(n+e)，取n次最小權，每次取完會進行n次更新。如果能達到o（n+e），就不需要O(n)。

在有向圖中，描述每個點向別的節點連的邊（點a->點b這種情況）。在無向圖中，描述每個點所有的邊。與鄰接表相對應的存圖方式叫做邊集表，這種方法用一個容器存儲所有的邊。

對於有向圖，vi的鄰接表中每個表結點都對應於以vi為始點射出的一條邊。因此，將有向圖的鄰接表稱為出邊表。

(5)圖的鄰接表存儲及遍歷擴展閱讀：

n個頂點e條邊的有向圖，它的鄰接表表示中有n個頂點表結點和e個邊表結點。（因為有向圖是單向的）

在有向圖中，為圖中每個頂點vi建立一個入邊表的方法稱逆鄰接表表示法。入邊表中的每個表結點均對應一條以vi為終點(即射入vi)的邊。

n個頂點e條邊的有向圖，它的逆鄰接表表示中有n個頂點表結點和e個邊表結點。

Ⅵ 圖的鄰接表的時間復雜度問題

其實是O(n + e)，頂點加上邊數
那個O(n*e)的意思是每次插入一條邊，都需要重新查找邊所包含兩個頂點信息對應的下標，正常的演算法沒這么弱智吧，不需要頂點信息即為頂點的下標，用散列等方法可以不用這樣的
用鄰接矩陣構造圖時，若存儲的是一個無向圖，則時間復雜度為O(n^2 + n*e)，其中，對鄰接矩陣的初始化耗費的時間為O(n^2);
對於DFS,BFS遍歷來說，時間復雜度和存儲結構有關：
n表示有n個頂點，e表示有e條邊。
1.若採用鄰接矩陣存儲，
時間復雜度為O(n^2);
2.若採用鄰接鏈表存儲，建立鄰接表或逆鄰接表時，

若輸入的頂點信息即為頂點的編號，則時間復雜度為O(n+e);
若輸入的頂點信息不是頂點的編號，需要通過查找才能得到頂點在圖中的位置，則時間復雜度為O(n*e);

Ⅶ c語言圖的遍歷，鄰接表存儲，深度，廣度優先遍歷

（1） 圖的建立，按採用鄰接表作為存儲結構。
（2） 從指定頂點出發進行深度優先搜索遍歷。
（3） 從指定頂點出發進行廣度優先搜索遍歷。

#include"stdio.h"
#include"string.h"
#include"stdlib.h"
#include"math.h"

#define MAX_INT 1000
#define MAX_VERTEX_NUM 20
#define MAX_QUEUE_NUMBER 20

typedef struct ArcNode
{
int adjvex;
double adj;
struct ArcNode *nextarc;
}ArcNode;
typedef struct VexNode
{
char szName[40];
ArcNode *firstarc;
}VexNode,AdjList[MAX_VERTEX_NUM];
typedef struct
{
AdjList vexs;
int vexnum,arcnum;
}Net;
//定義隊列
typedef struct{
int *elem;
int front, rear;
}Queue;
void InitQueue(Queue &Q)
{
Q.elem = new int[MAX_QUEUE_NUMBER];
Q.front = Q.rear = 0;
}
int EmptyQueue(Queue Q)
{
if(Q.front==Q.rear)
return 0;
else
return 1;
}
void DestroyQueue(Queue &Q){
delete []Q.elem;
Q.front = Q.rear = 0;
}

void EnterQueue(Queue &Q, int e)
{
if((Q.rear + 1)%MAX_QUEUE_NUMBER != Q.front)
Q.elem[Q.rear ] = e;
else
printf("隊列滿!\n");
Q.rear = (Q.rear + 1)%MAX_QUEUE_NUMBER;
}
void LeaveQueue(Queue &Q, int &e)
{
if(Q.rear != Q.front)
e = Q.elem[Q.front];
else
printf("隊列空!\n");
Q.front = (Q.front+1)%MAX_QUEUE_NUMBER;
}
int LocateVex(Net ga,char *name)
{
int i;
for(i=0;i<ga.vexnum;i++)
if(strcmp(name,ga.vexs[i].szName)==0)
return i;
return -1;

}
void crt_net(Net &ga)
{
ArcNode *p;
char name1[40],name2[40];
int i,j,k;
double w;
printf("請輸入頂點數和弧數：");
scanf("%d%d",&ga.vexnum,&ga.arcnum);
printf("請依次輸入頂點名：\n");
for(i=0;i<ga.vexnum;i++)
{
scanf("%s",ga.vexs[i].szName);
ga.vexs[i].firstarc=NULL;
}
for(k=0;k<ga.arcnum;k++)
{
printf("請輸入相鄰的兩個定點和權值：");
scanf("%s%s%lf",name1,name2,&w);
i=LocateVex(ga,name1);
j=LocateVex(ga,name2);
p=new ArcNode;
p->adjvex=j;
p->adj=w;
p->nextarc=ga.vexs[i].firstarc;
ga.vexs[i].firstarc=p;
}
}

void DFS(Net ga,char *name,int *visited)
{
int v,w;
ArcNode *p;
v=LocateVex(ga,name);
visited[v]=1;
printf("%s ",ga.vexs[v].szName);
p=ga.vexs[v].firstarc;
while(p!=NULL)
{
w=p->adjvex;
if(visited[w]==0)
DFS(ga,ga.vexs[w].szName,visited);
p=p->nextarc;
}

}
void DFSTravel(Net ga,char *name)
{
int v,k=0;
int visited[20];
for(v=0;v<ga.vexnum;v++)
visited[v]=0;
for(v=LocateVex(ga,name);k!=2;v=(v+1)%(ga.vexnum-1))
{
if(v+1==LocateVex(ga,name))
k++;
if(visited[v]==0)
DFS(ga,ga.vexs[v].szName,visited);

}
}

void BFSTravel(Net ga,char *name)
{
ArcNode *p;
int v,w,u,k=0;
Queue Q;
int visited[20];
for(v=0;v<ga.vexnum;v++)
visited[v]=0;
InitQueue(Q);
for(v=LocateVex(ga,name);k!=2;v=(v+1)%(ga.vexnum-1))
{
if(v+1==LocateVex(ga,name))
k++;
if(visited[v]==0)
{
visited[v]=1;
printf("%s ",ga.vexs[v].szName);
EnterQueue(Q,v);
while(EmptyQueue(Q)!=0)
{
LeaveQueue(Q,u);
p=ga.vexs[u].firstarc;
while(p!=NULL)
{
w=p->adjvex;
if(visited[w]==0)
{
printf("%s ",ga.vexs[w].szName);
visited[w]=1;
EnterQueue(Q,w);
}
p=p->nextarc;
}
}
}

}
}

void main()
{
char name[40];
Net ga;
crt_net(ga);
printf("請輸入深度優先遍歷開始點的名：");
scanf("%s",name);
printf("深度優先遍歷：");
DFSTravel(ga,name);
printf("\n");
printf("請輸入廣度優先遍歷開始點的名：");
scanf("%s",name);
printf("廣度優先遍歷：");
BFSTravel(ga,name);
printf("\n");

}