建立任意顶点不小于7的无向图，画出无向图，采用邻接矩阵存储，完成以下操作： （1）对该图进行深度优先遍历，并输出遍历结果； （2）对该图进行广度优先遍历，并输出遍历结果。

为了方便起见，我们可以建立一个7个顶点的无向图，如下所示：

     1
   /   \
  2     4
 / \   / \
3   5 6   7

邻接矩阵表示为：

  1 2 3 4 5 6 7
1 0 1 0 1 0 0 0
2 1 0 1 0 1 0 0
3 0 1 0 0 0 0 0
4 1 0 0 0 0 1 1
5 0 1 0 0 0 0 0
6 0 0 0 1 0 0 0
7 0 0 0 1 0 0 0

深度优先遍历：

我们可以从顶点1开始遍历，根据邻接矩阵，我们可以先访问顶点2，再访问顶点3，然后回到顶点2，访问顶点5，然后回到顶点1，访问顶点4，再访问顶点6和7。因此，深度优先遍历结果为：1 2 3 5 4 6 7。

广度优先遍历：

我们同样可以从顶点1开始遍历，根据邻接矩阵，我们可以先访问顶点2和4，然后访问顶点3和5，再访问顶点6和7。因此，广度优先遍历结果为：1 2 4 3 5 6 7。

相关问题

用C语言建立任意顶点不小于7的无向图，画出无向图，采用邻接矩阵存储，完成以下操作： （1）对该图进行深度优先遍历，并输出遍历结果； （2）对该图进行广度优先遍历，并输出遍历结果。

以下用C语言实现的任意顶点不小于7的无向图的代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX_VERTEX_NUM 20

typedef struct {
    int vertex[MAX_VERTEX_NUM];
    int arc[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int vertex_num, arc_num;
} MGraph;

bool visited[MAX_VERTEX_NUM];

void createGraph(MGraph *G) {
    int i, j, k, v1, v2;
    printf("请输入顶点数和边数：");
    scanf("%d%d", &G->vertex_num, &G->arc_num);
    printf("请输入%d个顶点：", G->vertex_num);
    for (i = 0; i < G->vertex_num; i++) {
        scanf("%d", &G->vertex[i]);
    }
    for (i = 0; i < G->vertex_num; i++) {
        for (j = 0; j < G->vertex_num; j++) {
            G->arc[i][j] = 0;
        }
    }
    printf("请输入%d条边：\n", G->arc_num);
    for (k = 0; k < G->arc_num; k++) {
        scanf("%d%d", &v1, &v2);
        i = -1, j = -1;
        for (int l = 0; l < G->vertex_num; l++) {
            if (G->vertex[l] == v1) {
                i = l;
            }
            if (G->vertex[l] == v2) {
                j = l;
            }
            if (i != -1 && j != -1) {
                break;
            }
        }
        G->arc[i][j] = 1;
        G->arc[j][i] = 1;
    }
}

void DFS(MGraph *G, int i) {
    int j;
    visited[i] = true;
    printf("%d ", G->vertex[i]);
    for (j = 0; j < G->vertex_num; j++) {
        if (G->arc[i][j] == 1 && !visited[j]) {
            DFS(G, j);
        }
    }
}

void DFSTraverse(MGraph *G) {
    int i;
    for (i = 0; i < G->vertex_num; i++) {
        visited[i] = false;
    }
    for (i = 0; i < G->vertex_num; i++) {
        if (!visited[i]) {
            DFS(G, i);
        }
    }
}

void BFS(MGraph *G, int i) {
    int queue[MAX_VERTEX_NUM];
    int front = 0, rear = 0;
    int j, k;
    printf("%d ", G->vertex[i]);
    visited[i] = true;
    queue[rear++] = i;
    while (front != rear) {
        j = queue[front++];
        for (k = 0; k < G->vertex_num; k++) {
            if (G->arc[j][k] == 1 && !visited[k]) {
                printf("%d ", G->vertex[k]);
                visited[k] = true;
                queue[rear++] = k;
            }
        }
    }
}

void BFSTraverse(MGraph *G) {
    int i;
    for (i = 0; i < G->vertex_num; i++) {
        visited[i] = false;
    }
    for (i = 0; i < G->vertex_num; i++) {
        if (!visited[i]) {
            BFS(G, i);
        }
    }
}

int main() {
    MGraph G;
    createGraph(&G);
    printf("深度优先遍历：");
    DFSTraverse(&G);
    printf("\n广度优先遍历：");
    BFSTraverse(&G);
    return 0;
}

其中，`createGraph`函数用来创建无向图，`DFS`函数用来进行深度优先遍历，`DFSTraverse`函数用来对整个图进行深度优先遍历，`BFS`函数用来进行广度优先遍历，`BFSTraverse`函数用来对整个图进行广度优先遍历。

输入输出示例：

请输入顶点数和边数：7 9
请输入7个顶点：1 2 3 4 5 6 7
请输入9条边：
1 2
1 3
1 4
2 5
2 6
3 6
4 7
5 7
6 7
深度优先遍历：1 2 5 7 6 3 4
广度优先遍历：1 2 3 4 5 6 7

c++无向图邻接矩阵

在C++中，无向图（Undirected Graph）可以通过邻接矩阵（Adjacency Matrix）来表示。邻接矩阵是一个二维数组，其中的每个元素表示两个顶点之间是否存在边。如果顶点i和顶点j之间有边，矩阵中的[i][j]或[j][i]（因为无向图是双向的）会有一个非零值，通常是1或其他非零标识；如果没有边，则对应位置的值为0。

邻接矩阵的主要优点是空间效率较高，适用于稠密图（边的数量接近于顶点数量的平方），查询任意两个顶点间是否有边的时间复杂度是O(1)。然而，对于稀疏图（边的数量远小于顶点数量的平方），邻接矩阵可能会浪费大量空间，因为大部分元素都是0。

邻接矩阵的实现步骤如下：

1. 定义一个二维数组，其大小为顶点数的平方，用于存储边的信息。
2. 初始化数组，例如使用整型数组并初始化为0，表示初始时没有边。
3. 当添加边时，更新对应位置的值。如果是无向图，需要同时更新[i][j]和[j][i]。
4. 查询边的存在时，只需检查[i][j]或[j][i]是否非零。