无向图的 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 = 0; i < Graph->Nv; ++i)
        Graph->G[i].FirstEdge = NULL;    //初始化所有表头指针为NULL

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


        //这种插入方法将会使下标大的在前，小的在后，所以遍历的时候下标大的会先遍历
        //插入边<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 = 0; 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 0;
}

输出：