建立有向图的邻接矩阵和邻接表存储结构，并实现两种遍历运算、简单路径求解。

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

邻接矩阵是一种二维数组，它的行和列分别代表了图中的顶点，数组的值表示两个顶点之间是否有边。如果两个顶点之间有边，则值为1，否则为0。邻接矩阵适用于稠密图。

邻接表则是由一个数组和若干个链表组成。数组中的每个元素表示一个顶点，对应的链表则存储该顶点所有相邻的顶点。邻接表适用于稀疏图。

下面是建立邻接矩阵和邻接表的代码：

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

    def add_edge(self, u, v):
        # 添加边到邻接矩阵
        self.adj_matrix[u][v] = 1
        self.adj_matrix[v][u] = 1

        # 添加边到邻接表
        self.adj_list[u].append(v)
        self.adj_list[v].append(u)

    def print_adj_matrix(self):
        for row in self.adj_matrix:
            print(row)

    def print_adj_list(self):
        for i in range(self.vertices):
            print(i, end=": ")
            for j in self.adj_list[i]:
                print(j, end=" ")
            print()

接下来是两种遍历算法，分别是深度优先遍历和广度优先遍历。

深度优先遍历（DFS）是一种递归遍历算法，它先访问一个顶点，然后递归访问该顶点的所有邻居，直到所有顶点都被访问过。DFS 的时间复杂度为 O(V+E)，其中 V 是顶点数，E 是边数。

广度优先遍历（BFS）是一种基于队列的遍历算法，它从起始顶点开始，依次访问该顶点的所有邻居，将访问过的邻居加入队列中，然后从队列中取出下一个顶点重复上述过程，直到所有顶点都被访问过。BFS 的时间复杂度也是 O(V+E)。

下面是深度优先遍历和广度优先遍历的代码实现：

class Graph:
    #...

    def dfs(self, v, visited):
        visited[v] = True
        print(v, end=" ")

        for i in self.adj_list[v]:
            if not visited[i]:
                self.dfs(i, visited)

    def bfs(self, v):
        visited = [False]*self.vertices
        queue = []

        visited[v] = True
        queue.append(v)

        while queue:
            s = queue.pop(0)
            print(s, end=" ")

            for i in self.adj_list[s]:
                if not visited[i]:
                    visited[i] = True
                    queue.append(i)

    def dfs_traversal(self):
        visited = [False]*self.vertices

        for i in range(self.vertices):
            if not visited[i]:
                self.dfs(i, visited)

    def bfs_traversal(self, v):
        self.bfs(v)

最后是简单路径的求解。简单路径是指不经过重复顶点的路径。我们可以使用深度优先遍历来找到两个顶点之间的简单路径。具体实现如下：

class Graph:
    #...

    def get_simple_path(self, u, v):
        visited = [False]*self.vertices
        path = []

        self.__get_simple_path_util(u, v, visited, path)

        if not path:
            return None
        else:
            return path

    def __get_simple_path_util(self, u, v, visited, path):
        visited[u] = True
        path.append(u)

        if u == v:
            return True

        for i in self.adj_list[u]:
            if not visited[i]:
                if self.__get_simple_path_util(i, v, visited, path):
                    return True

        path.pop()
        return False

在这里，我们使用了一个辅助函数 __get_simple_path_util 来递归地查找路径。如果找到了目标顶点 v，则返回 True，否则返回 False。如果找到了目标顶点，则将路径保存在列表 path 中。如果没有找到目标顶点，则将最后一个顶点弹出路径列表，回溯到上一个顶点，继续查找。如果最终没有找到简单路径，则返回 None。

希望这些代码能够帮助你理解邻接矩阵、邻接表、遍历算法和简单路径的实现。