用邻接表实现深度和广度搜索

 //=======================================================================
//Use Adjacency List Implement DFS And BFS
//BY:CHLAWS   
//TIME:08-8-4
//PS:transshipment don't delete this headmark
//=======================================================================

 

#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 20
int visited[MAX_VERTEX_NUM];

typedef char VertexType;
typedef struct ArcNode{
 int adjvex;       //该弧指向的顶点位置 
 struct ArcNode *nextarc;   //指向下一个表(边)结点 
 int info;       //权值
}ArcNode;  //边结点类型

typedef struct VNode{
 VertexType data;
 ArcNode *firstarc;
}VNode,AdjList[MAX_VERTEX_NUM];

typedef struct{
 AdjList vertices;  //邻接表
 int vexnum,arcnum; //顶点数和弧(边)数
}ALGraph;

#define MAXQSIZE MAX_VERTEX_NUM
typedef struct SQNode{
 VertexType base[MAXQSIZE];
 int front;
 int rear;
}SqQueue;

void InitQueue(SqQueue& Q)
{ 
 for(int ix=0; ix<MAXQSIZE; ++ix)
 {
  Q.base[ix] = 0;
 }
 Q.front = Q.rear = 0;
}

int LocateVex(ALGraph G,char u);
void CreateALGraph_adjlist(ALGraph &G);
void DFSTraverse(ALGraph G);
void DFS(ALGraph G, int v);
void BFSTraverse(ALGraph G);
void BFS(ALGraph G,int v);

void main()
{
 ALGraph G;
 printf("/n/n//===================创建邻接表===========================///n/n");
 CreateALGraph_adjlist(G);
 printf("/n/n//===================深度优先搜索===========================///n/n");
 DFSTraverse(G);
 printf("/n/n//===================广度优先搜索===========================///n/n");
 BFSTraverse(G);
}

//查找符合的数据在数组中的下标
int LocateVex(ALGraph G,char u)
{
 int i;
 for (i=0;i<G.vexnum;i++)
 {
  if(u==G.vertices[i].data)
   return i;
 }
 if (i==G.vexnum)
 {
  printf("Error u!/n");
  exit(1);
 }
 return 0;
}
void CreateALGraph_adjlist(ALGraph &G)
{ 
 int i,j,k,w;  char v1,v2;
 ArcNode *p;
 printf("Input vexnum & arcnum:/n");
 scanf("%d,%d",&G.vexnum,&G.arcnum);
 printf("Input Vertices:/n");
 for (i=0;i<G.vexnum;i++)
 {
  fflush(stdin);
  scanf("%c",&G.vertices[i].data);
  G.vertices[i].firstarc=NULL;
 }
 printf("Input Arcs(v1,v2,w):/n");
 for (k=0;k<G.arcnum;k++)
 {
  fflush(stdin);
  scanf("%c,%c,%d",&v1,&v2,&w);
  i=LocateVex(G,v1);
  j=LocateVex(G,v2);
  p=(ArcNode*)malloc(sizeof(ArcNode));
  p->adjvex=j;
  p->info = w;
  p->nextarc=G.vertices[i].firstarc;
  G.vertices[i].firstarc=p;
 } return;
}
//思路:
/****************************************************************************
** 使用广度优先搜索在访问了起始顶点 v 之后，          
** 由 v 出发，依次访问 v 的各个未曾被访问过的邻接顶点 w1, w2, …, wt，
** 然后再顺序访问 w1, w2, …, wt 的所有还未被访问过的邻接顶点。
** 再从这些访问过的顶点出发，再访问它们的所有还未被访问过的邻接顶点，
** … 如此做下去，直到图中所有顶点都被访问到为止。
*****************************************************************************/
void BFSTraverse(ALGraph G)
{
 int v;
 for (int v=0;v<G.vexnum;++v)
  visited[v]=0;
 for (v=0;v<G.vexnum;++v)
  if (!visited[v]) BFS(G,v);
}

void BFS(ALGraph G,int v)
{
 ArcNode *p; SqQueue Q;
 InitQueue(Q);
 printf("%c",G.vertices[v].data);
 visited[v]=1;
 Q.base[Q.rear]=v;
 Q.rear=(Q.rear+1)%MAXQSIZE;
 while (Q.front!=Q.rear)
 {
  v=Q.base[Q.front];
  Q.front=(Q.front+1)%MAXQSIZE;
  p=G.vertices[v].firstarc;

  while (p)
  { 
   if (!visited[p->adjvex])
   {
    printf("%c",G.vertices[p->adjvex].data);
    visited[p->adjvex]=1;
    Q.base[Q.rear]=p->adjvex;
    Q.rear=(Q.rear+1)%MAXQSIZE;
   }
   p=p->nextarc;
  }
 }
}

/*
DFS刚好相反,仔细理解就能明白
*/
void DFSTraverse(ALGraph G)
{
 for(int ix=0; ix < G.vexnum; ++ix)
 {
  visited[ix] = 0;
 }
 for(int ver=0; ver < G.vexnum; ++ver)
 {
  if(!visited[ver]) DFS(G,ver);
 }
}

void DFS(ALGraph G, int v)
{
 printf("pos:[%d] data :%c/n",v,G.vertices[v].data);
 visited[v] = 1;

 ArcNode *pArc;
 pArc = G.vertices[v].firstarc;
 while(pArc)
 {
  if(!visited[pArc->adjvex]) DFS(G,pArc->adjvex);
  pArc = pArc->nextarc;
 }
}
//DFS 搜索结果
/*
Input vexnum & arcnum:
9,10
Input Vertices:
a
b
c
d
e
f
g
h
i
Input Arcs(v1,v2 & w):
a,b,1
a,c,1
a,d,1
b,e,1
b,c,1
e,g,1
f,d,1
f,c,1
f,h,1
h,i,1
pos:[0] data :a
pos:[3] data :d
pos:[2] data :c
pos:[1] data :b
pos:[4] data :e
pos:[6] data :g
pos:[5] data :f
pos:[7] data :h
pos:[8] data :i
请按任意键继续. . .
*/