图的遍历

实验5 图的遍历问题

邻接表实现

#include <stdio.h>
#define MaxVertexNum 100
#define QueueSize 30
#include<iostream>
using namespace std;
typedef enum{ FALSE, TRUE }Boolean;
Boolean visited[MaxVertexNum];
typedef char VertexType;
typedef int EdgeType;
typedef struct node     //边表结点
{
    int adjvex;         //邻接点域
    struct node *next;  //域链
    //若是要表示边上的权,则应增加一个数据域
}EdgeNode;
typedef struct vnode    //顶点边结点
{
    VertexType vertex;  //顶点域
    EdgeNode *firstedge;//边表头指针
}VertexNode;
typedef VertexNode AdjList[MaxVertexNum];   //AdjList是邻接表类型
typedef struct
{
    AdjList adjlist;    //邻接表
    int n, e;           //图中当前顶点数和边数
}ALGraph;               //对于简单的应用，无须定义此类型，可直接使用AdjList类型

void CreateGraphAL(ALGraph *G)
{
    int i, j, k,c;
    char a,b,first;
    EdgeNode * s;
    cout<<"请输入顶点数和边数(输入格式为:顶点数,边数)：
";
    cin>>(G->n)>>(G->e);       // 读入顶点数和边数
    cout<<"输入"<<G->n<<"个顶点"<<endl;
    for (i = 0; i < G->n; i++)              // 立有n个顶点的顶点表
    {
        cout<<"输入顶点"<<i<<":";
        cin>>a;
        G->adjlist[i].vertex=a; // 读入顶点信息
        G->adjlist[i].firstedge = NULL;            // 点的边表头指针设为空
    }
    first=G->adjlist[0].vertex;
    cout<<"first"<<first<<endl;

    for (k = 0; k < G->e; k++)      // 建立边表
    {
        // 读入边<Vi,Vj>的顶点对应序号
        cout<<"输入弧"<<k<<":";
        cin>>a>>b>>c;
        s = new EdgeNode;         // 生成新边表结点s
        i=a-first;
        j=b-first;
      //  printf("%d  %d  
",i,j);
        s->adjvex = j;         // 邻接点序号为j
        s->next = G->adjlist[i].firstedge; // 将新边表结点s插入到顶点Vi的边表头部
        G->adjlist[i].firstedge = s;

    }

}

void DFS(ALGraph *G, int i)
{
    //以vi为出发点对邻接表表示的图G进行深度优先搜索
    EdgeNode *p;
    cout<<G->adjlist[i].vertex;
    visited[i] = TRUE;              //标记vi已访问
    p = G->adjlist[i].firstedge;        //取vi边表的头指针
    while (p)
    {                               //依次搜索vi的邻接点vj，这里j=p->adjvex
        if (!visited[p->adjvex])    //若vi尚未被访问
            DFS(G, p->adjvex);      //则以Vj为出发点向纵深搜索
        p = p->next;                     //找vi的下一邻接点
    }
}
void DFSTraverseM(ALGraph *G)
{
    int i;
    for (i = 0; i < G->n; i++)
        visited[i] = FALSE;
    for (i = 0; i < G->n; i++)
        if (!visited[i])
            DFS(G, i);
}
typedef struct
{
    int front;
    int rear;
    int count;
    int data[QueueSize];
}CirQueue;
void InitQueue(CirQueue *Q)
{
    Q->front = Q->rear = 0;
    Q->count = 0;
}
int QueueEmpty(CirQueue *Q)
{
    return Q->count == 0;
}
int QueueFull(CirQueue *Q)
{
    return Q->count == QueueSize;
}
void EnQueue(CirQueue *Q, int x)
{
    if (QueueFull(Q))
        cout<<"Queue overflow"<<endl;
    else
    {
        Q->count++;
        Q->data[Q->rear] = x;
        Q->rear = (Q->rear + 1) % QueueSize;
    }
}
int DeQueue(CirQueue *Q)
{
    int temp;
    if (QueueEmpty(Q))
    {
        cout<<"Queue underflow"<<endl;
        return NULL;
    }
    else
    {
        temp = Q->data[Q->front];
        Q->count--;
        Q->front = (Q->front + 1) % QueueSize;
        return temp;
    }
}
void BFS(ALGraph*G, int k)
{   // 以vk为源点对用邻接表表示的图G进行广度优先搜索
    int i;
    CirQueue Q;             //须将队列定义中DataType改为int
    EdgeNode *p;
    InitQueue(&Q);          //队列初始化
    cout<<G->adjlist[k].vertex;      //访问源点vk
    visited[k] = TRUE;
    EnQueue(&Q, k);         //vk已访问，将其人队。（实际上是将其序号人队）
    while (!QueueEmpty(&Q))
    {                                   //队非空则执行
        i = DeQueue(&Q);                    //相当于vi出队
        p = G->adjlist[i].firstedge;        //取vi的边表头指针
        while (p)
        {                               //依次搜索vi的邻接点vj(令p->adjvex=j)
            if (!visited[p->adjvex])
            {                           //若vj未访问过
              //  printf("visit vertex:%c
", G->adjlist[p->adjvex].vertex);      //访问vj
                cout<<G->adjlist[p->adjvex].vertex;
                visited[p->adjvex] = TRUE;
                EnQueue(&Q, p->adjvex); //访问过的vj人队
            }
            p = p->next;                    //找vi的下一邻接点
        }
    }
}
void BFSTraverseM(ALGraph *G)
{
    int i;
    for (i = 0; i < G->n; i++)
        visited[i] = FALSE;
    for (i = 0; i < G->n; i++)
        if (!visited[i])
            BFS(G, i);
}

