图的深度优先遍历及广度优先遍历

 声明： 代码中有大量的注释，所以此处就不再作出大量的解释了。

　　　 注 ：本文是用有向图作为例子，其他三种图的形态可类比写出。

一 ： 深度优先遍历

#include <iostream>
#include <string>
using namespace std;
using std :: string;
typedef string InforType;
//顶点类型
typedef char VertexType;
typedef int Status;
typedef enum {UDG = 1, DG, UDN, DN} GraphKind;
//最大顶点个数
#define MAX_VERTEX_NUM 20
#define ERROR -1
#define OK 1
//表节点的定义
typedef struct ArcNode
{
    //该弧所指向的顶点的位置（相对地址）
    int adjvex;
    //指向下一条弧的指针
    struct ArcNode* nextarc;
    //该弧相关信息的指针（例如权值）
    InforType info;
}ArcNode;
//头节点的定义
typedef struct VNode
{
    //顶点信息
    VertexType data;
    //指向第一条依附该顶点的弧的指针
    ArcNode* firstarc;
}VNode, AdjList[MAX_VERTEX_NUM];
//图的定义
typedef struct
{
    //存放头节点的一维数组
    AdjList vertices;
    //图的当前顶点数和弧数
    int vexnum, arcnum;
    //图的种类标志
    GraphKind kind;
}ALGraph;
//标志数组，用来查看顶点是否被访问过
bool visited[MAX_VERTEX_NUM];
Status Visit(VNode node);
Status DFS(const ALGraph& G, int index, Status (*visit)(VNode));
void DFSTraverse(const ALGraph& G, Status (*visit)(VNode));
//定位顶点在一维数组中的位置
int LocateVex(VNode vertices[], int vexnum, VertexType e)
{
    int i;
    for(i = 0; i < vexnum; i++)
    {
        if(vertices[i].data == e)
            break;
    }
    return i;
}
//创建有向图
Status CreateDG(ALGraph& G)
{
    VertexType e;
    int num;
    cout << "该图共有多少个顶点、多少条弧?" << endl;
    cin >> G.vexnum >> G.arcnum;
    cout << "请输入各顶点:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        //注意存储结构
        cin >> G.vertices[i].data;
        //先将头节点的指针域设为空
        G.vertices[i].firstarc = NULL;
    }
    for(int i = 0; i < G.vexnum; i++)
    {
        //(强调引用)
        //注意ptr是节点的指针（是节点类型的一部分）而不是‘指向’节点的指针
        //所以接连各节点不想以前那样简单了
        ArcNode* &ptr = G.vertices[i].firstarc;
        cout << "请问以顶点" << G.vertices[i].data << "为起点的弧一共有多少条?" << endl;
        cin >> num;
        if(num > 0)
        {
            int Index;
            ArcNode* p = NULL;
            cout << "请将这些顶点依次输入:" << endl;
            //先处理一个节点（为了方便后面的操作）
            ptr = new ArcNode;
            if(ptr)
            {
                cin >> e;
                Index = LocateVex(G.vertices, G.vexnum, e);
                p = ptr;
                p->adjvex = Index;
                p->nextarc = NULL;
            }
            else
                return ERROR;
            for(int j = 1; j < num; j++)
            {
                //注意各变量的类型，不要搞混了
                cin >> e;
                Index = LocateVex(G.vertices, G.vexnum, e);
                ArcNode* ptr2 = new ArcNode;
                if(ptr2)
                {
                    ptr2->adjvex = Index;
                    ptr2->nextarc = NULL;
                    //注意此处的连接节点与以前写的有点不同（ptr‘一直’为空）
                    p->nextarc = ptr2;
                    p = p->nextarc;
                }
                else
                    return ERROR;
            }
        }
    }
    return OK;
}
int main(void)
{
    ALGraph G;
    CreateDG(G);
    DFSTraverse(G, Visit);
    return 0;
}
void DFSTraverse(const ALGraph& G, Status (*visit)(VNode))
{
    for(int i = 0; i < G.vexnum; i++)
    {
        //首先将每个顶点都设置为未被访问的状态
        visited[i] = false;
    }
    //对每一个顶点都查看一下，防止有遗漏（特别是针对非连通图）
    for(int i = 0; i < G.vexnum; i++)
    {
        if(!visited[i])
            DFS(G, i, visit);
    }
}
Status DFS(const ALGraph& G, int index, Status (*visit)(VNode))
{
    //注意不同的存储结构会导致遍历的算法不同
    if(visit(G.vertices[index]))
    {
        //改变即将要被访问的节点的访问状态
        visited[index] = true;
        ArcNode* ptr = G.vertices[index].firstarc;
        while(ptr)
        {
            if(!visited[ptr->adjvex])
                DFS(G, ptr->adjvex, visit);
            ptr = ptr->nextarc;
        }
        return OK;
    }
    else
        return ERROR;
}
//访问节点
Status Visit(VNode node)
{
    cout << node.data << '	';
    return OK;
}

