采用邻接表存储的图的

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. 有向图的邻接表存储如图所示，请画出其邻接矩阵存储结构

有向图的邻接表存储如图所示，其邻接矩阵存储如图：