採用鄰接表存儲的圖的

A. 採用鄰接表存儲的圖的寬度優先遍歷演算法類似於二叉樹的()A.先序遍歷 B.中序遍歷 C . 後序遍歷

是啊，寬度優先就是訪問某頂點完後，將其所有鄰接的未訪問的頂點都訪問，這樣第一次訪問自己，第二次訪問的就是所有距離該頂點路徑長度為1的頂點，第三次訪問的就是所有距離該頂點路徑長度為2的頂點...
二叉樹的層次遍歷不就是從根開始，先訪問根，接著訪問所有第二層結點，再訪問所有第3層結點...，從路徑長度來看，不是也是0、1、2、....

B. 用鄰接表表示圖的廣度優先搜索時的存儲結構,通常採用（）結構來實現演算法

B。

廣度優先搜索相當於層次遍歷，深度優先搜索相當於先序優先遍歷，所以答案選擇B。

鄰接表表示的圖的廣度優先搜索一般採用隊列結構來實現演算法：

首先選擇一個起始節點，把它的臨界表中節點加入到隊列中，每次取出隊首元素，然後把該元素的鄰接表中的節點加入到隊列末尾，標記已遍歷過的節點，直到隊列中沒有節點為止，一般棧用於深度優先搜索，隊列用於廣度優先搜索。

(2)採用鄰接表存儲的圖的擴展閱讀：

深度優先搜索用一個數組存放產生的所有狀態。

（1） 把初始狀態放入數組中，設為當前狀態；

（2） 擴展當前的狀態，產生一個新的狀態放入數組中，同時把新產生的狀態設為當前狀態；

（3） 判斷當前狀態是否和前面的重復，如果重復則回到上一個狀態，產生它的另一狀態；

（4） 判斷當前狀態是否為目標狀態，如果是目標，則找到一個解答，結束演算法。

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

這是因為圖的深度優先遍歷演算法先訪問所在結點，再訪問它的鄰接點。與二叉樹的先序遍歷先訪問子樹的根結點，再訪問它的孩子結點（鄰接點）類似。圖的廣度優先遍歷演算法類似於二叉樹的按層次遍歷。
先序遍歷也叫做先根遍歷、前序遍歷，可記做根左右（二叉樹父結點向下先左後右）。
首先訪問根結點然後遍歷左子樹，最後遍歷右子樹。在遍歷左、右子樹時，仍然先訪問根結點，然後遍歷左子樹，最後遍歷右子樹，如果二叉樹為空則返回。
例如，下圖所示二叉樹的遍歷結果是：ABDECF。

