本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：拓扑排序用于在有向无环图（DAG）中对节点进行线性排序，它在计算机科学中的数据结构和算法领域有广泛应用，如课程安排和任务调度。本文详细介绍拓扑排序的步骤，包括建立邻接表、确定入度、排序过程、环路处理以及验证排序结果。同时，探讨了深度优先搜索（DFS）和广度优先搜索（BFS）两种实现方法，以及拓扑排序的变体和实际应用案例。
拓扑排序 整体 拓扑排序

1. 拓扑排序的定义与应用场景

拓扑排序是一种对有向无环图（DAG）中顶点的线性排序，使得对于每一条有向边(u, v)，顶点u都在顶点v之前。这种排序技术在多个领域有着广泛的应用，包括项目管理、课程表安排、以及编译器中的依赖处理等。理解拓扑排序的原理对于掌握图论基础和解决现实问题至关重要。

1.1 拓扑排序的基本概念

拓扑排序首先是关于图论的一个概念，它帮助我们确定有向图中顶点的顺序，这种顺序保证了图中没有任何一条边是反向的。换句话说，如果存在一条从顶点A指向顶点B的边，那么在排序结果中，顶点A将始终出现在顶点B之前。拓扑排序可以被看作是将图中的事件或任务组织成一个满足特定先后关系的序列。

1.2 应用场景的分析

拓扑排序在多个领域都有其实际应用。在软件开发中，它可以被用来解决依赖问题，如在构建软件包或类库时确定安装或编译顺序。在项目管理中，它有助于制定项目的执行计划，确保项目活动的执行顺序不会违反其依赖性约束。此外，拓扑排序也被应用于课程表编排，确保学生可以按先决条件顺序完成课程学习。

在接下来的章节中，我们将详细介绍如何使用邻接表来表示图，以及如何通过确定入度来识别源节点，并进一步探索拓扑排序的具体实现方法、环路检测和处理策略，以及如何验证排序结果的正确性。最后，我们将探讨拓扑排序在不同领域的实际应用案例以及其变体。

2. 邻接表建立方法

2.1 邻接表数据结构的介绍

2.1.1 邻接表的概念和特性

邻接表是图数据结构的一种表现形式，它特别适合表示稀疏图。在邻接表中，图由一系列顶点（Vertex）和边（Edge）组成。每个顶点都有一条边的列表，表示所有与该顶点相连接的顶点。邻接表的一个主要优点是它只需要存储图中实际存在的边，大大节省了空间。

邻接表的主要特性包括：

  • 空间效率 ：对于稀疏图来说，邻接表比邻接矩阵节省空间。
  • 遍历效率 ：邻接表便于遍历所有与顶点相邻的顶点。
  • 动态特性 ：添加或删除顶点和边较为方便。

2.1.2 邻接表的存储方式和操作

邻接表通常使用链表、数组或哈希表等数据结构来实现。在编程语言中，如C++和Java，通常使用类或结构体来表示顶点，其中包含一个链表数组。链表数组的每个节点指向与该顶点相邻的其他顶点。对于有向图而言，数组的大小等于图中顶点的数量。

邻接表的操作主要包括：

  • 初始化 ：创建一个大小等于顶点数目的数组，每个顶点初始时没有任何边。
  • 添加边 ：将目标顶点添加到源顶点的邻接链表中。
  • 删除边 ：从源顶点的邻接链表中移除目标顶点。

2.2 邻接表的构建过程

2.2.1 数据的输入与邻接表的初始化

构建邻接表的第一步是初始化一个空的邻接表。接下来需要输入图的顶点和边的数据。在顶点输入完成后，每个顶点的邻接链表都是空的。随着边数据的输入，我们将这些边添加到对应的邻接链表中。

假设我们有一个图的顶点集合V和边集合E，图的顶点数量为 |V| ，边的数量为 |E| 。初始化邻接表的伪代码如下： 

初始化邻接表 adjList
对于每个顶点 v ∈ V:
    创建链表 list_v
    将 list_v 设置为 adjList[v] 的值

2.2.2 边的添加和邻接表的动态更新

在邻接表中添加边是一个动态的过程。给定一个有向边(u, v)，我们首先检查是否已经存在从u到v的边。如果不存在，则将顶点v添加到顶点u的邻接链表中。

以下是一个添加边的示例代码： 