二 : 广度优先遍历

#include <iostream>
#include "Queue.h"
using namespace std;
//无穷大
#define INFINITY INT_MAX
//最大顶点个数
#define MAX_VERTEX_NUM 20
//标志数组， 表示顶点访问状态
bool visited[MAX_VERTEX_NUM];
//顶点类型
typedef char VertexType;
typedef int VRType;
typedef char infoType;
//图的四种类型
typedef enum {DG = 1, DN, UDG, UDN} GraphKind;
//弧的结构体定义
typedef struct ArcCell
{
    // 对于网来说是权值；对于图来说就是0或1
    VRType adj;
    //该弧相关信息的指针（现在暂且可以理解为字符指针）
    infoType* info;
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
//图的结构体定义
typedef struct
{
    VertexType vexs[MAX_VERTEX_NUM];
     //arcs可以先简单地理解为一个数组名
    AdjMatrix arcs;
    //当前图中的顶点数和弧数
    int vexnum, arcnum;
    //图的种类标志
    GraphKind kind;
}MGraph;
void CreateGraph(MGraph &G);
int LocateVex(MGraph G , int v1);
void CreateDG(MGraph &G);
Status Visit(VertexType e);
Status BFSTraverse(const MGraph& G, Status (*visit)(VertexType));
int main(void)
{
    MGraph G;
    CreateDG(G);
    BFSTraverse(G, Visit);
    return 0;
}
//返回该顶点在一维数组中的下标（当然每一个人创建的一维数组可以是不同的）
int LocateVex(MGraph G , int v1)
{
    int i;
    for(i = 0; i < G.vexnum; i++)
    {
        if(G.vexs[i] == v1)
            break;
    }
    return i;
}
//创建有向图
void CreateDG(MGraph &G)
{
    cout << "该图有多少顶点以及多少条边?" << endl;
    cin >> G.vexnum  >> G.arcnum;
    cout << "请输入顶点:" << endl;
    for(int i = 0; i < G.vexnum; i++)
    {
        cin >> G.vexs[i];
    }
    for(int i = 0; i < G.vexnum; i++)
    {
        for(int j = 0; j < G.vexnum; j++)
        {
            //先假定图中没有弧
            G.arcs[i][j].adj = 0;
        }
    }
    cout << "请输入各弧的两个端点" << endl;
    VertexType v1, v2;
    //用于暂时存储每条弧的'权值'(存在即为1,否则为0)
    //因为temp的取值只能为1或0，所以不需要再输入
    VRType temp = 1;
    int i, j;
    //有向图不具备对称性
    for(int k = 0; k < G.arcnum; k++)
    {
        cin >> v1 >> v2;
        i = LocateVex(G, v1), j = LocateVex(G, v2),
        G.arcs[i][j].adj = temp;
    }
}
Status BFSTraverse(const MGraph& G, Status (*visit)(VertexType))
{
    for(int i = 0; i < G.vexnum; i++)
    {
        //先将所有的顶点的访问状态设置为false
        visited[i] = false;
    }
    //注意调整好各文件之间的关系
    LinkQueue Q;
    InitQueue(Q);
    //对每一个顶点都进行查看一次，以防止遗漏（特别是非连通图）
    for(int i = 0; i < G.vexnum; i++)
    {
        if(!visited[i])
        {
            EnQueue(Q, G.vexs[i]);
            //保证每一个节点只进入栈中一次
            visited[i] = true;
            while(!QueueEmpty(Q))
            {
                QueuePtr p = NULL;
                GetHead(Q, p);
                //返回队首元素在一维数组中的下标
                //千万不要将i当作k来使用
                int k = LocateVex(G, p->Qdata);
                for(int j = 0; j < G.vexnum; j++)
                {
                    //将所有与顶点G.vexs[i]相邻的顶点压入栈中(0或1, 权值也一样)
                    if(G.arcs[k][j].adj)
                    {
                        if(!visited[j])
                        {
                            EnQueue(Q, G.vexs[j]);
                            visited[j] = true;
                        }
                    }
                }
                //等到与顶点G.vexs[i]相邻的顶点全部都被压入栈中后， 立刻对顶点G.vexs[i]进行访问
                //只不过我此时的顶点结构未进行封装，所有在这里其实visit函数可有可无
                VertexType temp;
                DeQueue(Q, temp);
                visit(temp);
            }
        }
    }
    return OK;
}
Status Visit(VertexType e)
{
    cout << e << '	';
    return OK;
}

注：因为广度优先遍历中运用到了队列，代码中因此引用了自定义头文件。

三：自定义头文件（copy时记得让头文件的名字一模一样哦！否则.....哈哈）

#ifndef QUEUE_H_INCLUDED
#define QUEUE_H_INCLUDED


#include <iostream>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR -1
#define OVERFLOW -2
typedef char VertexType;
typedef VertexType QElemType;
typedef int Status;
typedef struct QNode
{
    QElemType Qdata;
    struct QNode* next;
}QNode, *QueuePtr;
typedef struct
{
    QueuePtr front;         //队首指针
    QueuePtr rear;          //队尾指针
}LinkQueue;
Status InitQueue(LinkQueue&);               //初始化队列
Status DestroyQueue(LinkQueue&);            //销毁队列
Status ClearQueue(LinkQueue&);              //清空队列
Status QueueEmpty(const LinkQueue&);              //判断队列是否为空
int QueueLength(const LinkQueue&);                //返回队列长度
Status GetHead(const LinkQueue&, QueuePtr&);      //返回队首元素
Status EnQueue(LinkQueue&, QElemType);          //插入一个元素
Status DeQueue(LinkQueue&, QElemType&);          //删除一个元素
Status QueueTraverse(const LinkQueue&, Status (*visit)(const QueuePtr ));  //遍历整个队列
Status Visit(const QueuePtr);



#endif // QUEUE_H_INCLUDED

四 : 头文件之实现文件

#include "Queue.h"
Status InitQueue(LinkQueue& Q)
{
    Q.front = Q.rear = new QNode;       //带头节点的链式队列
    if(Q.front)
    {
        Q.front->next = NULL;
        return OK;
    }
    else
        return OVERFLOW;
}
Status DestroyQueue(LinkQueue& Q)
{
    while(Q.front)
    {
        Q.rear = Q.front->next;
        delete (Q.front);       //空间虽已销毁，但原本指向该空间的指针还在，只不过变为野指针了而已。
        Q.front = Q.rear;
    }
    return OK;
}
Status ClearQueue(LinkQueue& Q)
{
    QueuePtr ptr = Q.front->next;
    Q.rear = Q.front;
    while(ptr)
    {
        QueuePtr p = ptr;
        ptr = ptr->next;
        delete p;
    }
    return OK;
}
Status QueueEmpty(const LinkQueue& Q)
{
    if(Q.front == Q.rear)
        return TRUE;
    else
        return FALSE;
}
int QueueLength(const LinkQueue& Q)
{
    if(Q.front == Q.rear)
        return 0;
    else
    {
        int count = 0;
        QueuePtr ptr = Q.front->next;
        while(ptr)
        {
            count++;
            ptr = ptr->next;
        }
        return count;
    }
}
Status GetHead(const LinkQueue& Q, QueuePtr& ptr)
{
    QueuePtr p = Q.front->next;
    if(p)
    {
        ptr = p;
        return OK;
    }
    else
    {
        ptr = NULL;
        return ERROR;
    }
}
Status EnQueue(LinkQueue& Q, QElemType e)
{
    QueuePtr ptr = new QNode;
    if(ptr)
    {
        ptr->next = NULL;
        ptr->Qdata = e;
        Q.rear->next = ptr;
        Q.rear = ptr;
        return OK;
    }
    else
        return OVERFLOW;
}
Status DeQueue(LinkQueue& Q, QElemType& e)
{
    if(Q.front == Q.rear)
        return ERROR;
    else                                //注意这是队列，只能从队首删除元素，从队尾插入元素
    {
        QueuePtr ptr = Q.front->next;
        Q.front->next = ptr->next;
        e = ptr->Qdata;
        if(ptr == Q.rear)       //如果原本队列里只有一个元素
        {
            Q.rear = Q.front;
        }
        delete ptr;
        return OK;
    }
}
Status Visit(const QueuePtr ptr)
{
    if(!ptr)
    {
        return ERROR;
    }
    else
    {
        cout << ptr->Qdata << '	';
        return OK;
    }
}
Status QueueTraverse(const LinkQueue& Q, Status (*visit)(const QueuePtr ))
{
    QueuePtr ptr = NULL;
    if(Q.front == Q.rear)
        return ERROR;
    else
    {
        ptr = Q.front->next;        //从第一个节点开始遍历（带头节点的链表）
        while(ptr)
        {
            (*visit)(ptr);
            ptr = ptr->next;
        }
        cout << endl;
        return OK;
    }
}