(3)採用鄰接表存儲的圖的擴展閱讀：
遍歷種類：
一、NLR：前序遍歷(Preorder
Traversal
亦稱（先序遍歷）），訪問根結點的操作發生在遍歷其左右子樹之前。
二、LNR：中序遍歷(Inorder
Traversal)，訪問根結點的操作發生在遍歷其左右子樹之中（間）。
三、LRN：後序遍歷(Postorder
Traversal)，訪問根結點的操作發生在遍歷其左右子樹之後。
注意：
由於被訪問的結點必是某子樹的根，所以N(Node）、L(Left
subtree）和R(Right
subtree）又可解釋為根、根的左子樹和根的右子樹。NLR、LNR和LRN分別又稱為
先根遍歷、中根遍歷和後根遍歷。
參考資料來源：網路-先序遍歷

D. 如何用鄰接表存儲圖結構

我看不太懂這個程序，不過我有些過圖的鄰接表表示，看對你有沒有幫助吧。
#include <iostream>
#include <fstream>
#include <vector>

typedef int QElemTyep;
#include "queue.h"
using namespace std;
typedef int Status;
#define MAX_VERTEX_NUM 30 //圖的最大頂點數
enum BOOL {False,True};
BOOL visited[MAX_VERTEX_NUM]; //全局變數--訪問標志數組

typedef struct ArcNode{
//弧結點
int adjvex; //該弧所指向的頂點的位置
struct ArcNode *nextarc; //指向下一條弧的指針
InfoType *info; //保存邊的信息，可以簡單的改為 int w;
}ArcNode;
typedef struct VNode{
VertexType data;
ArcNode *firstarc;
}VNode,AdjList[MAX_VERTEX_NUM];

class Graph{
public: AdjList vertices; //記錄頂點信息，指向第一條依附該頂點的弧的指針
int vexnum,arcnum; //圖的當前頂點和弧數
int GraphKind; //圖的種類，0---無向圖，1---有向圖
Graph(int vexnum,int arcnum,int kind)
{
this->vexnum=vexnum;
this->arcnum=arcnum;
this->GraphKind=kind;
}
};
void CreateGraph(Graph &G,VertexType *V,ArcType *VR){
//構造鄰接表結構的圖G

int i;
ArcNode *s;
for(i=1;i<=G.vexnum;i++) //初始化指針數組
{
G.vertices[i].data=V[i];
G.vertices[i].firstarc=NULL;
}
for(i=1;i<=G.arcnum;i++)
{
s=(ArcNode *)malloc(sizeof(ArcNode)); //生成一個弧結點
s->nextarc=G.vertices[VR[i].start].firstarc; //插入到鄰接表中
s->adjvex=VR[i].end;
G.vertices[VR[i].start].firstarc=s;

if(G.GraphKind==0) {
//若是無向圖，再插入到終點的弧鏈中
s=(ArcNode *)malloc(sizeof(ArcNode));
s->nextarc=G.vertices[VR[i].end].firstarc;
s->adjvex=VR[i].start;
G.vertices[VR[i].end].firstarc=s;
}
}
}

E. 如下圖表示的是用鄰接表存儲的圖，畫出此圖，並寫出從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都已遍歷。

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

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

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

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

(6)採用鄰接表存儲的圖的擴展閱讀：

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

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

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

G. 圖的構造（用鄰接表儲存）

你程序中algraph G沒有申請空間....
改了下 在VC6.0下能運行的
#include"iostream"
#define Max 100
using namespace std;

struct arcnode //弧結點結構
{
int adjvex; //該弧所指向的頂點的位置
struct arcnode *nextarc; //指向下一條弧的指針
};

struct vexnode //頂結點結構
{
char data; //頂點信息
arcnode *firstarc; //指向第一條依附該頂點的弧
};

struct algraph //圖結構
{
vexnode vexlist[Max]; //頂點結點數組
int vexnum,arcnum; //圖的當前頂點數和弧數
};

int locate(algraph *G,char v) //返回該頂點在頂點數組中的位置
{
int i=0;
while(G->vexlist[i].data!=v)
i++;
return i;
}

void creatgraph(algraph *&G) //創建圖，用鏈接表儲存
{
cout<<"請輸入頂點數，邊數"<<endl;
G=new algraph;
cin>>G->vexnum>>G->arcnum;
cout<<"請輸入各頂點的信息"<<endl;
for(int i=0;i<G->vexnum;i++)
{
cin>>G->vexlist[i].data; // 輸入頂點
G->vexlist[i].firstarc=NULL; // 初始化鏈表頭指針為"空"
}
for(int k=0;k<G->arcnum;k++) // 輸入各邊並構造鄰接表
{
char sv,tv;
int i,j;
arcnode *pi;
cout<<"請輸入第"<<k+1<<"條弧的頭尾結點"<<endl;
cin>>sv>>tv;
i=locate(G,sv); j=locate(G,tv); //返回頭結點sv和尾結點tv在頂點結點數組中的位置
pi=new arcnode;
pi->adjvex=j;
pi->nextarc=G->vexlist[i].firstarc;
G->vexlist[i].firstarc=pi;
}
}

void main()
{
algraph *G;
creatgraph(G);
}

H. 鄰接表存儲結構適合存儲什麼樣的圖

圖的鄰接表數據類型描述如下：
const int N=maxn； // maxn表示圖中最大頂點數
const int E=maxe ； // maxe圖中最大邊數
struct Edge{
int u,v; //邊所鄰接的兩個頂點
int w; //邊的權值
int next; //邊指針，指向下一條邊的內存池地址
}edge[E]; // 靜態內存池，用於分配邊
int head[N]; // 表頭
int num; // 內存池的指針

I. 無向圖採用鄰接表存儲結構,編寫演算法輸出圖中各連通分量的節點序列

//按廣度優先非遞歸遍歷圖G。使用輔助隊列Q和訪問標志數組visited.僅適用於鄰接表結構
void BFSTraverse1(ALGraph G,void(* Visit)(char *))
{
int v,u;
ArcNode * p;//p指向表結點
LinkQueue Q;//鏈隊列類型
for (v=0; v<G.vexnum; ++v)
{
visited[v] = FALSE;//置初值為未被訪問
}
InitQueue(&Q);//初始化輔助隊列Q
for (v=0; v<G.vexnum; ++v)//如果是連通圖，只v=0就遍歷全圖
{
if (! visited[v])//v尚未被訪問
{
visited[v] = TRUE;//設v為已被訪問
Visit(G.vertices[v].data);//訪問v
EnQueue(&Q,v);//v入隊
while (! QueueEmpty(Q))//隊列不空
{
DeQueue(&Q,&u);//隊頭元素出隊並置為u
for (p=G.vertices[u].firstarc; p; p=p->next)//p依次指向u的鄰接頂點
{
if (! visited[p->data.adjvex])//u的鄰接頂點尚未被訪問
{
visited[p->data.adjvex] = TRUE;//該鄰接頂點設為已被訪問
Visit(G.vertices[p->data.adjvex].data);//訪問該鄰接頂點
EnQueue(&Q,p->data.adjvex);//入隊該鄰接頂點序號
}
}
}//while
}//if
}//for(v=......)
printf("\n");
}

J. 有向圖的鄰接表存儲如圖所示，請畫出其鄰接矩陣存儲結構

有向圖的鄰接表存儲如圖所示，其鄰接矩陣存儲如圖：