// 定义边结构体
struct EdgeNode {
    int adjvex; // 边指向的顶点的位置索引
    EdgeNode *next; // 指向下一条边的指针
};

// 定义顶点结构体
struct VertexNode {
    int data; // 顶点信息
    EdgeNode *firstEdge; // 指向第一条依附于该顶点的边
};

// 定义图结构
struct Graph {
    VertexNode adjList[MAX_VERTICES]; // 邻接表
    int n, e; // 顶点数和边数
};

// 添加边函数
void addEdge(Graph *G, int u, int v) {
    // 创建新的边节点
    EdgeNode *newEdge = new EdgeNode();
    newEdge->adjvex = v;
    newEdge->next = G->adjList[u].firstEdge;
    G->adjList[u].firstEdge = newEdge;
}

此代码段展示了如何在C++中通过添加新的边节点来动态更新邻接表。 addEdge 函数负责在顶点u的链表头部添加一条指向顶点v的边。由于是链表，因此添加操作的时间复杂度为O(1)。

通过这种方式，我们可以有效地构建和维护邻接表，为后续的拓扑排序或其他图算法打下基础。

3. 入度的确定与源节点识别

在有向图中，边的方向性导致顶点之间的依赖关系。拓扑排序的核心就是确定这种依赖关系，以便按照特定顺序处理顶点。为了实现这一目标，需要使用入度（in-degree）这个概念，它代表了从其他顶点指向该顶点的边的数量。源节点（source node）是没有前驱的节点，即入度为零的节点。本章将深入探讨如何确定入度和识别源节点，并讨论它们在拓扑排序中的作用。

3.1 入度的概念及计算方法

3.1.1 入度的定义和在拓扑排序中的作用

入度是针对有向图中顶点的一种度量，它反映了有多少条边指向该顶点。在拓扑排序中，入度的概念至关重要，因为它决定了顶点是否可以被安排在排序序列中的位置。一个顶点只有在其所有前驱顶点都被排序后，才能被加入到排序序列中，这正是入度为零的顶点可以被立即加入序列的原因。

3.1.2 入度数组的建立和更新策略

要建立入度数组，首先需要遍历图中所有的边，将每条边指向的顶点的入度加一。这可以通过数组来完成，数组的索引对应图中的顶点，元素值对应顶点的入度。 

int[] inDegree = new int[numOfVertices]; // 假设numOfVertices为顶点的数量
for (int[] edge : edges) {
    inDegree[edge[1]]++; // 对于每条边，从edge[0]指向edge[1]，所以edge[1]的入度加一
}

在排序过程中，当一个顶点被选中并加入到排序序列中后，需要更新其他顶点的入度。这意味着减少该顶点指向的所有顶点的入度。 

void updateInDegree(int[] inDegree, int processedVertex) {
    for (int i = 0; i < numOfEdges; i++) {
        if (edges[i][0] == processedVertex) { // edges[i][0]指向edges[i][1]
            inDegree[edges[i][1]]--;
        }
    }
}

3.2 源节点的识别技巧

3.2.1 源节点的定义和识别算法

源节点是没有前驱的顶点，也就是说，它的入度为零。识别源节点是拓扑排序的第一步，因为源节点是构建拓扑排序序列的起点。识别算法可以在建立入度数组的过程中同步进行。 

List<Integer> sources = new ArrayList<>();
for (int i = 0; i < numOfVertices; i++) {
    if (inDegree[i] == 0) {
        sources.add(i); // 将入度为零的顶点添加到源节点列表中
    }
}

3.2.2 源节点的选择对排序的影响

选择不同的源节点会影响拓扑排序的顺序，但不会影响排序的正确性。在实际应用中，可能需要根据具体需求选择源节点，以实现特定的排序序列。例如，在课程安排应用中，可能需要根据先决条件课程的安排来选择源节点。 

flowchart LR
    A[开始]
    B[初始化图和入度数组]
    C[识别源节点]
    D[从源节点开始拓扑排序]
    E[返回排序结果]
    A --> B
    B --> C
    C --> D
    D --> E

在实现源节点识别时，要注意以下几点：
- 确保在构建图的数据结构时，边的信息是准确的。
- 入度数组需要与图的顶点数量匹配。
- 识别过程应该是高效的，避免不必要的重复计算。

通过源节点的识别和入度数组的建立，可以为拓扑排序奠定坚实的基础。接下来的章节将会介绍如何使用这些基础信息来完成拓扑排序的过程，以及如何处理可能出现的环路问题。

