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

好的，我来回答你的问题。

首先，我们需要构建一个无向图并采用邻接矩阵存储。假设这个图有5个顶点，边的情况如下：

    0——1——2
    |  / |
    | /  |
    3——4

邻接矩阵可以表示如下：

   0  1  2  3  4
0  0  1  1  1  0
1  1  0  1  1  1
2  1  1  0  0  1
3  1  1  0  0  1
4  0  1  1  1  0

其中，1表示相应的两个顶点之间有边相连，0表示没有边相连。

接下来，我们可以按照以下方式对该图进行深度优先遍历和广度优先遍历：

（1）深度优先遍历：从某个顶点开始，依次访问与其相邻的未访问过的顶点，并以这些顶点为起点递归进行深度优先遍历。因此，该图的深度优先遍历结果可能为：0 1 2 4 3 或 0 3 4 1 2。这里有多种可能的遍历结果，因为深度优先遍历的顺序不唯一。

（2）广度优先遍历：从某个顶点开始，依次访问其与之相邻的未访问过的顶点，并按照访问顺序将这些顶点加入队列中，然后从队列中取出一个顶点继续进行访问。因此，该图的广度优先遍历结果为：0 1 3 2 4。

希望这个例子能够帮助你理解无向图的遍历方式。

相关问题

建立任意无向图，采用邻接矩阵存储，完成以下操作：对该图进行深度优先遍历，并输出遍历结果；对该图进行广度优先遍历，并输出遍历结果。

好的，我可以给你提供一个Python的实现，首先定义一个Graph类来存储图，使用邻接矩阵表示：

class Graph:
    def __init__(self, vertices):
        self.V = vertices
        self.adj_matrix = [[0] * self.V for i in range(self.V)]

    def add_edge(self, src, dest):
        self.adj_matrix[src][dest] = 1
        self.adj_matrix[dest][src] = 1

上面的代码中，我们定义了一个Graph类，并且使用邻接矩阵来存储图，其中V表示顶点数，adj_matrix是一个二维矩阵，用于存储边的关系。add_edge方法用于添加边，我们采用无向图，因此需要将两个方向都添加。

接下来我们可以使用深度优先遍历和广度优先遍历算法来遍历图。

深度优先遍历算法：

def dfs_iterative(self, start):
        visited = [False] * self.V
        stack = []
        stack.append(start)
        while stack:
            curr = stack.pop()
            if not visited[curr]:
                visited[curr] = True
                print(curr, end=' ')
            for i in range(self.V-1, -1, -1):
                if self.adj_matrix[curr][i] == 1 and not visited[i]:
                    stack.append(i)

上面的代码中，我们使用栈来进行迭代式遍历，初始时将起始节点放入栈中，然后遍历栈中的节点，如果该节点没有被访问过，则标记为已访问，并输出。然后遍历该节点的邻居，将未访问的邻居放入栈中。

广度优先遍历算法：

def bfs_iterative(self, start):
        visited = [False] * self.V
        queue = []
        queue.append(start)
        visited[start] = True
        while queue:
            curr = queue.pop(0)
            print(curr, end=' ')
            for i in range(self.V):
                if self.adj_matrix[curr][i] == 1 and not visited[i]:
                    queue.append(i)
                    visited[i] = True

上面的代码中，我们使用队列进行迭代式遍历，初始时将起始节点放入队列中，并标记为已访问，然后遍历队列中的节点，输出该节点，并遍历该节点的邻居，将未访问的邻居放入队列中。

最后，我们可以创建一个Graph对象，添加节点和边，然后调用上面定义的深度优先遍历和广度优先遍历算法完成遍历：

g = Graph(5)
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(1, 3)
g.add_edge(2, 3)
g.add_edge(3, 4)

print('DFS Traversal:')
g.dfs_iterative(0)

print('\nBFS Traversal:')
g.bfs_iterative(0)

完整代码如下：

用c++建立任意无向图，采用邻接矩阵存储，完成以下操作：对该图进行深度优先遍历，并输出遍历结果；对该图进行广度优先遍历，并输出遍历结果。

以下是基于邻接矩阵的C++代码实现：

#include <iostream>
#include <queue>
#include <stack>
using namespace std;

const int MAXN = 100;
bool visited[MAXN] = {false}; // 记录节点是否被访问过

// 邻接矩阵
struct Graph {
    int n; // 节点数
    int e; // 边数
    int matrix[MAXN][MAXN]; // 邻接矩阵

    Graph() {
        n = e = 0;
        memset(matrix, 0, sizeof(matrix)); // 初始化邻接矩阵
    }
};

// 添加边
void addEdge(Graph& g, int u, int v) {
    g.matrix[u][v] = g.matrix[v][u] = 1; // 无向图
    g.e++;
}

// 深度优先遍历
void DFS(Graph& g, int u) {
    visited[u] = true;
    cout << u << " ";
    for (int v = 0; v < g.n; v++) {
        if (g.matrix[u][v] == 1 && !visited[v]) {
            DFS(g, v);
        }
    }
}

// 广度优先遍历
void BFS(Graph& g, int u) {
    queue<int> q;
    visited[u] = true;
    q.push(u);
    while (!q.empty()) {
        int front = q.front();
        q.pop();
        cout << front << " ";
        for (int v = 0; v < g.n; v++) {
            if (g.matrix[front][v] == 1 && !visited[v]) {
                visited[v] = true;
                q.push(v);
            }
        }
    }
}

int main() {
    Graph g;
    g.n = 6;
    addEdge(g, 0, 1);
    addEdge(g, 0, 2);
    addEdge(g, 1, 2);
    addEdge(g, 1, 3);
    addEdge(g, 2, 4);
    addEdge(g, 3, 4);
    addEdge(g, 3, 5);

    cout << "深度优先遍历：";
    DFS(g, 0);
    memset(visited, false, sizeof(visited)); // 重置visited数组
    cout << endl;

    cout << "广度优先遍历：";
    BFS(g, 0);
    cout << endl;

    return 0;
}

输出结果为：

深度优先遍历：0 1 2 4 3 5 
广度优先遍历：0 1 2 3 4 5

其中，深度优先遍历使用了递归实现，广度优先遍历使用了队列实现。