void PrintfGraphAL(ALGraph *G)
{
    for (int i = 0; i < G->n; i++)
    {
        cout<<"vertex"<<G->adjlist[i].vertex;
        EdgeNode *p = G->adjlist[i].firstedge;
        while (p)
        {
            cout<<"→"<<p->adjvex;
            p = p->next;
        }
        cout<<endl;
    }
}

void DeleteGraphAL(ALGraph *G)
{
    for (int i = 0; i < G->n; i++)
    {
        EdgeNode *q;
        EdgeNode *p = G->adjlist[i].firstedge;
        while (p)
        {
            q = p;
            p = p->next;
            delete q;
        }
        G->adjlist[i].firstedge = NULL;
    }
}
int main()
{

    ALGraph G;
    CreateGraphAL(&G);
    cout<<"深度优先遍历：
";
    DFSTraverseM(&G);
    cout<<endl;
    cout<<"广度优先遍历：
";
    BFSTraverseM(&G);
 //   PrintfGraphAL(&G);
    DeleteGraphAL(&G);

    return 0;
}

邻接矩阵实现

#include <stdio.h>
#include<iostream>

typedef enum{ FALSE, TRUE }Boolean;
#define maxSize 20
Boolean visited[maxSize];
using namespace std;
struct g
{
    int w[maxSize][maxSize];
    int n,e;
    char first;
    char vertex[maxSize];
};
g graph;
void creatgraph()
{

    int i,j,w;
    char a,b;

    cout<<"输入顶点数和弧数："<<endl;
    cin>>graph.n>>graph.e;
    for(i=0;i<graph.n;i++)
    {
        cout<<"输入顶点"<<i<<":";
        cin>>a;
        graph.vertex[i]=a;
    }
   graph.first=graph.vertex[0];
    cout<<"输入"<<graph.e<<"条弧"<<endl;
    for(i=0;i<graph.e;i++)
    {
        cout<<"输入弧"<<i<<":";
        cin>>a>>b>>w;
        graph.w[a-graph.first][b-graph.first]=w;
    }
    cout<<"----图----"<<endl;
    for(i=0;i<graph.n;i++)
    {
        for(j=0;j<graph.n;j++)
        cout<<graph.w[i][j];
        cout<<endl;
    }


}
void DFS(g graph,int i)
{
    int j;
    cout<<graph.vertex[i];
    visited[i]=TRUE;
    for(j=0;j<graph.n;j++)
        if(graph.w[i][j]==1 && visited[j]!=1)
            DFS(graph,j);
}
void DFST()
{
    int i;
    for(i=0;i<graph.n;i++)
        visited[i]=FALSE;
    for(i=0;i<graph.n;i++)
        if(!visited[i])
            DFS(graph,i);
}
void clearg(int j)
{
    for(int i=0;i<graph.n;i++)
        graph.w[i][j]=0;
}
char change(int x)
{
    for(char c='a';c<='z';c++)
    {
        if(c-x==0)
            return c;
    }
}

void BFST()
{
    int i,j;bool flag=0;
    for (i = 0; i < graph.n; i++)
    {


        for(int j=0;j<graph.n;j++)
        if(graph.w[i][j])
        {cout<<change(i+graph.first);flag=1;break;}
        if(flag)
        break;
    }
    for(i=0;i<graph.n;i++)
            for(int j=0;j<graph.n;j++)
                if(graph.w[i][j])
    {cout<<change(j+graph.first);clearg(j);}
}
int main()
{
    creatgraph();
    cout<<"深度优先："<<endl;
    DFST();
    cout<<endl;
    cout<<"广度优先："<<endl;
    BFST();
    cout<<endl;
    return 0;
}

矩阵实现的BFS部分我偷懒了，我为了应付实验验收，没有用队列，而且搜索之后数组全被我清零。这样是有bug的。建议用visited数组来标记是否被访问。