4. 拓扑排序的排序过程与环路处理

拓扑排序是针对有向无环图（DAG）的一种排序算法，它能将图中的顶点排成一个线性序列，使得对于图中的每一条有向边(u, v)，顶点u都在顶点v之前。这个线性序列被称作拓扑序列。在这一章节中，我们将深入探讨拓扑排序的过程，并解释如何处理图中可能出现的环路问题。

4.1 拓扑排序的基本算法

4.1.1 排序过程的逻辑描述

拓扑排序的逻辑是基于图中的入度概念进行的。入度是指指向该顶点的边的数量。排序过程从入度为0的顶点开始，因为这些顶点没有任何前驱节点，可以被看作是排序序列的起点。按照以下步骤进行：

  1. 初始化 ：计算所有顶点的入度，并将所有入度为0的顶点放入一个队列中。
  2. 循环处理 ：当队列非空时，重复以下步骤：
    - 从队列中取出一个顶点，将其加入到拓扑排序的序列中。
    - 遍历此顶点的所有邻接点，将这些邻接点的入度减1。
    - 若邻接点的入度减为0，则将该邻接点加入队列中。
  3. 结束条件 ：当队列为空且所有顶点都已被处理，则结束排序；若队列为空但还有未处理的顶点，则表示图中存在环。

4.1.2 排序算法的代码实现步骤

下面是一个用Python实现的拓扑排序算法的代码示例： 

from collections import deque

def topological_sort(graph, num_nodes):
    # 计算所有顶点的入度
    in_degree = [0] * num_nodes
    for node in graph:
        for neighbour in graph[node]:
            in_degree[neighbour] += 1

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

    # 存储排序结果
    sorted_order = []
    while queue:
        current = queue.popleft()
        sorted_order.append(current)

        # 遍历当前顶点的所有邻接点
        for neighbour in graph[current]:
            in_degree[neighbour] -= 1
            # 如果邻接点的入度减为0，则加入队列
            if in_degree[neighbour] == 0:
                queue.append(neighbour)

    # 检查是否有未处理的顶点，即图中是否存在环
    if len(sorted_order) == num_nodes:
        return sorted_order
    else:
        return None

在此代码中，我们首先初始化每个顶点的入度数组，然后创建一个队列并将所有入度为0的顶点加入队列。接着，我们进入一个循环，在这个循环中，我们从队列中弹出顶点并将其加入拓扑排序序列，同时更新所有邻接点的入度，并将入度变为0的邻接点加入队列。最后，我们检查排序序列的长度是否与顶点数相同，以确定图中是否存在环。

4.2 拓扑排序中的环路检测

4.2.1 环路出现的原因和检测方法

环路是指在有向图中，存在一系列顶点 v1, v2, ..., vn ，使得从 v1 到 vn 都有路径存在，且 v1 能通过一条路径回到自己。在拓扑排序过程中，如果遇到图中存在环路，那么排序无法进行到底，因为环路中的顶点相互依赖，无法确定它们的线性排序。

环路的检测通常在排序过程中进行，通过检查是否所有顶点都被处理来确定是否存在环。如果在队列为空的情况下，还有顶点的入度不为0，则说明这些顶点无法被加入排序序列，从而推断出图中存在环。

4.2.2 处理环路的策略和算法优化

一旦检测到环路，算法必须停止，并返回一个错误或者空的排序序列。在某些情况下，可能需要进一步的步骤来处理这种环路情况，比如：

  • 删除边或顶点 ：在有些应用中，可以通过删除导致环路的边或顶点来解决问题。例如，在课程安排问题中，如果检测到环路，可能意味着某些课程之间存在依赖性错误，需要调整课程之间的依赖关系。
  • 反馈循环 ：在有向图表示的反馈系统中，环路可能是系统设计的一部分。在这种情况下，算法可能需要进一步调整，以处理环路，并确保系统的稳定性和功能性。

此外，如果图中的顶点数目非常大，或者算法需要频繁执行，那么可以通过优化数据结构和算法的实现来提升效率。例如，使用哈希表（字典）来存储邻接表可以加快边的查找速度，而使用堆（优先队列）可以优化出队操作的效率。

通过本章的内容，我们已经了解到拓扑排序的排序过程以及环路处理的策略。下一章，我们将探讨如何验证拓扑排序结果的正确性，并分析排序结果在实际问题中的应用。

