无向图的 DFS 和 BFS实现 （以邻接表存储的图）

 #include <iostream>
 #include <queue>

 using namespace std;

 #define MaxVertexNum 10
 typedef int Vertex;
 typedef int WeightType;
 typedef char DataType;

 bool Visited[MaxVertexNum] = { false };

 //边的定义
 typedef struct ENode
 {
     Vertex V1, V2;    //有向边<V1,V2>
     WeightType Weight;    //权重
 }*Edge;

 //邻接点的定义
 typedef struct AdjVNode
 {
     Vertex AdjV;    //邻接点下标
     WeightType Weight;    //边权重
     struct AdjVNode *Next;    //指向下一个邻接点的指针
 }*PtrToAdjVNode;

 //顶点表头结点的定义
 typedef struct VNode
 {
     /* DataType Data;    //存顶点的数据，很多情况下，顶点无数据，此时Data可以不用出现 */
     struct AdjVNode *FirstEdge;    //边表头指针
 }AdjList[MaxVertexNum];

 //图结点的定义
 typedef struct GNode
 {
     int Nv;        //顶点数
     int Ne;        //边数
     AdjList G;  //邻接表表示的图
 }*LGraph;

 LGraph BuildGraph(int vertex_num, int edge_num)
 {
     LGraph Graph = (LGraph)malloc(sizeof(struct GNode));
     Graph->Nv = vertex_num;
     Graph->Ne = edge_num;
     for (int i = ; i < Graph->Nv; ++i)
         Graph->G[i].FirstEdge = NULL;    //初始化所有表头指针为NULL

     Edge E = (Edge)malloc(sizeof(struct ENode));
     for (int i = ; i < Graph->Ne; ++i)
     {
         printf("请输入第%d条边的起点和终点：", i+);
         cin >> E->V1 >> E->V2;
         E->Weight = ;

         //这种插入方法将会使下标大的在前，小的在后，所以遍历的时候下标大的会先遍历
         //插入边<V1,V2>
         PtrToAdjVNode NewNode1 = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
         NewNode1->AdjV = E->V2;
         NewNode1->Weight = E->Weight;
         NewNode1->Next = Graph->G[E->V1].FirstEdge;
         Graph->G[E->V1].FirstEdge = NewNode1;

         //无向图，还要插入边<V2,V1>
         PtrToAdjVNode NewNode2 = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
         NewNode2->AdjV = E->V1;
         NewNode2->Weight = E->Weight;
         NewNode2->Next = Graph->G[E->V2].FirstEdge;
         Graph->G[E->V2].FirstEdge = NewNode2;
     }

     return Graph;
 }

 void Visit(LGraph Graph, Vertex V)
 {
     cout << V << ' ';
 }

 void ClearVisited()
 {
     for (int i = ; i < MaxVertexNum; ++i)
         Visited[i] = false;
 }

 void DFS(LGraph Graph, Vertex V)
 {
     Visit(Graph, V);
     Visited[V] = true;

     for (PtrToAdjVNode p = Graph->G[V].FirstEdge; p != NULL; p = p->Next)
     {
         if (!Visited[p->AdjV])
             DFS(Graph, p->AdjV);
     }
 }

 void BFS(LGraph Graph, Vertex V)
 {
     Visit(Graph, V);
     Visited[V] = true;
     queue<Vertex> Q;
     Q.push(V);

     while(!Q.empty())
     {
         Vertex W = Q.front();
         Q.pop();
         for (PtrToAdjVNode p = Graph->G[W].FirstEdge; p != NULL; p = p->Next)
         {
             if (!Visited[p->AdjV])
             {
                 Visit(Graph, p->AdjV);
                 Visited[p->AdjV] = true;
                 Q.push(p->AdjV);
             }
         }
     }
 }

 int main()
 {
     int nv, ne;
     cout << "请输入图的顶点数与边数：";
     cin >> nv >> ne;
     LGraph Graph = BuildGraph(nv, ne);
     cout << endl;
     cout << "请输入遍历起点：";
     Vertex V;
     cin >> V;
     cout << "DFS: ";
     DFS(Graph, V);
     ClearVisited();
     cout <<endl;
     cout << "BFS: ";
     BFS(Graph, V);

     return ;
 }

输出：