1. 建立无向图的邻接矩阵存储并输出。2. 建立图的邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历。

1. 建立无向图的邻接矩阵存储并输出：

邻接矩阵是一种常用的图的存储方式，可以用一个二维数组来表示图中各个节点之间的关系。对于无向图，邻接矩阵是一个对称矩阵，即矩阵中的第i行第j列和第j行第i列都表示节点i和节点j之间是否有边相连。

下面是一个无向图的邻接矩阵示例：

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

其中，矩阵中的每个元素表示两个节点之间的边是否存在，1表示存在，0表示不存在。

2. 建立图的邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历：

邻接表是另一种常用的图的存储方式，它将每个节点的所有邻居节点都存储在一个链表中。对于无向图，每个节点的邻居节点都是双向的，因此邻接表中需要存储两个方向的链表。

下面是一个无向图的邻接表示例：

1 -> 2 -> 3
2 -> 1 -> 3 -> 4
3 -> 1 -> 2 -> 5
4 -> 2 -> 5
5 -> 3 -> 4

其中，每个节点后面的箭头表示该节点的邻居节点。

在邻接表的基础上，可以实现图的深度优先遍历和广度优先遍历。深度优先遍历是一种递归的方式，从起点节点开始，先访问它的一个邻居节点，然后再递归访问该邻居节点的邻居节点，直到所有节点都被访问过。广度优先遍历则是一种迭代的方式，从起点节点开始，先访问它的所有邻居节点，然后再依次访问它们的邻居节点，直到所有节点都被访问过。

相关问题

无向图如下所示： 1.建立无向图的邻接矩阵存储并输出。 2.建立图的邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历。

对于给定的无向图，我们可以使用邻接矩阵和邻接表两种数据结构来存储和遍历。下面是实现这两种方法的代码：

# 邻接矩阵存储方式
graph_matrix = [[0, 1, 1, 0, 0], 
                [1, 0, 1, 1, 0], 
                [1, 1, 0, 1, 1], 
                [0, 1, 1, 0, 1], 
                [0, 0, 1, 1, 0]]

# 输出邻接矩阵
print("邻接矩阵：")
for i in range(len(graph_matrix)):
    for j in range(len(graph_matrix[i])):
        print(graph_matrix[i][j], end=" ")
    print()

# 邻接表存储方式
graph_list = [[1, 2], [0, 2, 3], [0, 1, 3, 4], [1, 2, 4], [2, 3]]

# 深度优先遍历
def dfs(graph, start, visited):
    visited[start] = True
    print(start, end=" ")
    for i in graph[start]:
        if not visited[i]:
            dfs(graph, i, visited)

print("深度优先遍历：")
visited = [False] * len(graph_list)
dfs(graph_list, 0, visited)
print()

# 广度优先遍历
from collections import deque

def bfs(graph, start):
    visited = [False] * len(graph)
    queue = deque([start])
    visited[start] = True
    while queue:
        vertex = queue.popleft()
        print(vertex, end=" ")
        for i in graph[vertex]:
            if not visited[i]:
                visited[i] = True
                queue.append(i)

print("广度优先遍历：")
bfs(graph_list, 0)

输出结果为：

邻接矩阵：
0 1 1 0 0 
1 0 1 1 0 
1 1 0 1 1 
0 1 1 0 1 
0 0 1 1 0 
深度优先遍历：
0 1 2 3 4 
广度优先遍历：
0 1 2 3 4 

以上代码中，邻接矩阵存储方式使用二维数组来表示图，其中 matrix[i][j] = 1 表示节点 i 和 j 之间有一条边，否则为 0。邻接表存储方式使用列表来表示图，其中 list[i] 表示与节点 i 相邻的节点列表。深度优先遍历使用递归方式实现，广度优先遍历使用队列实现。

用c++写一个代码实现1.建立无向图的邻接矩阵存储并输出。 2.建立图的邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历。

1. 建立无向图的邻接矩阵存储并输出

#include <iostream>
using namespace std;

const int MAXN = 100;

int graph[MAXN][MAXN]; // 邻接矩阵

int main() {
    int n, m; // n 个节点，m 条边
    cin >> n >> m;

    // 初始化邻接矩阵
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            graph[i][j] = 0;
        }
    }

    // 读入每一条边
    for (int i = 0; i < m; i++) {
        int u, v; // u 和 v 之间有一条边
        cin >> u >> v;
        graph[u][v] = graph[v][u] = 1; // 无向图
    }

    // 输出邻接矩阵
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cout << graph[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

2. 建立图的邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历

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

const int MAXN = 100;

vector<int> adj[MAXN]; // 邻接表
bool visited[MAXN];    // 标记每个节点是否已被访问

// 深度优先遍历
void dfs(int u) {
    cout << u << " ";
    visited[u] = true;
    for (int v : adj[u]) {
        if (!visited[v]) {
            dfs(v);
        }
    }
}

// 广度优先遍历
void bfs(int u) {
    queue<int> q;
    q.push(u);
    visited[u] = true;
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        cout << u << " ";
        for (int v : adj[u]) {
            if (!visited[v]) {
                q.push(v);
                visited[v] = true;
            }
        }
    }
}

int main() {
    int n, m; // n 个节点，m 条边
    cin >> n >> m;

    // 初始化邻接表
    for (int i = 0; i < n; i++) {
        adj[i].clear();
        visited[i] = false;
    }

    // 读入每一条边
    for (int i = 0; i < m; i++) {
        int u, v; // u 和 v 之间有一条边
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u); // 无向图
    }

    // 从节点 0 开始进行深度优先遍历
    cout << "Depth First Search: ";
    dfs(0);
    cout << endl;

    // 重新初始化 visited 数组
    for (int i = 0; i < n; i++) {
        visited[i] = false;
    }

    // 从节点 0 开始进行广度优先遍历
    cout << "Breadth First Search: ";
    bfs(0);
    cout << endl;

    return 0;
}