5. 拓扑排序结果的验证

5.1 验证排序结果正确性的方法

5.1.1 正确排序的逻辑条件

在执行拓扑排序算法后，我们得到了一个序列，其表示了图中节点的一个排列。为了验证这个排列是正确的，我们需要检查它是否满足拓扑排序的所有逻辑条件。首先，对于图中的每一条有向边(u, v)，节点u必须在序列中出现在节点v之前。这意味着，没有一个节点会排在它的前驱节点之后。其次，对于图中所有的源节点（即入度为0的节点），它们应该出现在排序结果的开始位置。这是因为在排序算法的执行过程中，所有源节点是首先被选出并输出的。

5.1.2 验证算法的编写和测试案例

为了验证拓扑排序的结果，我们可以编写一个函数来检查上述逻辑条件是否得到满足。以下是一个示例的Python代码段，用于验证拓扑排序结果的正确性。 

def validate_topological_sort(graph, sorted_nodes):
    """
    验证拓扑排序结果的正确性。
    :param graph: 邻接表表示的有向图
    :param sorted_nodes: 拓扑排序后的节点列表
    :return: 如果排序正确，返回True；否则返回False
    """
    node_count = len(graph)
    in_degree = [0] * node_count

    # 计算所有节点的入度
    for node, neighbors in graph.items():
        for neighbor in neighbors:
            in_degree[neighbor] += 1

    # 检查排序结果是否满足拓扑排序的条件
    for i, node in enumerate(sorted_nodes):
        for neighbor in graph[node]:
            # 如果排序后在当前节点之后的节点有比当前节点的入度小，则拓扑排序不正确
            if sorted_nodes.index(neighbor) <= i:
                return False
            # 减少该节点的入度
            in_degree[neighbor] -= 1
            # 如果入度变为负，则说明存在环
            if in_degree[neighbor] < 0:
                return False

    # 如果所有节点都被访问过，则排序正确
    return all(d == 0 for d in in_degree)

# 示例图的邻接表表示
graph = {
    0: [1, 2],
    1: [3],
    2: [3],
    3: []
}

# 拓扑排序后的节点列表
sorted_nodes = [0, 1, 2, 3]

# 验证排序结果
if validate_topological_sort(graph, sorted_nodes):
    print("拓扑排序结果正确。")
else:
    print("拓扑排序结果错误。")

以上代码段提供了一个有效的验证方法。我们首先计算出所有节点的入度，然后遍历排序后的节点列表，检查排序结果是否满足条件。我们还应该测试不同的输入情况，以确保验证函数能够准确地工作。

5.2 排序结果的分析和应用

5.2.1 结果的统计分析

在验证了拓扑排序的结果之后，我们可以进一步对结果进行统计分析。这包括分析排序序列中每个节点的前驱和后继数量、统计排序过程中涉及到的边的数量，以及评估整个拓扑排序算法的性能。例如，我们可以分析排序中源节点的数量，以及是否有多个节点的入度始终为1，这些信息对于理解图的结构特性非常有用。

5.2.2 排序结果在实际问题中的应用分析

拓扑排序的结果在许多实际问题中都有广泛的应用。在软件工程中，它可以用来确定模块或任务之间的依赖关系。在教学领域，它可以帮助创建一个满足先决条件要求的课程表。在项目管理中，它可以用来安排任务的执行顺序，确保项目按照正确的顺序推进，从而避免资源浪费和提高效率。在操作系统中，它可以用于进程调度，确保在执行一个进程之前，所有其依赖的进程已经完成。

为了展示这些应用，我们可以使用拓扑排序结果来创建一个可视化的项目依赖图，帮助项目管理团队理解任务之间的依赖关系，从而更好地规划项目的进程。

通过以上章节的详细介绍和示例，我们理解了拓扑排序结果的验证方法和如何将这些结果应用于实际问题中。这些步骤展示了拓扑排序不仅仅是算法上的一个技巧，更是解决复杂依赖关系问题的强大工具。

6. 拓扑排序的DFS和BFS实现方法

在本章中，我们将探讨拓扑排序的两种主要实现方法：深度优先搜索（DFS）和广度优先搜索（BFS）。通过对比这两种方法的原理和实现细节，我们将揭示它们在不同场景下的优势和劣势，并提供代码实现以供参考。

