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

深度优先搜索和广度优先搜索

要求

分别使用深度优先搜索和广度优先搜索遍历下面中的图。

思想

深度优先遍历思想：

首先以一个未被访问过的顶点作为起始顶点，沿当前顶点的边走到未被访问过的顶点，当没有未访问过的顶点式，则回到上一个顶点，继续探索访问别的顶点，直到所有的顶点都被访问过。

广度优先遍历思想：

首先以一个未被访问过的顶点作为起始顶点，访问其所有相邻的顶点，然后对每个相邻的顶点，再访问它们相邻的未被访问过的顶点，直到所有顶点都被访问过。

图的存储

常用二维数组存储，1表示有边，-1表示没有边，0表示自己，这种方式称为图的邻接矩阵存储法。

0	1	1	-1	1
1	0	-1	1	-1
1	-1	0	-1	1
-1	1	-1	0	-1
1	-1	1	-1	0

代码

#include <stdio.h>

#define N 6
#define M 6

int a[N][M] = {
                { 0 },
                { 0, 0,  1,  1, -1,  1},     /*       1          */
                { 0, 1,  0, -1,  1, -1},     /*     / | \        */
                { 0, 1, -1,  0, -1,  1},     /*    2  3 - 5      */
                { 0, -1, 1, -1,  0, -1},     /*    |             */
                { 0, 1, -1,  1, -1,  0}      /*    4             */
               };

int b[M] = {0};
int sum;

void dfs(int cur) {
    printf("%d ", cur);
    sum++;
    if (sum == M-1) {
        return;
    }
    for (int i = 1; i < M; ++i) {
        if (a[cur][i] == 1 && b[i] == 0){
            b[i] = 1;
            dfs(i);
        }
    }
}

int queue[40];
int head = 0; int tail = 0;
int e[M] = {0};

void bfs(int cur) {
    e[cur] = 1;
    queue[tail] = cur;
    tail++;

    while(head < tail) {
        cur = queue[head];
        head++;

        printf("%d ", cur);

        for (int i = 1; i < M; ++i) {
            if (a[cur][i] == 1 && e[i] == 0) {
                e[i] = 1;
                queue[tail] = i;
                tail++;
            }
        }
    }
}

int main() {
    b[1] = 1;
    dfs(1);

    printf("\n");
    bfs(1);
    return 0;
}