数据结构 图 图的遍历

（1）DFS

图采用邻接表的结构，头文件algraph.h如下：

#define MAX_VERTEX_NUM 20

typedef  int  InfoType;
typedef char  VertexType;

typedef enum ...{DG, DN, UDG, UDN}  GraphKind;

typedef struct ArcNode... {
    int adjvex;
    struct ArcNode *next;
    InfoType info;
} ArcNode;

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

typedef struct ... {
    AdjList vertex;
    int vexnum, arcnum;
    GraphKind kind;
} algraph;

bool flag[MAX_VERTEX_NUM];

DFS的递归算法如下：

#include  " algraph.h "

#include  " stdio.h "
#include  " stdlib.h "

void  createDN(algraph  & g) ... {}
void  createUDN(algraph  & g) ... {}
void  createUDG(algraph  & g) ... {}

// get the vertice name's index
int  locate(algraph g,  char  name) ... {
 for(int i = 0; i < g.vexnum; i++)...{
  if(name == g.vertex[i].data)...{
   return i;
  }
 }
 return -1;
}

void  createDG(algraph  & g) ... {
 printf("input the number of vertex and arcs: ");
 scanf("%d %d", &g.vexnum, &g.arcnum);
 fflush(stdin);
 
 int i = 0, j = 0, k = 0;
 
 printf("input the name of vertex: ");
 //init the vertex names
 for(i = 0; i < g.vexnum; i++)...{
  scanf("%c", &g.vertex[i].data);
  fflush(stdin);
  g.vertex[i].firstarc = NULL;
 }
 
 //construct the graph's adjacent link list
 char v1, v2;
 int w;
 ArcNode *p;

 printf("input the %d arcs v1 v2 and weight: ", g.arcnum);
 for(k = 0; k < g.arcnum; k++)...{
  scanf("%c %c %d", &v1, &v2, &w);
  fflush(stdin);
  i = locate(g, v1);
  j = locate(g, v2);

  //new a link node
  p = (ArcNode *)malloc(sizeof(ArcNode));
  p->adjvex = j;
  p->info = w;
  p->next = NULL;

  //insert the new node to the head of list
  if(!g.vertex[i].firstarc)...{
   g.vertex[i].firstarc = p;
  }else...{
   p->next = g.vertex[i].firstarc;
   g.vertex[i].firstarc = p;
  }
 }
}

// print the graph
void  printGraph(algraph g) ... {
 for(int i = 0; i < g.vexnum; i++)...{
  printf("the edges of vretice %c: ", g.vertex[i].data);
  ArcNode *p = g.vertex[i].firstarc;
  while(p)...{
   printf("%c(%d) ", g.vertex[p->adjvex].data, p->info);
   p = p->next;
  }
  printf(" ");
 }
}

void  createGragh(algraph  & g) ... {
 
 printf("please input the type of graph: ");
 scanf("%d", &g.kind);
 
 switch(g.kind)...{
 case DG: 
  createDG(g);
  printGraph(g);
  break;
 case DN: 
  createDN(g);
  break;
 case UDG: 
  createUDG(g);
  break;
 case UDN: 
  createUDN(g);
  break;
 }
}

void  visit(algraph g,  int  v) ... {
 printf("%c", g.vertex[v].data);
}

// dfs the graph
void  dfs(algraph g,  int  i,  void  ( *  f)(algraph,  int )) ... {
 flag[i] = 1;
 f(g, i);
 ArcNode *p = g.vertex[i].firstarc;
 while(p)...{
  int adj = p->adjvex;
  if(!flag[adj])...{
   dfs(g, adj, f);
  }
  p = p->next;
 }
}

void  dfsTraval(algraph g,  void  ( *  f)(algraph,  int )) ... {
 for(int i = 0; i < g.vexnum; i++)...{
  flag[i] = 0;
 }

 for(i = 0; i < g.vexnum; i++)...{
  if(!flag[i])...{
   dfs(g, i, f);
  }
 }
}

void  main() ... {
 algraph g;
 createGragh(g);

 void (* f)(algraph, int);
 f = visit;
 dfsTraval(g, f);
}

（2）BFS

使用队列对图节点进行遍历。

程序略。

关于图的遍历算法的复杂度：

1．  图的DFS：使用的是邻接表的结构时，算法的复杂度是O（n + e）；使用的是邻接矩阵的结构时，算法的复杂度是O（n²）。

2．  遍历图的过程实质是通过边或者弧找邻接点的过程，所以BDS和DFS的算法的复杂度相同，二者的区别在于对顶点的访问顺序不同。