6.1 使用深度优先搜索(DFS)实现拓扑排序

6.1.1 DFS排序算法原理

深度优先搜索是一种用于图遍历或树遍历的算法，其核心思想是从一个顶点开始，尽可能深地遍历图的分支，直到无法继续为止，然后回溯到上一个分叉点继续寻找新的分支。在拓扑排序中，DFS可以用来检测图中是否存在环，并在不存在环的情况下进行排序。

DFS算法在执行拓扑排序时会维护一个递归栈。当一个顶点的所有邻接点都已被访问后，它会从栈中弹出并输出，这样输出的顺序实际上就是拓扑排序的结果。

6.1.2 DFS实现的代码细节和效率分析

在Python中，可以使用递归和全局变量来实现DFS拓扑排序。以下是DFS拓扑排序的伪代码实现： 

def dfs(graph, visited, stack, vertex):
    visited[vertex] = True
    for neighbor in graph[vertex]:
        if not visited[neighbor]:
            dfs(graph, visited, stack, neighbor)
    stack.insert(0, vertex)  # 将顶点插入栈的顶部

def topological_sort(graph):
    visited = {v: False for v in graph}  # 初始化访问状态
    stack = []  # 初始化输出栈

    for vertex in graph:
        if not visited[vertex]:
            dfs(graph, visited, stack, vertex)
    return stack  # 栈的顺序即为拓扑排序的结果

在这段代码中， dfs 函数递归地遍历每一个未访问的邻接点，当所有邻接点都被访问之后，将当前顶点压入栈中。最终，栈的逆序就是拓扑排序的结果。

在效率方面，DFS的时间复杂度为O(V+E)，其中V是顶点的数量，E是边的数量。这是因为DFS需要访问图中所有顶点和边。DFS的主要优势在于其空间复杂度较低，尤其适用于边稀疏的图。

6.2 使用广度优先搜索(BFS)实现拓扑排序

6.2.1 BFS排序算法原理

广度优先搜索算法逐层遍历图的顶点，直到所有顶点都被访问。在拓扑排序中，BFS利用入度的概念来实现排序。首先，将所有入度为零的顶点加入到一个队列中，然后不断从队列中取出顶点，将其邻接点的入度减一，并在邻接点的入度减为零时将其加入队列。重复此过程，直到队列为空。

在BFS中，顶点的输出顺序就是其拓扑排序的结果。

6.2.2 BFS实现的代码细节和效率分析

在Python中，可以使用队列来实现BFS拓扑排序。以下是BFS拓扑排序的伪代码实现： 

from collections import deque

def topological_sort_bfs(graph):
    indegree = {v: 0 for v in graph}  # 初始化所有顶点的入度为0
    for vertex in graph:
        for neighbor in graph[vertex]:
            indegree[neighbor] += 1  # 计算每个顶点的入度

    queue = deque()  # 初始化队列
    for vertex in indegree:
        if indegree[vertex] == 0:
            queue.append(vertex)  # 将所有入度为0的顶点加入队列

    sorted_list = []  # 存储拓扑排序的结果

    while queue:
        vertex = queue.popleft()
        sorted_list.append(vertex)
        for neighbor in graph[vertex]:
            indegree[neighbor] -= 1
            if indegree[neighbor] == 0:
                queue.append(neighbor)  # 若邻接点入度变为0，则加入队列
    return sorted_list

在这段代码中，首先计算所有顶点的入度，然后将所有入度为0的顶点加入到队列中。在队列不为空的情况下，不断从队列中取出顶点，并将其邻接点的入度减一，当邻接点入度减为零时，将其加入队列。最终，当队列为空时，得到的 sorted_list 就是拓扑排序的结果。

BFS的效率与DFS相似，时间复杂度为O(V+E)，但其在处理稠密图时更加高效，因为BFS能够更早地发现和处理入度为零的顶点。

通过本章节的介绍，我们了解了如何使用DFS和BFS两种不同的方法来实现拓扑排序。DFS适合边稀疏的图，而BFS适合边稠密的图。在选择实现方法时，需要根据具体问题的需求和图的特性来决定。下一章节我们将介绍如何验证拓扑排序结果的正确性，并分析排序结果在实际问题中的应用。

7. 拓扑排序变体与应用案例

