根据输入输出一个图完成图的深度优先遍历算法、广度优先遍历算法。其中，邻接表的创建相当于创建多个单链表。

好的，我可以为您解答这个问题。

首先，我们需要了解一下深度优先遍历算法和广度优先遍历算法的基本思想和步骤。

深度优先遍历算法：从图的某个顶点开始遍历，沿着一条路径一直走到底，直到不能再走为止，然后回退到前一个节点，再沿着另一条路径继续走到底，直到所有的节点都被遍历过为止。

广度优先遍历算法：从图的某个顶点开始遍历，先访问所有与该顶点相邻的节点，然后再依次访问与这些节点相邻的所有节点，直到所有的节点都被遍历过为止。

邻接表是一种常见的图的表示方法，它用一个一维数组存储图中的所有顶点，每个顶点对应一个单链表，链表中存储该顶点所连的所有边的信息。

下面是基于邻接表的深度优先遍历算法和广度优先遍历算法的实现：

深度优先遍历算法：

# 定义节点
class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

# 定义图
class Graph:
    def __init__(self, n):
        self.n = n # 图中节点的个数
        self.adj = [None] * n # 邻接表

    # 添加一条边
    def add_edge(self, s, t):
        node = Node(t)
        node.next = self.adj[s]
        self.adj[s] = node

    # 深度优先遍历
    def dfs(self, s):
        visited = [False] * self.n # 标记节点是否已被访问
        self._dfs(s, visited)

    def _dfs(self, node, visited):
        print(node) # 访问节点
        visited[node] = True # 标记节点已被访问
        next_node = self.adj[node]
        while next_node:
            if not visited[next_node.val]:
                self._dfs(next_node.val, visited)
            next_node = next_node.next

广度优先遍历算法：

# 定义节点
class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

# 定义图
class Graph:
    def __init__(self, n):
        self.n = n # 图中节点的个数
        self.adj = [None] * n # 邻接表

    # 添加一条边
    def add_edge(self, s, t):
        node = Node(t)
        node.next = self.adj[s]
        self.adj[s] = node

    # 广度优先遍历
    def bfs(self, s):
        visited = [False] * self.n # 标记节点是否已被访问
        queue = [] # 队列
        queue.append(s)
        visited[s] = True # 标记节点已被访问
        while queue:
            node = queue.pop(0) # 出队
            print(node) # 访问节点
            next_node = self.adj[node]
            while next_node:
                if not visited[next_node.val]:
                    queue.append(next_node.val) # 入队
                    visited[next_node.val] = True # 标记节点已被访问
                next_node = next_node.next

以上就是基于邻接表的深度优先遍历算法和广度优先遍历算法的实现。希望可以帮助到您！