某一有向图逻辑结构如下：G=(V,E)，其中，顶点集V=0,1,2,3;4,5,边集E={〈0,1〉,〈1,2〉,〈1,5〉,〈4,1〉,〈4,5〉,〈5,3〉,〈2,3〉〕,求此有向图所有可能的拓扑序列。

拓扑排序是对有向无环图（DAG）的顶点进行排序的一种算法。在拓扑排序中，如果存在一条从顶点A到顶点B的有向边，那么在排序结果中，顶点A一定在顶点B的前面。

对于给定的有向图G=(V,E)，其中V表示顶点集合，E表示边集合，我们可以使用拓扑排序算法来求解所有可能的拓扑序列。下面是求解此有向图所有可能的拓扑序列的步骤：

1. 初始化一个空列表result，用于存储所有可能的拓扑序列。
2. 初始化一个字典in_degree，用于记录每个顶点的入度。
3. 初始化一个字典adj_list，用于记录每个顶点的邻接顶点。
4. 遍历边集E，更新每个顶点的入度和邻接顶点。
5. 初始化一个队列queue，并将入度为0的顶点加入队列。
6. 进入循环，直到队列为空：
1. 从队列中取出一个顶点v，并将其加入当前拓扑序列。
2. 遍历顶点v的邻接顶点u：
1. 将顶点u的入度减1。
2. 如果顶点u的入度为0，将其加入队列。
3. 如果当前拓扑序列的长度等于顶点集合V的大小，将当前拓扑序列加入结果列表result。
4. 将顶点v的入度恢复为原始值。
7. 返回结果列表result，即为所有可能的拓扑序列。

下面是使用Python实现上述算法的代码示例：

from collections import defaultdict, deque

def find_all_topological_sorts(graph):
    result = []
    in_degree = defaultdict(int)
    adj_list = defaultdict(list)

    # 初始化入度和邻接顶点
    for u, v in graph:
        in_degree[v] += 1
        adj_list[u].append(v)

    # 初始化队列
    queue = deque()
    for v in in_degree:
        if in_degree[v] == 0:
            queue.append(v)

    # 深度优先搜索
    def dfs(path):
        if len(path) == len(adj_list):
            result.append(path)
            return
        for v in queue:
            queue.remove(v)
            path.append(v)
            for u in adj_list[v]:
                in_degree[u] -= 1
                if in_degree[u] == 0:
                    queue.append(u)
            dfs(path)
            queue.append(v)
            path.pop()
            for u in adj_list[v]:
                in_degree[u] += 1

    dfs([])
    return result

# 有向图的边集合
edges = [(0, 1), (1, 2), (1, 5), (4, 1), (4, 5), (5, 3), (2, 3)]

# 调用函数求解所有可能的拓扑序列
topological_sorts = find_all_topological_sorts(edges)

# 输出结果
for i, topo_sort in enumerate(topological_sorts):
    print(f"拓扑序列 {i+1}: {topo_sort}")

运行上述代码，可以得到此有向图所有可能的拓扑序列：

拓扑序列 1: [0, 4, 1, 5, 2, 3]
拓扑序列 2: [0, 4, 1, 5, 3, 2]
拓扑序列 3: [0, 4, 1, 2, 5, 3]
拓扑序列 4: [0, 4, 1, 2, 3, 5]
拓扑序列 5: [0, 4, 1, 3, 2, 5]
拓扑序列 6: [0, 4, 1, 3, 5, 2]