图

alGraph.h

#ifndef ALGRAPH_H
#define ALGRAPH_H

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

#define MAX_VERTEX_NUM 20

typedef char InfoType;
typedef int VertexType;

typedef enum{ERROR,OK} Status;

//---图的邻接表存储,本程序中为使用此存储方式
typedef struct ArcNode//弧节点
{
    int adjvex;
    InfoType *info;
    struct ArcNode *nextarc;
}ArcNode;

typedef struct VNode//顶点节点
{
    VertexType data;//顶点信息
    ArcNode *firstAdj;//指向第一条依附该顶点的弧的指针
}VNode,AdjList[MAX_VERTEX_NUM];

typedef struct 
{
    AdjList vertices;
    int vexnum,arcnum;
    int kind;
}ALGraph;

//---图的十字链表存储,本程序中使用的此存储方式
typedef struct ArcBox
{
    int tailvex,headvex;
    struct ArcBox *hlink,*tlink;
    InfoType *info;
}ArcBox;

typedef struct VexNode
{
    VertexType data;
    ArcBox *firstin,*firstout;
}VexNode;

typedef struct 
{
    VexNode xlist[MAX_VERTEX_NUM];
    int vexnum,arcnum;
}OLGraph;

Status (*VisitFun)(VexNode ar);//遍历树时使用的函数
int visited[MAX_VERTEX_NUM];//访问数组，用来标志是否被访问过

int Locate(OLGraph g,int x)//根据值获取数组下标
{
    for(int i = 0;i < g.arcnum;i++)
    {
        if(x == g.xlist[i].data)
        {
            return i;
        }
    }
    return -1;
}

Status CreateOLGraph(OLGraph &g)//用户输入值，转化为位置存储，输出时再将位置转化为值输出给用户，即相当于在内部存取都是位置，从0开始，但在与用户交互时都是使用值而非位置
{
    int incinfo;
    scanf("%d %d %d",&g.vexnum,&g.arcnum,&incinfo);//incinfo如果为0则边的info为空，incinfo为1则需要输入info

    printf("please input the value of vex :\n");
    for(int i = 0;i < g.vexnum;i++)//输入节点的值
    {
        scanf("%d",&g.xlist[i].data);
        g.xlist[i].firstin = NULL;
        g.xlist[i].firstout = NULL;
    }

    printf("please input the value of arc:\n");
    for(int i = 0;i < g.arcnum;i++)
    {
        int k,j;//k1和j1是节点的值，需要通过locate函数得到其在xlist中的位置(即数组下标)
        scanf("%d %d",&j,&k);

        j = Locate(g,j);
        if(j == -1)
        {
            printf("cannot locate the vertex!\n");
            return ERROR;
        }

        k = Locate(g,k);
        if(k == -1)
        {
            printf("cannot locate the vertex!\n");
            return ERROR;
        }

        ArcBox *ar = (ArcBox *)malloc(sizeof(ArcBox));
        //这里类似于链表的头插法建立链表，所以越是往后输入的边的端点越是在链表的表头，因此在后面遍历时，会感觉和输入的边的顺序相反，相反才说明正确
        ar->hlink = g.xlist[k].firstin;
        ar->tlink = g.xlist[j].firstout;
        ar->headvex = k;
        ar->tailvex = j;
        g.xlist[j].firstout = ar;
        g.xlist[k].firstin = ar;

        if(incinfo)
        {
            char aa;
            scanf("%c",&aa);
            ar->info = &aa;
        }
        else
        {
            ar->info = "";
        }
    }
    return OK;
}

Status PrintOLGraph(OLGraph g)
{
    printf("the value of the vertex and arcvalue is :\n");//输出的值和内部存储的值不一定相同，内部存储全是存储位置，因此要转化为值输出
    for(int i = 0;i < g.vexnum;i++)
    {
        printf("%d\n",g.xlist[i].data);
        ArcBox *temp = g.xlist[i].firstout;
        while(temp)
        {
            printf("(%d %d) ",g.xlist[temp->tailvex].data,g.xlist[temp->headvex].data);
            temp = temp->tlink;
        }
        printf("\n");
    }
    return OK;
}

int FirstAdjVex(OLGraph g,int v)
{
    if(g.xlist[v].firstout)
    {
        int nu = g.xlist[v].firstout->headvex;
        if(visited[nu] == 0)
        {
            return nu;
        }
    }
    else
    {
        return -1;
    }
}

int NextAdjVex(OLGraph g,int v,int w)
{
    ArcBox *temp = g.xlist[v].firstout;
    while(temp->headvex != w)
    {
        temp = temp->tlink;
    }

    temp = temp->tlink;
    if(temp && visited[temp->headvex] == 0)
    {
        return temp->headvex;
    }
    else
    {
        return -1;
    }
}

Status visit(VexNode ar)
{
    printf("%d\n",ar.data);
    return OK;
}

void Dfs(OLGraph g,int num)
{
    if(!visited[num])
    {
        VisitFun(g.xlist[num]);
        visited[num] = 1;
    }
    for(int m = FirstAdjVex(g,num);m >= 0;m = NextAdjVex(g,num,m))
    {
        if(!visited[m])
        {
            Dfs(g,m);
        }
    }
}

void DFSTraverse(OLGraph g,Status (*visit)(VexNode ar))//深度遍历树
{
    for(int i = 0;i < g.vexnum;i++)
    {
        visited[i] = 0;//初始化访问数组
    }

    VisitFun = visit;//初始化全局变量函数指针，使得Dfs函数中也可以调用访问函数
    for(int i = 0;i < g.vexnum;i++)
    {
        if(!visited[i])
        {
            Dfs(g,i);
        }
    }
}

void BFSTraverse(OLGraph g,Status (*visit)(VexNode ar))//广度优先遍历树
{
    for(int i = 0;i < g.vexnum;i++)
    {
        visited[i] = 0;
    }

    std::queue<int> q;//辅助队列，用来存放xlist数组节点的下标而不是节点本身，存放下标方便些

    for(int i = 0;i < g.vexnum;i++)
    {    
        if(!visited[i])
        {    
            visit(g.xlist[i]);
            q.push(i);
            visited[i] = 1;
            int temp;

            while(!q.empty())
            {
                temp = q.front();
                q.pop();
                for(int w = FirstAdjVex(g,temp);w >= 0;w = NextAdjVex(g,temp,w))
                {
                    if(visited[w] == 0)
                    {
                        visited[w] = 1;
                        visit(g.xlist[w]);
                        q.push(w);
                    }
                }
            }
        }
    }
}

#endif

main.cpp

#include "alGraph.h"

int main()
{
    OLGraph g;

    CreateOLGraph(g);
    PrintOLGraph(g);

    printf("DFSTraverse:\n");
    DFSTraverse(g,visit);

    printf("BFSTraverse:\n");
    BFSTraverse(g,visit);

    system("pause");
    return 0;
}