分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历。

### 回答1：
邻接矩阵实现图的深度优先遍历：

1. 从起点开始，将其标记为已访问。
2. 遍历起点的所有邻居节点，如果邻居节点未被访问，则递归访问该邻居节点。
3. 重复步骤2，直到所有节点都被访问。

邻接矩阵实现图的广度优先遍历：

1. 从起点开始，将其标记为已访问，并将其加入队列。
2. 从队列中取出一个节点，遍历该节点的所有邻居节点，如果邻居节点未被访问，则将其标记为已访问，并将其加入队列。
3. 重复步骤2，直到队列为空。

邻接表实现图的深度优先遍历：

1. 从起点开始，将其标记为已访问。
2. 遍历起点的所有邻居节点，如果邻居节点未被访问，则递归访问该邻居节点。
3. 重复步骤2，直到所有节点都被访问。

邻接表实现图的广度优先遍历：

1. 从起点开始，将其标记为已访问，并将其加入队列。
2. 从队列中取出一个节点，遍历该节点的所有邻居节点，如果邻居节点未被访问，则将其标记为已访问，并将其加入队列。
3. 重复步骤2，直到队列为空。

### 回答2：
邻接矩阵是一种常用的表示图的方法，它是一个二维数组，通过数组的下标可以直接访问到图中的顶点，对于边的信息，可以在数组中用1或0表示：如果两个点之间有边，就在邻接矩阵中对应位置上写1，否则写0。邻接矩阵的实现主要涉及到深度优先遍历和广度优先遍历两种算法。

深度优先遍历：从一个节点出发，优先访问它的深层次子节点，直到遍历完整个图。具体实现时，从图的任意一个节点开始深度优先遍历，先访问当前节点，标记该节点已被访问，并遍历当前节点的所有相邻节点，如果相邻节点没有被访问过，则递归访问该节点，直到所有节点都被遍历完。

邻接矩阵实现深度优先遍历的代码如下：

def dfs(matrix, n, visited, k):
    visited[k] = True
    print(k, end=' ')
    for i in range(n):
        if matrix[k][i] and not visited[i]:
            dfs(matrix, n, visited, i)

广度优先遍历：从一个节点出发，逐层访问它的相邻节点，直到遍历完整个图。具体实现时，从图的任意一个节点开始广度优先遍历，将该节点入队列，标记该节点已被访问，并遍历该节点的所有相邻节点，将这些相邻节点入队列。然后取队首元素，重复以上步骤，直到队列为空。

邻接矩阵实现广度优先遍历的代码如下：

def bfs(matrix, n, visited, k):
    queue = [k]
    visited[k] = True
    while queue:
        node = queue.pop(0)
        print(node, end=' ')
        for i in range(n):
            if matrix[node][i] and not visited[i]:
                queue.append(i)
                visited[i] = True

邻接表是另一种常见的表示图的方法，它的实现是通过一个哈希表和一个链表。哈希表中的键存储图中的顶点，值存储与该顶点相邻的顶点。链表中的节点表示与该顶点相邻的一个顶点。

深度优先遍历：从一个节点出发，优先访问它的深层次子节点，直到遍历完整个图。具体实现时，从图的任意一个节点开始深度优先遍历，先访问当前节点，标记该节点已被访问，并遍历当前节点的所有相邻节点，如果相邻节点没有被访问过，则递归访问该节点，直到所有节点都被遍历完。

邻接表实现深度优先遍历的代码如下：

def dfs(adj_list, visited, k):
    visited[k] = True
    print(k, end=' ')
    for i in adj_list[k]:
        if not visited[i]:
            dfs(adj_list, visited, i)

广度优先遍历：从一个节点出发，逐层访问它的相邻节点，直到遍历完整个图。具体实现时，从图的任意一个节点开始广度优先遍历，将该节点入队列，标记该节点已被访问，并遍历该节点的所有相邻节点，将这些相邻节点入队列。然后取队首元素，重复以上步骤，直到队列为空。

邻接表实现广度优先遍历的代码如下：

def bfs(adj_list, visited, k):
    queue = [k]
    visited[k] = True
    while queue:
        node = queue.pop(0)
        print(node, end=' ')
        for i in adj_list[node]:
            if not visited[i]:
                queue.append(i)
                visited[i] = True

总之，邻接矩阵和邻接表都是表示图的有效方法，它们各自适用于不同的场景和要求，因此在实际应用中需要根据具体情况进行选择。

### 回答3：
邻接矩阵和邻接表是两种常用的图存储方式。针对图的深度优先遍历和广度优先遍历，两种存储方式的实现方法略有不同：

邻接矩阵的深度优先遍历：

1. 创建一个bool类型的visited数组，表示是否已访问；
2. 从起点开始依次访问相邻节点，标记为visited；
3. 如果有未访问的邻居，则递归访问该邻居的邻居，重复2-3步骤。

邻接矩阵的广度优先遍历：

1. 创建一个bool类型的visited数组，表示是否已访问，同时创建一个队列queue，将起点入队；
2. 当队列不为空时，弹出队首元素，访问它的邻居，并将未访问的邻居入队；
3. 重复2步骤，直到队列为空。

邻接表的深度优先遍历：

1. 创建一个bool类型的visited数组，表示是否已访问；
2. 从起点开始依次访问相邻节点，标记为visited；
3. 如果有未访问的邻居，则递归访问该邻居的邻居，重复2-3步骤。

邻接表的广度优先遍历：

1. 创建一个bool类型的visited数组，表示是否已访问，同时创建一个队列queue，将起点入队；
2. 当队列不为空时，弹出队首元素，访问它的邻居，并将未访问的邻居入队；
3. 重复2步骤，直到队列为空。

两种存储方式的核心代码实现如下：

邻接矩阵的深度优先遍历：

void DFS_Matrix(int v, bool visited[]) {
    visited[v] = true;
    cout << v << " ";
    for (int i=0; i<n; i++) {
        if (graph_Matrix[v][i] && !visited[i]) {
            DFS_Matrix(i, visited);
        }
    }
}

邻接矩阵的广度优先遍历：

void BFS_Matrix(int v, bool visited[]) {
    queue<int> Q;
    visited[v] = true;
    Q.push(v);
    while (!Q.empty()) {
        v = Q.front();
        cout << v << " ";
        Q.pop();
        for (int i=0; i<n; i++) {
            if (graph_Matrix[v][i] && !visited[i]) {
                visited[i] = true;
                Q.push(i);
            }
        }
    }
}

邻接表的深度优先遍历：

void DFS_List(int v, bool visited[]) {
    visited[v] = true;
    cout << v << " ";
    for (auto u: graph_List[v]) {
        if (!visited[u]) {
            DFS_List(u, visited);
        }
    }
}

邻接表的广度优先遍历：

void BFS_List(int v, bool visited[]) {
    queue<int> Q;
    visited[v] = true;
    Q.push(v);
    while (!Q.empty()) {
        v = Q.front();
        cout << v << " ";
        Q.pop();
        for (auto u: graph_List[v]) {
            if (!visited[u]) {
                visited[u] = true;
                Q.push(u);
            }
        }
    }
}

综上所述，邻接矩阵和邻接表都可以有效地实现图的深度优先遍历和广度优先遍历。但对于不同的图应用场景，选择不同的存储方式会更加符合实际需要。