图的深度遍历和广度遍历（邻接矩阵）

 

 

#include<iostream>
using namespace std;

#define MAXSIZE 9 /* 存储空间初始分配量 */
#define MAXEDGE 15
#define MAXVEX 9

typedef struct //建立图这个结构体
{
    char vexs[MAXVEX];//顶点表
    int arc[MAXVEX][MAXVEX];//建立矩阵
    int numVertexes, numEdges;//图中当前顶点数和边数
}MGraph;

typedef struct//建立循环队列
{
    int data[MAXSIZE];
    int front;
    int rear;
}Queue;

bool InitQueue(Queue* Q)//初始化一个空队列
{
    Q->front = 0;
    Q->rear = 0;
    return true;
}

bool QueueEmpty(Queue Q)//判断队列是否为空
{
    if (Q.front == Q.rear)//如果队列为空
        return true;
    return false;
}

bool InQueue(Queue* Q, int e)//入队
{
    if ((Q->rear + 1) % MAXSIZE == Q->front)//如果队满,插入失败
        return false;
    Q->data[Q->rear + 1] = e;
    Q->rear = (Q->rear + 1) % MAXSIZE;//插入成功
    return true;
}

bool DeQueue(Queue* Q, int* e)//出队
{
    if (Q->front == Q->rear)
        return false;
    *e = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return  true;
}

void GreatMGraph(MGraph* G)
{
    G->numEdges = 15;
    G->numVertexes = 9;
    
    //读取顶点信息
    G->vexs[0]='A';
    G->vexs[1]='B';
    G->vexs[2]='C';
    G->vexs[3]='D';
    G->vexs[4]='E';
    G->vexs[5]='F';
    G->vexs[6]='G';
    G->vexs[7]='H';
    G->vexs[8]='I';
    
    //初始化图
    for (int i = 0; i < G->numVertexes; i++)
        for (int j = 0; j < G->numVertexes; j++)
            G->arc[i][j] = 0;

    /*把能到达的路经赋值为1,此代码的任务是完成深度优先遍历，
    所有我规定A--B中，只能A->B*/
    G->arc[0][1] = 1;
    G->arc[0][5] = 1;
    
    G->arc[1][2] = 1;
    G->arc[1][6] = 1;
    G->arc[1][8] = 1;
    
    G->arc[2][3] = 1;
    G->arc[2][8] = 1;
    
    G->arc[3][4] = 1;
    G->arc[3][6] = 1;
    G->arc[3][7] = 1;
    
    G->arc[4][5] = 1;
    G->arc[4][7] = 1;
    
    G->arc[5][6] = 1;
    
    G->arc[6][7] = 1;

    for (int i = 0; i < G->numVertexes; i++)
    {
        for (int j = i; j < G->numVertexes; j++)
        {
            G->arc[j][i] = G->arc[i][j];
        }
    }

}

int visited[MAXVEX];
//邻接矩阵深度优先递归算法
void DFS(MGraph G, int i)
{
    int j;
    visited[i] = 1;//访问后改为1
    printf("%c", G.vexs[i]);//打印顶点，也可做其它操作；
    for (j = 0; j < G.numVertexes; j++)
    {
        if (G.arc[i][j] == 1 && !visited[j])
            DFS(G, j);
    }
}
//邻接矩阵的深度遍历操作
void DFSTraverse(MGraph G)
{
    for (int i = 0; i < G.numVertexes; i++)
        visited[i] = 0; /* 初始所有顶点状态都是未访问过状态 */
    for (int j = 0; j < G.numVertexes; j++)
    {
        if (!visited[j])
            DFS(G, j);
    }
}

void BFSTraverse(MGraph G)
{
    Queue Q;
    InitQueue(&Q);
    for (int i = 0; i < G.numVertexes; i++)
        visited[i] = 0; /* 初始所有顶点状态都是未访问过状态 */
    for (int i = 0; i < G.numVertexes; i++)
    {
        if (!visited[i])
        {
            visited[i] = 1;
            printf("%c", G.vexs[i]);
            InQueue (&Q, i);
            while (!QueueEmpty(Q))
            {
                DeQueue(&Q, &i);
                for (int j = 0; j < G.numVertexes; j++)
                {
                    if (G.arc[i][j] == 1 && !visited[j])
                    {
                        visited[j] = 1;
                        printf("%c", G.vexs[j]);
                        InQueue(&Q, j);
                    }
                }
            }
        }
    }
}

int main()
{
    MGraph G;
    GreatMGraph(&G);
    cout << "深度遍历结果：";
    DFSTraverse(G);
    cout <<endl<< "广度遍历结果：";
    BFSTraverse(G);
    return 0;
}

广度遍历出了大问题，没找到错误，但是思想还是没问题的。