拓扑排序是图论中解决有向无环图(DAG)节点排序问题的经典算法。在实际应用中，根据不同的需求，出现了一些拓扑排序的变体，它们在保持原有算法核心思想的基础上，对细节进行了调整以适应特定场景。

7.1 拓扑排序的变体介绍

7.1.1 变体算法的提出背景和适用场景

随着图结构的广泛应用，拓扑排序的变体应运而生。例如，在项目管理中，需要根据任务的依赖关系合理安排项目的执行顺序；在课程安排中，需要确保学生在上某门课程前已经掌握了必要的先修课程知识。这些情况下的拓扑排序需要考虑特定约束条件，从而发展出了不同的变体算法。变体算法通常在如何处理节点的入度、如何选择下一个要输出的节点等方面进行了改进。

7.1.2 变体算法的实现原理和代码示例

一个典型的拓扑排序变体是针对具有多源点的图进行排序。在这种情况下，我们可能需要从多个源点开始排序，或者对图中的某些节点进行优先级排序。代码示例可能如下所示： 

from collections import deque, defaultdict

def topological_sort(variant_graph):
    in_degree = defaultdict(int)
    graph = defaultdict(list)
    for node, edges in variant_graph.items():
        in_degree[node] = 0
        for edge in edges:
            graph[edge[0]].append(node)
            in_degree[node] += 1

    # 对于多源点或优先级排序的处理
    sources = deque([node for node in in_degree if in_degree[node] == 0])

    sorted_order = []
    while sources:
        node = sources.popleft()
        sorted_order.append(node)

        for neighbor in graph[node]:
            in_degree[neighbor] -= 1
            if in_degree[neighbor] == 0:
                sources.append(neighbor)

    return sorted_order if len(sorted_order) == len(variant_graph) else []

# 示例图结构
variant_graph = {
    'A': [('B', 1), ('C', 1)],  # 假设节点间有权重，可以根据权重选择入度
    'B': [('D', 1)],
    'C': [('D', 1)],
    'D': []
}

sorted_result = topological_sort(variant_graph)
print(sorted_result)

在上述代码中，我们构建了一个带有权重的图结构，其中权重代表了节点间的依赖关系强度。排序时优先选择权重较高的节点，以处理多源点或具有特定优先级的场景。

7.2 拓扑排序在不同领域的应用案例

7.2.1 项目管理中的应用

在项目管理中，拓扑排序用于确定任务的执行顺序。假设有一个构建软件的项目，各个模块的开发和测试存在依赖关系。应用拓扑排序可以确保在开发一个模块之前，其所有依赖的模块都已开发完成。

7.2.2 课程安排中的应用

学校课程安排通常需要满足先修课的要求，即某些课程必须在其他课程之后才能学习。使用拓扑排序算法可以帮助创建一个有效的课程时间表，确保学生在学习高级课程前已经掌握了必要的基础知识。

7.2.3 其他领域中的应用分析

除了上述领域，拓扑排序也被广泛应用于以下领域：
- 软件包依赖管理：确保软件安装顺序符合依赖关系。
- 编译器中的指令调度：确定指令的执行顺序。
- 网络通信：确定消息传递的顺序，避免死锁和循环依赖。
- 人工智能：用于路径规划、任务调度等。

通过这些应用案例，我们可以看出拓扑排序及其变体在解决现实世界问题中的灵活性和实用性。随着技术的发展和新需求的出现，拓扑排序算法不断被扩展和改进，以满足更多领域的需求。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：拓扑排序用于在有向无环图（DAG）中对节点进行线性排序，它在计算机科学中的数据结构和算法领域有广泛应用，如课程安排和任务调度。本文详细介绍拓扑排序的步骤，包括建立邻接表、确定入度、排序过程、环路处理以及验证排序结果。同时，探讨了深度优先搜索（DFS）和广度优先搜索（BFS）两种实现方法，以及拓扑排序的变体和实际应用案例。


本文还有配套的精品资源，点击获取
menu-r.4af5f7ec.gif

Logo
乐奇 Rokid 开放社区

更多推荐

cover

微安级唤醒、2节干电池直供：CI3422如何重新定义电池供电设备的语音交互

avatar 乐奇 Rokid 开放社区
cover

基于 Rokid AIUI：从一句咒语到一副眼镜，我做了款 AR 寻宝游戏《寻宝猎手》

avatar 乐奇 Rokid 开放社区
cover

AR巡检哪家好

avatar 乐奇 Rokid 开放社区