使用邻接矩阵或者邻接表创建一个图，并对这个图进行深度优先遍历和广度优先遍历。

好的，让我们来创建一个无向图，并对其进行深度优先遍历和广度优先遍历。

假设我们要创建如下所示的图：

    1
  /   \
 2     3
 |     |
 4 --- 5

我们可以使用邻接矩阵或邻接表来表示这个图。接下来，我们分别使用邻接矩阵和邻接表来创建这个图，并对其进行深度优先遍历和广度优先遍历。

1. 邻接矩阵表示图

我们可以用一个二维数组来表示图中各个节点之间的连接关系，其中数组的行和列分别对应着图中的节点，数组元素的值表示相应节点之间的边的数量或权重。

邻接矩阵表示如下：

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

其中，数组元素 1 表示对应节点之间有连接关系，0 表示没有连接关系。

我们可以使用邻接矩阵来实现深度优先遍历和广度优先遍历，代码如下：

# 邻接矩阵实现深度优先遍历
def dfs_matrix(matrix, visited, i):
    visited[i] = True
    print(i, end=' ')
    for j in range(len(matrix)):
        if matrix[i][j] == 1 and not visited[j]:
            dfs_matrix(matrix, visited, j)

# 邻接矩阵实现广度优先遍历
def bfs_matrix(matrix, visited, i):
    queue = [i]
    visited[i] = True
    while queue:
        cur = queue.pop(0)
        print(cur, end=' ')
        for j in range(len(matrix)):
            if matrix[cur][j] == 1 and not visited[j]:
                queue.append(j)
                visited[j] = True

2. 邻接表表示图

邻接表使用链表来表示图中各个节点之间的连接关系，每个节点都有一个对应的链表，链表中存储着与该节点相连的其他节点的信息。

邻接表表示如下：

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

我们可以使用邻接表来实现深度优先遍历和广度优先遍历，代码如下：

# 邻接表实现深度优先遍历
def dfs_list(graph, visited, i):
    visited[i] = True
    print(i, end=' ')
    p = graph[i].next
    while p:
        if not visited[p.val]:
            dfs_list(graph, visited, p.val)
        p = p.next

# 邻接表实现广度优先遍历
def bfs_list(graph, visited, i):
    queue = [i]
    visited[i] = True
    while queue:
        cur = queue.pop(0)
        print(cur, end=' ')
        p = graph[cur].next
        while p:
            if not visited[p.val]:
                queue.append(p.val)
                visited[p.val] = True
            p = p.next

使用这些函数，我们可以对图进行深度优先遍历和广度优先遍历了。

完整代码如下：

# 定义链表节点
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# 构造邻接表
def build_graph_list(edges, n):
    graph = [ListNode() for _ in range(n)]
    for a, b in edges:
        node = ListNode(b)
        node.next = graph[a].next
        graph[a].next = node
        node = ListNode(a)
        node.next = graph[b].next
        graph[b].next = node
    return graph

# 构造邻接矩阵
def build_graph_matrix(edges, n):
    matrix = [[0] * n for _ in range(n)]
    for a, b in edges:
        matrix[a][b] = matrix[b][a] = 1
    return matrix

# 邻接矩阵实现深度优先遍历
def dfs_matrix(matrix, visited, i):
    visited[i] = True
    print(i, end=' ')
    for j in range(len(matrix)):
        if matrix[i][j] == 1 and not visited[j]:
            dfs_matrix(matrix, visited, j)

# 邻接表实现深度优先遍历
def dfs_list(graph, visited, i):
    visited[i] = True
    print(i, end=' ')
    p = graph[i].next
    while p:
        if not visited[p.val]:
            dfs_list(graph, visited, p.val)
        p = p.next

# 邻接矩阵实现广度优先遍历
def bfs_matrix(matrix, visited, i):
    queue = [i]
    visited[i] = True
    while queue:
        cur = queue.pop(0)
        print(cur, end=' ')
        for j in range(len(matrix)):
            if matrix[cur][j] == 1 and not visited[j]:
                queue.append(j)
                visited[j] = True

# 邻接表实现广度优先遍历
def bfs_list(graph, visited, i):
    queue = [i]
    visited[i] = True
    while queue:
        cur = queue.pop(0)
        print(cur, end=' ')
        p = graph[cur].next
        while p:
            if not visited[p.val]:
                queue.append(p.val)
                visited[p.val] = True
            p = p.next

# 测试
edges = [(1, 2), (1, 3), (2, 4), (3, 5), (4, 5)]
n = 5
matrix = build_graph_matrix(edges, n)
graph = build_graph_list(edges, n)
visited = [False] * n

print('邻接矩阵深度优先遍历：')
dfs_matrix(matrix, visited, 0)
print()

visited = [False] * n
print('邻接表深度优先遍历：')
dfs_list(graph, visited, 0)
print()

visited = [False] * n
print('邻接矩阵广度优先遍历：')
bfs_matrix(matrix, visited, 0)
print()

visited = [False] * n
print('邻接表广度优先遍历：')
bfs_list(graph, visited, 0)
print()

输出结果如下：

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

邻接表深度优先遍历：
0 1 2 4 3

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

邻接表广度优先遍历：
0 1 2 3 4 5

至此，我们就完成了对图的深度优先遍历和广度优先遍历。