矩阵图的深度广度遍历

图的常用表示方法就是矩阵和邻接表。

矩阵通常使用与规整的，且数据量较小的图，这种图直观上方便的表示出了图之间节点的相互关系。

图的数据结构

typedef struct Graph_Matrix{
    char vers[NUM]; //存储数据表示
    int arc[NUM][NUM];//二维矩阵图，用来表示节点相连情况
    int numVer,numEdge;//顶点数，和边数
}Graph_Matrix;

矩阵图的深度优先遍历

为了防止图中有不连通的子图，因此每个节点顺序的遍历一次，每次采用深度优先遍历其联通子图，避免了遗漏节点。

有点类似书中遍历玩父节点，直接遍历他的左边孩子，然后再回来....

int DFS(Graph_Matrix *g,int i){
    int j;
    visited[i] = 1;
    printf("%c ",g->vers[i]);
    for(j=0;j<g->numVer;j++){
        if(g->arc[i][j] == 1 && !visited[j])
            DFS(g,j);
    }
}
void DFSTraverse(Graph_Matrix *g){
    int i;
    for(i=0;i<g->numVer;i++)
        visited[i] = 0;
    for(i=0;i<g->numVer;i++){
        if(!visited[i])
            DFS(g,i);
    }
}

矩阵图的广度优先遍历

广度优先遍历，主要依赖于一个队列，每次遍历一个父节点，寻找他的子节点一次放入队列中，遍历完，读取队列中的队头，在此读取其子节点，有点类似树中遍历父节点后，在遍历他的孩子节点。

void BFSTraverse(Graph_Matrix *g){
    int i,j;
    Queue *q = (Queue *)malloc(sizeof(Queue));
    for(i=0;i<g->numVer;i++)
        visited[i] = 0;
    initQueue(q,0);
    for(i=0;i<g->numVer;i++){
        if(!visited[i]){
            visited[i] = 1;
            printf("%c ",g->vers[i]);
            inQueue(q,i);
            while(getLength(q)){
                int *tar = (int *)malloc(sizeof(int));
                outQueue(q,tar);
                for(j=0;j<g->numVer;j++){
                    if(g->arc[*tar][j] == 1 &&  !visited[j]){
                        visited[j] = 1;
                        printf("%c ",g->vers[j]);
                        inQueue(q,j);
                    }
                }
            }
        }
    }
}

示例图

示例代码

#include <stdio.h>
#include <stdlib.h>
#define NUM 5
#define MAXSIZE NUM
typedef struct Graph_Matrix{
    char vers[NUM];
    int arc[NUM][NUM];
    int numVer,numEdge;
}Graph_Matrix;

typedef struct Queue{
    int data[NUM];
    int front;
    int rear;
}Queue;

void initQueue(Queue *q,int n);
void showQueue(Queue *q);
int getLength(Queue *q);
int inQueue(Queue *q,int num);
int outQueue(Queue *q,int *tar);

void createGraph(Graph_Matrix *g);
void showGraph(Graph_Matrix *g);
int visited[NUM];
int DFS(Graph_Matrix *g,int i);
void DFSTraverse(Graph_Matrix *g);
void BFSTraverse(Graph_Matrix *g);

int main()
{
    Graph_Matrix * g1 = (Graph_Matrix *)malloc(sizeof(Graph_Matrix));
    createGraph(g1);
    showGraph(g1);
    printf("
");
    DFSTraverse(g1);
    printf("
");
    BFSTraverse(g1);
    return 0;
}

void createGraph(Graph_Matrix *g){
    int i;
    int j;
    g->numEdge = 0;
    for(i=0;i<NUM;i++){
        g->vers[i] = 65+i;
    }
    for(i=0;i<NUM;i++){
        for(j=0;j<NUM;j++){
            if(i != j){
                g->arc[i][j] = 1;
                g->numEdge++;
            }
            else
                g->arc[i][j] = 0;
        }
    }
    g->arc[2][3] = g->arc[3][2] = 0;
    g->arc[1][2] = g->arc[2][1] = 0;
    g->numEdge -= 4;
    g->numEdge = g->numEdge/2;
    g->numVer = 5;
}
void showGraph(Graph_Matrix *g){
    int i,j;
    for(i=0;i<g->numVer;i++){
        printf("%c ",g->vers[i]);
    }
    printf("
");

    for(i=0;i<g->numVer;i++){
        for(j=0;j<g->numVer;j++){
            printf("%d ",g->arc[i][j]);
        }
        printf("
");
    }
    printf("vertexes:%d edges:%d",g->numVer,g->numEdge);
}

int DFS(Graph_Matrix *g,int i){
    int j;
    visited[i] = 1;
    printf("%c ",g->vers[i]);
    for(j=0;j<g->numVer;j++){
        if(g->arc[i][j] == 1 && !visited[j])
            DFS(g,j);
    }
}
void DFSTraverse(Graph_Matrix *g){
    int i;
    for(i=0;i<g->numVer;i++)
        visited[i] = 0;
    for(i=0;i<g->numVer;i++){
        if(!visited[i]) //如果是连通图，只会执行一次
            DFS(g,i);
    }
}

void BFSTraverse(Graph_Matrix *g){
    int i,j;
    Queue *q = (Queue *)malloc(sizeof(Queue));
    for(i=0;i<g->numVer;i++)
        visited[i] = 0;
    initQueue(q,0);
    for(i=0;i<g->numVer;i++){
        if(!visited[i]){
            visited[i] = 1;
            printf("%c ",g->vers[i]);
            inQueue(q,i);
            while(getLength(q)){
                int *tar = (int *)malloc(sizeof(int));
                outQueue(q,tar);
                for(j=0;j<g->numVer;j++){
                    if(g->arc[*tar][j] == 1 &&  !visited[j]){
                        visited[j] = 1;
                        printf("%c ",g->vers[j]);
                        inQueue(q,j);
                    }
                }
            }
        }
    }
}

void initQueue(Queue *q,int n){
    int i;
    q->front=0;
    q->rear =0;
    for(i=0;i<n;i++){
        q->data[q->rear]=2*i+1;
        q->rear++;
    }
}
void showQueue(Queue *q){
    int i;
    int len=getLength(q);
    printf("front-");
    for(i=0;i<len;i++){
        if(q->front+i<MAXSIZE)
            printf("%d-",q->data[q->front+i]);
        else
            printf("%d-",q->data[q->front+i-MAXSIZE]);
    }
    printf("rear
");
}
int getLength(Queue *q){
    return (q->rear-q->front+MAXSIZE)%MAXSIZE;
}
int inQueue(Queue *q,int num){
    if((q->rear+1)%MAXSIZE == q->front)
        return 0;
    q->data[q->rear] = num;
    q->rear = (q->rear+1)%MAXSIZE;
    return 1;
}
int outQueue(Queue *q,int *tar){
    if(q->front == q->rear)
        return 0;
    *tar = q->data[q->front];
    q->front = (q->front+1)%MAXSIZE;
    return 1;
}

运行结果