From 2c96e433e24cda8d6953b88157ca428e95ba3b08 Mon Sep 17 00:00:00 2001 From: krahets Date: Tue, 11 Jul 2023 19:21:38 +0800 Subject: [PATCH] deploy --- 404.html | 16 + chapter_appendix/contribution/index.html | 16 + chapter_appendix/installation/index.html | 22 +- chapter_array_and_linkedlist/array/index.html | 16 + chapter_array_and_linkedlist/index.html | 16 + .../linked_list/index.html | 16 + chapter_array_and_linkedlist/list/index.html | 16 + .../summary/index.html | 16 + .../backtracking_algorithm/index.html | 48 +- chapter_backtracking/index.html | 16 + .../n_queens_problem/index.html | 16 + .../permutations_problem/index.html | 22 +- .../subset_sum_problem/index.html | 16 + chapter_backtracking/summary/index.html | 16 + chapter_computational_complexity/index.html | 16 + .../performance_evaluation/index.html | 16 + .../space_complexity/index.html | 16 + .../summary/index.html | 16 + .../time_complexity/index.html | 16 + .../basic_data_types/index.html | 32 +- .../character_encoding/index.html | 16 + .../index.html | 30 +- chapter_data_structure/index.html | 16 + .../number_encoding/index.html | 16 + chapter_data_structure/summary/index.html | 16 + .../climbing_stairs_constraint_example.png | Bin ...mbing_stairs_constraint_state_transfer.png | Bin .../min_cost_cs_dp.png | Bin .../min_cost_cs_example.png | Bin .../dp_problem_features/index.html | 24 +- .../dp_solution_pipeline/index.html | 20 +- chapter_dynamic_programming/index.html | 16 + .../intro_to_dynamic_programming/index.html | 16 + .../knapsack_problem/index.html | 38 +- .../coin_change_dp_step1.png | Bin 0 -> 62488 bytes .../coin_change_dp_step10.png | Bin 0 -> 66659 bytes .../coin_change_dp_step11.png | Bin 0 -> 65281 bytes .../coin_change_dp_step12.png | Bin 0 -> 65664 bytes .../coin_change_dp_step13.png | Bin 0 -> 66014 bytes .../coin_change_dp_step14.png | Bin 0 -> 65685 bytes .../coin_change_dp_step15.png | Bin 0 -> 58827 bytes .../coin_change_dp_step2.png | Bin 0 -> 64473 bytes .../coin_change_dp_step3.png | Bin 0 -> 66980 bytes .../coin_change_dp_step4.png | Bin 0 -> 67091 bytes .../coin_change_dp_step5.png | Bin 0 -> 67371 bytes .../coin_change_dp_step6.png | Bin 0 -> 67380 bytes .../coin_change_dp_step7.png | Bin 0 -> 65428 bytes .../coin_change_dp_step8.png | Bin 0 -> 66609 bytes .../coin_change_dp_step9.png | Bin 0 -> 66803 bytes .../coin_change_example.png | Bin 0 -> 55454 bytes .../coin_change_ii_example.png | Bin 0 -> 63093 bytes .../unbounded_knapsack_dp_comp_step1.png | Bin 0 -> 66784 bytes .../unbounded_knapsack_dp_comp_step2.png | Bin 0 -> 67442 bytes .../unbounded_knapsack_dp_comp_step3.png | Bin 0 -> 68946 bytes .../unbounded_knapsack_dp_comp_step4.png | Bin 0 -> 69343 bytes .../unbounded_knapsack_dp_comp_step5.png | Bin 0 -> 68784 bytes .../unbounded_knapsack_dp_comp_step6.png | Bin 0 -> 69037 bytes .../unbounded_knapsack_example.png | Bin 0 -> 70520 bytes .../unbounded_knapsack_problem/index.html | 3202 +++++++++++++++++ chapter_graph/graph/index.html | 16 + chapter_graph/graph_operations/index.html | 16 + chapter_graph/graph_traversal/index.html | 16 + chapter_graph/index.html | 16 + chapter_graph/summary/index.html | 16 + chapter_hashing/hash_algorithm/index.html | 16 + chapter_hashing/hash_collision/index.html | 16 + chapter_hashing/hash_map/index.html | 16 + chapter_hashing/index.html | 16 + chapter_hashing/summary/index.html | 16 + chapter_heap/build_heap/index.html | 16 + chapter_heap/heap/index.html | 16 + chapter_heap/index.html | 16 + chapter_heap/summary/index.html | 16 + chapter_heap/top_k/index.html | 16 + .../algorithms_are_everywhere/index.html | 16 + chapter_introduction/index.html | 16 + chapter_introduction/summary/index.html | 16 + chapter_introduction/what_is_dsa/index.html | 16 + chapter_preface/about_the_book/index.html | 16 + chapter_preface/index.html | 16 + chapter_preface/suggestions/index.html | 16 + chapter_preface/summary/index.html | 16 + chapter_reference/index.html | 16 + chapter_searching/binary_search/index.html | 16 + .../binary_search_edge/index.html | 16 + chapter_searching/index.html | 16 + .../replace_linear_by_hashing/index.html | 16 + .../searching_algorithm_revisited/index.html | 16 + chapter_searching/summary/index.html | 16 + chapter_sorting/bubble_sort/index.html | 16 + chapter_sorting/bucket_sort/index.html | 16 + chapter_sorting/counting_sort/index.html | 16 + chapter_sorting/heap_sort/index.html | 16 + chapter_sorting/index.html | 16 + chapter_sorting/insertion_sort/index.html | 16 + chapter_sorting/merge_sort/index.html | 16 + chapter_sorting/quick_sort/index.html | 16 + chapter_sorting/radix_sort/index.html | 16 + chapter_sorting/selection_sort/index.html | 16 + chapter_sorting/sorting_algorithm/index.html | 16 + chapter_sorting/summary/index.html | 16 + chapter_stack_and_queue/deque/index.html | 16 + chapter_stack_and_queue/index.html | 16 + chapter_stack_and_queue/queue/index.html | 16 + chapter_stack_and_queue/stack/index.html | 16 + chapter_stack_and_queue/summary/index.html | 16 + .../array_representation_of_tree/index.html | 16 + chapter_tree/avl_tree/index.html | 16 + chapter_tree/binary_search_tree/index.html | 16 + chapter_tree/binary_tree/index.html | 16 + chapter_tree/binary_tree_traversal/index.html | 16 + chapter_tree/index.html | 16 + chapter_tree/summary/index.html | 16 + index.html | 16 + search/search_index.json | 2 +- sitemap.xml | 173 +- sitemap.xml.gz | Bin 836 -> 847 bytes 117 files changed, 4713 insertions(+), 132 deletions(-) rename chapter_dynamic_programming/{intro_to_dynamic_programming.assets => dp_problem_features.assets}/climbing_stairs_constraint_example.png (100%) rename chapter_dynamic_programming/{intro_to_dynamic_programming.assets => dp_problem_features.assets}/climbing_stairs_constraint_state_transfer.png (100%) rename chapter_dynamic_programming/{intro_to_dynamic_programming.assets => dp_problem_features.assets}/min_cost_cs_dp.png (100%) rename chapter_dynamic_programming/{intro_to_dynamic_programming.assets => dp_problem_features.assets}/min_cost_cs_example.png (100%) create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step1.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step10.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step11.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step12.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step13.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step14.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step15.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step2.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step3.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step4.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step5.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step6.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step7.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step8.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step9.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_example.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_ii_example.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step1.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step2.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step3.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step4.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step5.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step6.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_example.png create mode 100644 chapter_dynamic_programming/unbounded_knapsack_problem/index.html diff --git a/404.html b/404.html index 9c625c147..e23cd441a 100644 --- a/404.html +++ b/404.html @@ -1893,6 +1893,8 @@ + + @@ -1971,6 +1973,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_appendix/contribution/index.html b/chapter_appendix/contribution/index.html index 9e0e2ed47..321f879f4 100644 --- a/chapter_appendix/contribution/index.html +++ b/chapter_appendix/contribution/index.html @@ -1904,6 +1904,8 @@ + + @@ -1982,6 +1984,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_appendix/installation/index.html b/chapter_appendix/installation/index.html index d512c5496..6d25020ff 100644 --- a/chapter_appendix/installation/index.html +++ b/chapter_appendix/installation/index.html @@ -15,7 +15,7 @@ - + @@ -1904,6 +1904,8 @@ + + @@ -1982,6 +1984,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + @@ -2437,7 +2453,7 @@ diff --git a/chapter_array_and_linkedlist/index.html b/chapter_array_and_linkedlist/index.html index 5fd01a021..be38e79e0 100644 --- a/chapter_array_and_linkedlist/index.html +++ b/chapter_array_and_linkedlist/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_array_and_linkedlist/linked_list/index.html b/chapter_array_and_linkedlist/linked_list/index.html index cc8a71245..006c295e9 100644 --- a/chapter_array_and_linkedlist/linked_list/index.html +++ b/chapter_array_and_linkedlist/linked_list/index.html @@ -1968,6 +1968,8 @@ + + @@ -2046,6 +2048,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_array_and_linkedlist/list/index.html b/chapter_array_and_linkedlist/list/index.html index fee0203b3..492dbfd5f 100644 --- a/chapter_array_and_linkedlist/list/index.html +++ b/chapter_array_and_linkedlist/list/index.html @@ -1954,6 +1954,8 @@ + + @@ -2032,6 +2034,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_array_and_linkedlist/summary/index.html b/chapter_array_and_linkedlist/summary/index.html index 48f6b6aa4..b32c4c7a1 100644 --- a/chapter_array_and_linkedlist/summary/index.html +++ b/chapter_array_and_linkedlist/summary/index.html @@ -1947,6 +1947,8 @@ + + @@ -2025,6 +2027,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_backtracking/backtracking_algorithm/index.html b/chapter_backtracking/backtracking_algorithm/index.html index 31a7d8069..5644c636d 100644 --- a/chapter_backtracking/backtracking_algorithm/index.html +++ b/chapter_backtracking/backtracking_algorithm/index.html @@ -1870,14 +1870,14 @@
  • - 12.1.5.   典型例题 + 12.1.5.   优势与局限性
  • - 12.1.6.   优势与局限性 + 12.1.6.   典型例题
    • @@ -1982,6 +1982,8 @@ + + @@ -2060,6 +2062,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + @@ -2236,14 +2252,14 @@
  • - 12.1.5.   典型例题 + 12.1.5.   优势与局限性
  • - 12.1.6.   优势与局限性 + 12.1.6.   典型例题
    • @@ -2273,7 +2289,7 @@

    12.1.   回溯算法

    「回溯算法 Backtracking Algorithm」是一种通过穷举来解决问题的方法，它的核心思想是从一个初始状态出发，暴力搜索所有可能的解决方案，当遇到正确的解则将其记录，直到找到解或者尝试了所有可能的选择都无法找到解为止。

    -

    回溯算法通常采用「深度优先搜索」来遍历解空间。在二叉树章节中，我们提到前序、中序和后序遍历都属于深度优先搜索。下面，我们将从前序遍历入手，逐步了解回溯算法的工作原理。

    +

    回溯算法通常采用「深度优先搜索」来遍历解空间。在二叉树章节中，我们提到前序、中序和后序遍历都属于深度优先搜索。接下来我们先用前序遍历构造一个回溯问题，逐步了解回溯算法的工作原理。

    例题一

    给定一个二叉树，搜索并记录所有值为 \(7\) 的节点，返回节点列表。

    @@ -3542,7 +3558,19 @@

    相较于基于前序遍历的实现代码，基于回溯算法框架的实现代码虽然显得啰嗦，但通用性更好。实际上，所有回溯问题都可以在该框架下解决。我们需要根据具体问题来定义 state 和 choices ，并实现框架中的各个方法。

    -

    12.1.5.   典型例题

    +

    12.1.5.   优势与局限性

    +

    回溯算法本质上是一种深度优先搜索算法，它尝试所有可能的解决方案直到找到满足条件的解。这种方法的优势在于它能够找到所有可能的解决方案，而且在合理的剪枝操作下，具有很高的效率。

    +

    然而，在处理大规模或者复杂问题时，回溯算法的运行效率可能难以接受。

    + +

    即便如此，回溯算法仍然是某些搜索问题和约束满足问题的最佳解决方案。对于这些问题，由于无法预测哪些选择可生成有效的解，因此我们必须对所有可能的选择进行遍历。在这种情况下，关键是如何进行效率优化：

    + +

    12.1.6.   典型例题

    搜索问题：这类问题的目标是找到满足特定条件的解决方案。

    请注意，回溯算法通常不是解决组合优化问题的最优方法。0-1 背包问题通常使用动态规划解决；旅行商是一个 NP-Hard 问题，常用解决方法有遗传算法和蚁群算法等；最大团问题是图轮中的一个经典 NP-Hard 问题，通常用贪心算法等启发式算法来解决。

    -

    12.1.6.   优势与局限性

    -

    回溯算法本质上是一种深度优先搜索算法，它尝试所有可能的解决方案直到找到满足条件的解。这种方法的优势在于它能够找到所有可能的解决方案，而且在合理的剪枝操作下，具有很高的效率。

    -

    然而，在处理大规模或者复杂问题时，回溯算法的运行效率可能难以接受。这是因为在最坏的情况下，回溯算法需要遍历解空间的所有可能解。例如，求解 \(n\) 皇后问题的时间复杂度可以达到 \(O(n!)\) 。回溯算法的空间复杂度也可能较高。因为在每一次递归调用时，都需要保存当前的状态（例如选择路径、用于剪枝的辅助变量等），对于深度很大的递归，空间需求可能会变得非常大。

    -

    即便如此，回溯算法仍然是某些搜索问题和约束满足问题的最佳解决方案。对于这些问题，由于我们无法预测哪些选择可生成有效的解，因此我们必须对所有可能的选择进行遍历。在这种情况下，关键是如何进行效率优化：

    - diff --git a/chapter_backtracking/index.html b/chapter_backtracking/index.html index f00b72559..9208daf75 100644 --- a/chapter_backtracking/index.html +++ b/chapter_backtracking/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_backtracking/n_queens_problem/index.html b/chapter_backtracking/n_queens_problem/index.html index 7941d6a39..6b5469dde 100644 --- a/chapter_backtracking/n_queens_problem/index.html +++ b/chapter_backtracking/n_queens_problem/index.html @@ -1947,6 +1947,8 @@ + + @@ -2025,6 +2027,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_backtracking/permutations_problem/index.html b/chapter_backtracking/permutations_problem/index.html index 176bb343c..a2bb6d847 100644 --- a/chapter_backtracking/permutations_problem/index.html +++ b/chapter_backtracking/permutations_problem/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + @@ -2231,7 +2247,7 @@

    12.2.   全排列问题

    全排列问题是回溯算法的一个典型应用。它的定义是在给定一个集合（如一个数组或字符串）的情况下，找出这个集合中元素的所有可能的排列。

    -

    如下表所示，列举了几个示例数组和其对应的所有排列。

    +

    下表列举了几个示例数据，包括输入数组和对应的所有排列。

    @@ -2559,7 +2575,7 @@

    需要重点关注的是，我们引入了一个布尔型数组 selected ，它的长度与输入数组长度相等，其中 selected[i] 表示 choices[i] 是否已被选择。我们利用 selected 避免某个元素被重复选择，从而实现剪枝。

    -

    如下图所示，假设我们第一轮选择 1 ，第二轮选择 3 ，第三轮选择 2 ，则需要在第二轮剪掉元素 1 的分支，在第三轮剪掉元素 1, 3 的分支。从本质上理解，此剪枝操作可将搜索空间大小从 \(O(n^n)\) 降低至 \(O(n!)\) 。

    +

    如下图所示，假设我们第一轮选择 1 ，第二轮选择 3 ，第三轮选择 2 ，则需要在第二轮剪掉元素 1 的分支，在第三轮剪掉元素 1, 3 的分支。此剪枝操作可将搜索空间大小从 \(O(n^n)\) 降低至 \(O(n!)\) 。

    全排列剪枝示例

    Fig. 全排列剪枝示例

    @@ -2572,7 +2588,7 @@

    重复排列

    Fig. 重复排列

    -

    那么，如何去除重复的排列呢？最直接地，我们可以借助一个哈希表，直接对排列结果进行去重。然而，这样做不够优雅，因为生成重复排列的搜索分支是没有必要的，应当被提前识别并剪枝，这样可以提升算法效率。

    +

    那么，如何去除重复的排列呢？最直接地，我们可以借助一个哈希表，直接对排列结果进行去重。然而这样做不够优雅，因为生成重复排列的搜索分支是没有必要的，应当被提前识别并剪枝，这样可以进一步提升算法效率。

    观察发现，在第一轮中，选择 \(1\) 或选择 \(\hat{1}\) 是等价的，因为在这两个选择之下生成的所有排列都是重复的。因此，我们应该把 \(\hat{1}\) 剪枝掉。同理，在第一轮选择 \(2\) 后，第二轮选择中的 \(1\) 和 \(\hat{1}\) 也会产生重复分支，因此也需要将第二轮的 \(\hat{1}\) 剪枝。

    重复排列剪枝

    Fig. 重复排列剪枝

    diff --git a/chapter_backtracking/subset_sum_problem/index.html b/chapter_backtracking/subset_sum_problem/index.html index a4ef111fc..fb4cb1dc6 100644 --- a/chapter_backtracking/subset_sum_problem/index.html +++ b/chapter_backtracking/subset_sum_problem/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_backtracking/summary/index.html b/chapter_backtracking/summary/index.html index 19c037311..c93817fc2 100644 --- a/chapter_backtracking/summary/index.html +++ b/chapter_backtracking/summary/index.html @@ -1916,6 +1916,8 @@ + + @@ -1994,6 +1996,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_computational_complexity/index.html b/chapter_computational_complexity/index.html index d0bd57385..e582aa6b7 100644 --- a/chapter_computational_complexity/index.html +++ b/chapter_computational_complexity/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_computational_complexity/performance_evaluation/index.html b/chapter_computational_complexity/performance_evaluation/index.html index 184269773..1abde9866 100644 --- a/chapter_computational_complexity/performance_evaluation/index.html +++ b/chapter_computational_complexity/performance_evaluation/index.html @@ -1981,6 +1981,8 @@ + + @@ -2059,6 +2061,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_computational_complexity/space_complexity/index.html b/chapter_computational_complexity/space_complexity/index.html index 74ebb1f49..2f44af78f 100644 --- a/chapter_computational_complexity/space_complexity/index.html +++ b/chapter_computational_complexity/space_complexity/index.html @@ -2009,6 +2009,8 @@ + + @@ -2087,6 +2089,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_computational_complexity/summary/index.html b/chapter_computational_complexity/summary/index.html index 1304ea5ba..60a06e7d9 100644 --- a/chapter_computational_complexity/summary/index.html +++ b/chapter_computational_complexity/summary/index.html @@ -1947,6 +1947,8 @@ + + @@ -2025,6 +2027,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_computational_complexity/time_complexity/index.html b/chapter_computational_complexity/time_complexity/index.html index 35a4769a5..3b4b4e8d7 100644 --- a/chapter_computational_complexity/time_complexity/index.html +++ b/chapter_computational_complexity/time_complexity/index.html @@ -2057,6 +2057,8 @@ + + @@ -2135,6 +2137,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_data_structure/basic_data_types/index.html b/chapter_data_structure/basic_data_types/index.html index 4c082ef18..e942ec164 100644 --- a/chapter_data_structure/basic_data_types/index.html +++ b/chapter_data_structure/basic_data_types/index.html @@ -1916,6 +1916,8 @@ + + @@ -1994,6 +1996,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + @@ -2260,7 +2276,7 @@
    -
    /* 使用多种「基本数据类型」来初始化「数组」 */
+
    // 使用多种基本数据类型来初始化数组
 int[] numbers = new int[5];
 float[] decimals = new float[5];
 char[] characters = new char[5];
@@ -2268,7 +2284,7 @@
    -
    /* 使用多种「基本数据类型」来初始化「数组」 */
+
    // 使用多种基本数据类型来初始化数组
 int numbers[5];
 float decimals[5];
 char characters[5];
@@ -2289,19 +2305,19 @@
    -
    /* JavaScript 的数组可以自由存储各种基本数据类型和对象 */
+
    // JavaScript 的数组可以自由存储各种基本数据类型和对象
 const array = [0, 0.0, 'a', false];
    -
    /* 使用多种「基本数据类型」来初始化「数组」 */
+
    // 使用多种基本数据类型来初始化数组
 const numbers: number[] = [];
 const characters: string[] = [];
 const booleans: boolean[] = [];
    -
    /* 使用多种「基本数据类型」来初始化「数组」 */
+
    // 使用多种基本数据类型来初始化数组
 int numbers[10];
 float decimals[10];
 char characters[10];
@@ -2309,7 +2325,7 @@
    -
    /* 使用多种「基本数据类型」来初始化「数组」 */
+
    // 使用多种基本数据类型来初始化数组
 int[] numbers = new int[5];
 float[] decimals = new float[5];
 char[] characters = new char[5];
@@ -2317,7 +2333,7 @@
    -
    /* 使用多种「基本数据类型」来初始化「数组」 */
+
    // 使用多种基本数据类型来初始化数组
 let numbers = Array(repeating: Int(), count: 5)
 let decimals = Array(repeating: Double(), count: 5)
 let characters = Array(repeating: Character("a"), count: 5)
@@ -2329,7 +2345,7 @@
    -
    /* 使用多种「基本数据类型」来初始化「数组」 */
+
    // 使用多种基本数据类型来初始化数组
 List<int> numbers = List.filled(5, 0);
 List<double> decimals = List.filled(5, 0.0);
 List<String> characters = List.filled(5, 'a');
diff --git a/chapter_data_structure/character_encoding/index.html b/chapter_data_structure/character_encoding/index.html
index 79e66e809..94d777c21 100644
--- a/chapter_data_structure/character_encoding/index.html
+++ b/chapter_data_structure/character_encoding/index.html
@@ -1975,6 +1975,8 @@
         
           
         
+          
+        
       
       
         
@@ -2053,6 +2055,20 @@
 
             
           
+            
+              
+  
+  
+  
+    
  • 
+      
+        13.5.   完全背包问题（New）
+      
+    
    • 
+  
+
+            
+          
         
       
     
diff --git a/chapter_data_structure/classification_of_data_structure/index.html b/chapter_data_structure/classification_of_data_structure/index.html
index fff502479..3a6dc4b54 100644
--- a/chapter_data_structure/classification_of_data_structure/index.html
+++ b/chapter_data_structure/classification_of_data_structure/index.html
@@ -1954,6 +1954,8 @@
         
           
         
+          
+        
       
       
         
@@ -2032,6 +2034,20 @@
 
             
           
+            
+              
+  
+  
+  
+    
  • 
+      
+        13.5.   完全背包问题（New）
+      
+    
    • 
+  
+
+            
+          
         
       
     
@@ -2219,16 +2235,22 @@
 
    数据结构可以从逻辑结构和物理结构两个维度进行分类。
    
 
    3.1.1.   逻辑结构：线性与非线性
    
 
    「逻辑结构」揭示了数据元素之间的逻辑关系。在数组和链表中，数据按照顺序依次排列，体现了数据之间的线性关系；而在树中，数据从顶部向下按层次排列，表现出祖先与后代之间的派生关系；图则由节点和边构成，反映了复杂的网络关系。
    
-
    逻辑结构通常分为「线性」和「非线性」两类。线性结构比较直观，指数据在逻辑关系上呈线性排列；非线性结构则相反，呈非线性排列，例如网状或树状结构。
    
+
    逻辑结构通常分为“线性”和“非线性”两类。线性结构比较直观，指数据在逻辑关系上呈线性排列；非线性结构则相反，呈非线性排列。
    
 
      
 
    • 线性数据结构：数组、链表、栈、队列、哈希表；
      • 
-
    • 非线性数据结构：树、图、堆、哈希表；
      • 
+
    • 非线性数据结构：树、堆、图、哈希表；
      • 
 
    
 
    线性与非线性数据结构
    
 
     Fig. 线性与非线性数据结构 
    
 
+
    非线性数据结构可以进一步被划分为树形结构和网状结构。
    
+
      
+
    • 线性结构：数组、链表、队列、栈、哈希表，元素存在一对一的顺序关系；
      • 
+
    • 树形结构：树、堆、哈希表，元素存在一对多的关系；
      • 
+
    • 网状结构：图，元素存在多对多的关系；
      • 
+
    
 
    3.1.2.   物理结构：连续与离散
    
-
    在计算机中，内存和硬盘是两种主要的存储硬件设备。「硬盘」主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。「内存」用于运行程序时暂存数据，速度较快，但容量较小（通常为 GB 级别）。
    
+
    在计算机中，内存和硬盘是两种主要的存储硬件设备。硬盘主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。内存用于运行程序时暂存数据，速度较快，但容量较小（通常为 GB 级别）。
    
 
    在算法运行过程中，相关数据都存储在内存中。下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储 1 byte 的数据，在算法运行时，所有数据都被存储在这些单元格中。
    
 
    系统通过「内存地址 Memory Location」来访问目标内存位置的数据。计算机根据特定规则为表格中的每个单元格分配编号，确保每个内存空间都有唯一的内存地址。有了这些地址，程序便可以访问内存中的数据。
    
 
    内存条、内存空间、内存地址
    
@@ -2244,7 +2266,7 @@
 
  • 基于数组可实现：栈、队列、哈希表、树、堆、图、矩阵、张量（维度 \(\geq 3\) 的数组）等；
    • 
 
  • 基于链表可实现：栈、队列、哈希表、树、堆、图等；
    • 
 
-
    基于数组实现的数据结构也被称为「静态数据结构」，这意味着此类数据结构在初始化后长度不可变。相对应地，基于链表实现的数据结构被称为「动态数据结构」，这类数据结构在初始化后，仍可以在程序运行过程中对其长度进行调整。
    
+
    基于数组实现的数据结构也被称为“静态数据结构”，这意味着此类数据结构在初始化后长度不可变。相对应地，基于链表实现的数据结构被称为“动态数据结构”，这类数据结构在初始化后，仍可以在程序运行过程中对其长度进行调整。
    
 
    
 
    Tip
    
 
    如若感觉理解物理结构有困难，建议先阅读下一章“数组与链表”，然后再回头理解物理结构的含义。数组与链表是其他所有数据结构的基石，建议你投入更多时间深入了解这两种基本数据结构。
    
diff --git a/chapter_data_structure/index.html b/chapter_data_structure/index.html
index fbcf41913..f054b9034 100644
--- a/chapter_data_structure/index.html
+++ b/chapter_data_structure/index.html
@@ -1906,6 +1906,8 @@
         
           
         
+          
+        
       
       
         
@@ -1984,6 +1986,20 @@
 
             
           
+            
+              
+  
+  
+  
+    
  • 
+      
+        13.5.   完全背包问题（New）
+      
+    
    • 
+  
+
+            
+          
         
       
     
diff --git a/chapter_data_structure/number_encoding/index.html b/chapter_data_structure/number_encoding/index.html
index 09e25d9eb..0080f67f9 100644
--- a/chapter_data_structure/number_encoding/index.html
+++ b/chapter_data_structure/number_encoding/index.html
@@ -1954,6 +1954,8 @@
         
           
         
+          
+        
       
       
         
@@ -2032,6 +2034,20 @@
 
             
           
+            
+              
+  
+  
+  
+    
  • 
+      
+        13.5.   完全背包问题（New）
+      
+    
    • 
+  
+
+            
+          
         
       
     
diff --git a/chapter_data_structure/summary/index.html b/chapter_data_structure/summary/index.html
index 88788acc7..7b592b0b9 100644
--- a/chapter_data_structure/summary/index.html
+++ b/chapter_data_structure/summary/index.html
@@ -1947,6 +1947,8 @@
         
           
         
+          
+        
       
       
         
@@ -2025,6 +2027,20 @@
 
             
           
+            
+              
+  
+  
+  
+    
  • 
+      
+        13.5.   完全背包问题（New）
+      
+    
    • 
+  
+
+            
+          
         
       
     
diff --git a/chapter_dynamic_programming/intro_to_dynamic_programming.assets/climbing_stairs_constraint_example.png b/chapter_dynamic_programming/dp_problem_features.assets/climbing_stairs_constraint_example.png
similarity index 100%
rename from chapter_dynamic_programming/intro_to_dynamic_programming.assets/climbing_stairs_constraint_example.png
rename to chapter_dynamic_programming/dp_problem_features.assets/climbing_stairs_constraint_example.png
diff --git a/chapter_dynamic_programming/intro_to_dynamic_programming.assets/climbing_stairs_constraint_state_transfer.png b/chapter_dynamic_programming/dp_problem_features.assets/climbing_stairs_constraint_state_transfer.png
similarity index 100%
rename from chapter_dynamic_programming/intro_to_dynamic_programming.assets/climbing_stairs_constraint_state_transfer.png
rename to chapter_dynamic_programming/dp_problem_features.assets/climbing_stairs_constraint_state_transfer.png
diff --git a/chapter_dynamic_programming/intro_to_dynamic_programming.assets/min_cost_cs_dp.png b/chapter_dynamic_programming/dp_problem_features.assets/min_cost_cs_dp.png
similarity index 100%
rename from chapter_dynamic_programming/intro_to_dynamic_programming.assets/min_cost_cs_dp.png
rename to chapter_dynamic_programming/dp_problem_features.assets/min_cost_cs_dp.png
diff --git a/chapter_dynamic_programming/intro_to_dynamic_programming.assets/min_cost_cs_example.png b/chapter_dynamic_programming/dp_problem_features.assets/min_cost_cs_example.png
similarity index 100%
rename from chapter_dynamic_programming/intro_to_dynamic_programming.assets/min_cost_cs_example.png
rename to chapter_dynamic_programming/dp_problem_features.assets/min_cost_cs_example.png
diff --git a/chapter_dynamic_programming/dp_problem_features/index.html b/chapter_dynamic_programming/dp_problem_features/index.html
index ad27cade8..7e072eaca 100644
--- a/chapter_dynamic_programming/dp_problem_features/index.html
+++ b/chapter_dynamic_programming/dp_problem_features/index.html
@@ -1906,6 +1906,8 @@
         
           
         
+          
+        
       
       
         
@@ -2032,6 +2034,20 @@
 
             
           
+            
+              
+  
+  
+  
+    
  • 
+      
+        13.5.   完全背包问题（New）
+      
+    
    • 
+  
+
+            
+          
         
       
     
@@ -2225,7 +2241,7 @@
 
    给定一个楼梯，你每步可以上 \(1\) 阶或者 \(2\) 阶，每一阶楼梯上都贴有一个非负整数，表示你在该台阶所需要付出的代价。给定一个非负整数数组 \(cost\) ，其中 \(cost[i]\) 表示在第 \(i\) 个台阶需要付出的代价，\(cost[0]\) 为地面起始点。请计算最少需要付出多少代价才能到达顶部？
    
 
    
 
    如下图所示，若第 \(1\) , \(2\) , \(3\) 阶的代价分别为 \(1\) , \(10\) , \(1\) ，则从地面爬到第 \(3\) 阶的最小代价为 \(2\) 。
    
-
    爬到第 3 阶的最小代价
    
+
    爬到第 3 阶的最小代价
    
 
     Fig. 爬到第 3 阶的最小代价 
    
 
 
    设 \(dp[i]\) 为爬到第 \(i\) 阶累计付出的代价，由于第 \(i\) 阶只可能从 \(i - 1\) 阶或 \(i - 2\) 阶走来，因此 \(dp[i]\) 只可能等于 \(dp[i - 1] + cost[i]\) 或 \(dp[i - 2] + cost[i]\) 。为了尽可能减少代价，我们应该选择两者中较小的那一个，即：
    
@@ -2341,7 +2357,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
    -

    爬楼梯最小代价的动态规划过程

    +

    爬楼梯最小代价的动态规划过程

    Fig. 爬楼梯最小代价的动态规划过程

    这道题同样也可以进行状态压缩，将一维压缩至零维，使得空间复杂度从 \(O(n)\) 降低至 \(O(1)\) 。

    @@ -2446,7 +2462,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]

    给定一个共有 \(n\) 阶的楼梯，你每步可以上 \(1\) 阶或者 \(2\) 阶，但不能连续两轮跳 \(1\) 阶，请问有多少种方案可以爬到楼顶。

    例如，爬上第 \(3\) 阶仅剩 \(2\) 种可行方案，其中连续三次跳 \(1\) 阶的方案不满足约束条件，因此被舍弃。

    -

    带约束爬到第 3 阶的方案数量

    +

    带约束爬到第 3 阶的方案数量

    Fig. 带约束爬到第 3 阶的方案数量

    在该问题中，下一步选择不能由当前状态（当前楼梯阶数）独立决定，还和前一个状态（上轮楼梯阶数）有关。如果上一轮是跳 \(1\) 阶上来的，那么下一轮就必须跳 \(2\) 阶。

    @@ -2463,7 +2479,7 @@ dp[i, 1] = dp[i-1, 2] \\ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2] \end{cases} \]
    -

    考虑约束下的递推关系

    +

    考虑约束下的递推关系

    Fig. 考虑约束下的递推关系

    最终，返回 \(dp[n, 1] + dp[n, 2]\) 即可，两者之和代表爬到第 \(n\) 阶的方案总数。

    diff --git a/chapter_dynamic_programming/dp_solution_pipeline/index.html b/chapter_dynamic_programming/dp_solution_pipeline/index.html index a26945410..676ce6d03 100644 --- a/chapter_dynamic_programming/dp_solution_pipeline/index.html +++ b/chapter_dynamic_programming/dp_solution_pipeline/index.html @@ -1906,6 +1906,8 @@ + + @@ -2053,6 +2055,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + @@ -2325,12 +2341,12 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]

    Note

    边界条件即初始状态，在搜索中用于剪枝，在动态规划中用于初始化 \(dp\) 表。状态转移顺序的核心是要保证在计算当前问题时，所有它依赖的更小子问题都已经被正确地计算出来。

    -

    最后，我们基于以上结果实现解法即可。熟练度较高同学可以直接写出动态规划解法，初学者可以按照“暴力搜索 \(\rightarrow\) 记忆化搜索 \(\rightarrow\) 动态规划” 的顺序实现。

    +

    接下来，我们就可以实现动态规划代码了。然而，由于子问题分解是一种从顶至底的思想，因此按照“暴力搜索 \(\rightarrow\) 记忆化搜索 \(\rightarrow\) 动态规划”的顺序实现更加符合思维习惯。

    13.3.3.   方法一：暴力搜索

    从状态 \([i, j]\) 开始搜索，不断分解为更小的状态 \([i-1, j]\) 和 \([i, j-1]\) ，包括以下递归要素：

    • 递归参数：状态 \([i, j]\) ；返回值：从 \([0, 0]\) 到 \([i, j]\) 的最小路径和 \(dp[i, j]\) ；
      • -
    • 终止条件：当 \(i = 0\) 且 \(j = 0\) 时，返回代价 \(grid[0][0]\) ；
      • +
    • 终止条件：当 \(i = 0\) 且 \(j = 0\) 时，返回代价 \(grid[0, 0]\) ；
    • 剪枝：当 \(i < 0\) 时或 \(j < 0\) 时索引越界，此时返回代价 \(+\infty\) ，代表不可行；
    diff --git a/chapter_dynamic_programming/index.html b/chapter_dynamic_programming/index.html index 43dfd9e59..bc208e670 100644 --- a/chapter_dynamic_programming/index.html +++ b/chapter_dynamic_programming/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_dynamic_programming/intro_to_dynamic_programming/index.html b/chapter_dynamic_programming/intro_to_dynamic_programming/index.html index 46b998154..8dee22181 100644 --- a/chapter_dynamic_programming/intro_to_dynamic_programming/index.html +++ b/chapter_dynamic_programming/intro_to_dynamic_programming/index.html @@ -1906,6 +1906,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_dynamic_programming/knapsack_problem/index.html b/chapter_dynamic_programming/knapsack_problem/index.html index 47e2a3424..f19a52170 100644 --- a/chapter_dynamic_programming/knapsack_problem/index.html +++ b/chapter_dynamic_programming/knapsack_problem/index.html @@ -18,7 +18,7 @@ - + @@ -1906,6 +1906,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + @@ -2245,7 +2261,7 @@

    第一步：思考每轮的决策，定义状态，从而得到 \(dp\) 表

    在 0-1 背包问题中，不放入背包，背包容量不变；放入背包，背包容量减小。由此可得状态定义：当前物品编号 \(i\) 和剩余背包容量 \(c\) ，记为 \([i, c]\) 。

    状态 \([i, c]\) 对应的子问题为：前 \(i\) 个物品在剩余容量为 \(c\) 的背包中的最大价值，记为 \(dp[i, c]\) 。

    -

    至此，我们得到一个尺寸为 \(n \times cap\) 的二维 \(dp\) 矩阵。

    +

    需要求解的是 \(dp[n, cap]\) ，因此需要一个尺寸为 \((n+1) \times (cap+1)\) 的二维 \(dp\) 表。

    第二步：找出最优子结构，进而推导出状态转移方程

    当我们做出物品 \(i\) 的决策后，剩余的是前 \(i-1\) 个物品的决策。因此，状态转移分为两种情况：

      @@ -2260,6 +2276,10 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])

      第三步：确定边界条件和状态转移顺序

      当无物品或无剩余背包容量时最大价值为 \(0\) ，即所有 \(dp[i, 0]\) 和 \(dp[0, c]\) 都等于 \(0\) 。

      当前状态 \([i, c]\) 从上方的状态 \([i-1, c]\) 和左上方的状态 \([i-1, c-wgt[i-1]]\) 转移而来，因此通过两层循环正序遍历整个 \(dp\) 表即可。

      +
      +

      Tip

      +

      完成以上三步后，我们可以直接实现从底至顶的动态规划解法。而为了展示本题包含的重叠子问题，本文也同时给出从顶至底的暴力搜索和记忆化搜索解法。

      +

      13.4.1.   方法一：暴力搜索

      搜索代码包含以下要素：

        @@ -2510,7 +2530,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])

        Fig. 0-1 背包的记忆化搜索递归树

        13.4.3.   方法三：动态规划

        -

        动态规划解法本质上就是在状态转移中填充 dp 矩阵的过程，代码如下所示。

        +

        动态规划解法本质上就是在状态转移中填充 \(dp\) 表的过程，代码如下所示。

        @@ -2627,7 +2647,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
        -

        如下图所示，时间复杂度由 dp 矩阵大小决定，为 \(O(n \times cap)\) 。

        +

        如下图所示，时间复杂度由数组 dp 大小决定，为 \(O(n \times cap)\) 。

        @@ -2674,8 +2694,8 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
        -

        最后考虑状态压缩。以上代码中的 dp 矩阵占用 \(O(n \times cap)\) 空间。由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 \(O(n^2)\) 将低至 \(O(n)\) 。代码省略，有兴趣的同学可以自行实现。

        -

        那么，我们是否可以仅用一个数组实现状态压缩呢？观察可知，每个状态都是由左上方或正上方的格子转移过来的。假设只有一个数组，当遍历到第 \(i\) 行时，该数组存储的仍然是第 \(i-1\) 行的状态，为了避免左边区域的格子在状态转移中被覆盖，我们应采取倒序遍历。

        +

        最后考虑状态压缩。以上代码中的数组 dp 占用 \(O(n \times cap)\) 空间。由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 \(O(n^2)\) 将低至 \(O(n)\) 。代码省略，有兴趣的同学可以自行实现。

        +

        那么，我们是否可以仅用一个数组实现状态压缩呢？观察可知，每个状态都是由左上方或正上方的格子转移过来的。假设只有一个数组，当遍历到第 \(i\) 行时，该数组存储的仍然是第 \(i-1\) 行的状态，为了避免左方区域的格子在状态转移中被覆盖，应该采取倒序遍历。

        以下动画展示了在单个数组下从第 \(i=1\) 行转换至第 \(i=2\) 行的过程。建议你思考一下正序遍历和倒序遍历的区别。

        @@ -2699,7 +2719,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
    -

    如以下代码所示，我们仅需将 dp 矩阵的第一维 \(i\) 直接删除，并且将内循环修改为倒序遍历即可。

    +

    如以下代码所示，我们仅需将数组 dp 的第一维 \(i\) 直接删除，并且将内循环修改为倒序遍历即可。

    @@ -2907,13 +2927,13 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) -
    XpBNEZi+=gCT zwXuj#&8lJbcn{UaUkqnUnITeY;+asDoX*kuzl4FD|ZdOf z0_)p^`kGD~bN~u47e2ehg@8@qbe?PevFv;k%WxX}4OZSf(xui!*0@idt9Umc>=dfztXSNPPB4ZWN@c1g z!7>G9cv6G?vL3Tm)<*)WiGPAtKNi7VGc=Ua5z>*9>%KhOx!P?fniwCq`ee*~Q+r0( z6}@B|!_(1|?=v~0E~FfX+iA(u6zQAB7)MVNfiP~dd(^l;AS{R5hh7`b(YL)=@&U;0 zcf)2s6)epE*3%o$btu$%a0^QJLYx5zTx%Pk)_Sox0{aV7}H-pou@nX zb!$lqRN?dM<#I)9xONyedw=ZKx;jX8>S0bM=Rm1Y`VFRE%>wq(BzCc`Z07^)+H$?O zPto!thR^NVL#G z#UamOYtXpi1@Zc%wb8dwZR<&z?`ahMzn!qfznP~0)bMMb2G8V}^>=wz6?v#z= zrYRXYG(HEaQZ3i-dGD6i&lP`>INlk1T6lt=?t8kfz}dtjX8L7D$Axnb+H#7lu^e@g z?vM=$pXGSy!7BMgna8LVgjzwIqG3eBn_SLwPy>%;{+5%l^j7yN(*$}^YuXI#-rci{5fEZr z--oLdui-Fh+X^A8&4|XG{gDw9W9t0hM*GpZSlc{M^lO+GeA;O#N+ubz+MD0Uowp7` zJy#|2kgc2NB~(9|-+sCWqxX=yv_QZwvz@#0^yP zp7Fpw_}I6w?tJj-JOW<7Mz;pnxfNiIE`42Ap6#W)F-|;WwSglqdC|FY_tZ5FU zO(Avbd@btJ9V^`m$rA2F(oY=q%nf9s*@s2kez|DAP3ab6iL=E}&M}AFkFTY}DDxh} zPL8vJY19lYF1FSflJm8pVj~q}^u107?kLw&C#~FA)6)vZed(5B1s$EF={HDGBwI8%{{&jv zR;+&nX~UxodwU1H(_^8grgn5-Qr)%0YHu*6LvW>RFS zm2HFEm(N+3eBhg6)$y39ljskA6lP2<|N5hwR$&u4&#U_~UIvh<#N?NGRdZ9-XERT3 zahJC^*5)M3?%gBcv|KwbgnJcsKT3RTwɁEAPmDB_VxXCY_($#nOS0(~MfOQRp} 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

    >a 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ș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 L71c6jtI+=gPhY@d literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step15.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step15.png new file mode 100644 index 0000000000000000000000000000000000000000..18834419a3e51708cbddfbfe78dd773150d9e95e GIT binary patch literal 58827 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 literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step2.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step2.png new file mode 100644 index 0000000000000000000000000000000000000000..e67ec40daf0439645a1138ecd1df05294b305ef1 GIT binary patch literal 64473 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

    1v&f(A$uzT9t>wC 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 literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step7.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step7.png new file mode 100644 index 0000000000000000000000000000000000000000..128aaecc4ef2d992b5d74f241544405477f02d9a GIT binary patch literal 65428 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 literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step8.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step8.png new file mode 100644 index 0000000000000000000000000000000000000000..9fd69604d6b08ed92ff3aa8274d76937323107fa GIT binary patch literal 66609 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 literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step9.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step9.png new file mode 100644 index 0000000000000000000000000000000000000000..23a09ed4a123a260183f2af4a280d685571c74bd GIT binary patch literal 66803 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�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 literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_example.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_example.png new file mode 100644 index 0000000000000000000000000000000000000000..76be71d842815a8aeca3411a6c7663e4477c384f GIT binary patch literal 55454 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

    p_#*1 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 literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_ii_example.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_ii_example.png new file mode 100644 index 0000000000000000000000000000000000000000..35a7527b564a7a7c2eaff17d112d4ebab0b46a3f GIT binary patch literal 63093 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 B=hy%M literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step2.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step2.png new file mode 100644 index 0000000000000000000000000000000000000000..85fc94a01870e41b5e32063196962dcbb8d6d1bb GIT binary patch literal 67442 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�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 literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step4.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step4.png new file mode 100644 index 0000000000000000000000000000000000000000..1a4d6d2948e6ac134570d011c7cb57e07723c1a0 GIT binary patch literal 69343 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 z zaWompig81i#$SsVm>^hW@^b70LYlVKqs+VdqzeB!zxaJV1@If&AUQ8_^24QKE^Jvk zcjY966#J3se)G*CnK4>^Gh}h+`e(hEZBs%qt(Y)!cNR#(-ip1#5S1RI(0Xn;Q*>5_ zZFgUCE_;Q9=ARosGKf-Z98!7XQnV-7nzWqkCIEkW*&Tl#uPL%Pxm6Q1bcf7R-9ye3 z9Uk3Zq-Q%d&tX(NG9dr{)HEKCDE?^C)!JJ=sEumeo?0yFmqI?W`t( zKHdbFmk+M>2ivuE{mz?&z#1=RUk6Au@1DEt5$4a?W-*2bRt@)0Z;4`%Y3QL$=)a^Y zfzyAcf`qo;${*7Us++X)cQVs!7DS5$GYmPN$Uczk1}EsA%O$crszp_^NkFd@vbV{O z#MOGYpBod4hSdN$qc_q zEA~+}Tbg8+&r?Slr}cwx7Ig$d73~`H(Ej-CZp5jQr#MKV>&9$?$*Tcz99$)R!X`KJ zxu8v(ag$}KkD;+9NEPnetPhl=;c{MMu9rC|+6{ws>BEQ&zHp zt#_3lccJO`fj5~AFS=Hr^YP20*> zj?SHlXE3+$cv^mFt9t@74Jg!?E7s3;WW~)cig~yQ%!2dzV()It?~mTe5ZIH{eg1`E z``ZSh)KUf`O|WePs>wc&2gNzy$q-a;vPj;KE0>jPWdGxC9}ZF(^)fu@gE^7)ZhZl8Go?Zc~v z@=-giC9TQYDbZyl+xq-?)$B=pl@ay&P&dKk9gG*5cCNJ=&Cc38pmJ@{=GdSPK8?!U z=8d8K3LXday6ONczrKRkZ%X^G?fYUe7qLTGTFgh=gKj(XJpxVB7kzvRv?H;@?nyD; zjMKy2|Fu4gp-?Ufx_Jc>PIY{c`RK)E2x%LF)OuxP&-^is2!9*^H0@S(dVg4yFqcuB zU|~X+rW>yVi%#`y&L|~1@+~Em-bF}gbKww&3|T>cG{F?)=dIMRnZ={6Y+0C< z9ElRn0LEO^O3H{_fp)@{*#2@bTyHO}u2f7EV(ixv4t6FQc3f8x30J)UCn{&xkE`421(3F< zLgz&dmwYaDx8zvwie|J|#N=+q7Q&2I!hc9wj&@xYXWglS8 zmJDXQ!#R3;cc^kJ>K0b`4*F2rcMMppG&i@@k&5x?FCDdud6+(9RduV4 zR?Z@u6?{2j6ARS?FOM}~Y4pm8_U` zKi$3^Waf+hPHtuC=V)$w*odGcTW>T;j`~C6%-+U@OEb*FMizi9ok34CL!2+J2n-_B zCqLiriW>_-@t?TJu3D^jvH|^#>gi)<$KYjPT@ts**2kr#=uHk`0y#(Vn#Z~W4xP8E z;J5adSp$e`ed5weA5fh!y+zQ?h6er>6xPd-z}u%*1s*fTuj7zD9mo%5I`qVzeaf;7 znV0YD+E{QrT~+@Gn6KWOlB4w=vv}kL)m%Ot`0$=WhJZ(WqmTZm$257?F_ZEsQS1aMCGG;vog%!o zMKj@phbJeMB5WDS96qUC?(79_Q$<$dm3wU-vA(4O5PFU#TSd!8`K*w5gzJYXb+jYt z9sRGO9)>W#Hl?_5dw*yd*PASo$yH~EU3 z{AABgcK*zufhT;>?zV~hE=T-{GJ!Km-SNC6*wC# zR^369B{_9TkdgLDX>d$WoC2DE_-)4eXkj@nojVMktba18tjIKTG#TbKU>;7aE+D_7j>G`O z1?}}a4Jf6He%IiKeJn>;3xJ*p7-=(xaQlB1;m)|;fKV6tqTy2;SDs|f#G?A-u4tI_ zM$oLXd~|e78Ic-|mXlsVxS2UuqFmv%XTsZ5AKTc6RaB@!l^_rT;cQ?NlKA|C)#J@m z1P4O?v2L@RNqhFpg>jp1lclIeqpB+v@+-Z#IJ-hrHCD)k>oP48CfP((Kt%E0qpv*E zIPrNI?(ujRo4BqRVf*X{@{iUfA#2zB|4F z== zVsx-dGWp)UkW8fwcnV7e#oF5sW8$Qb2ne#5>KyR`qnw3e$GOk)(rn_0H{@SAq8s>5 zU)NcdkB?z1N!w1(fo30v&`0!Nh;Uda6F*4jw$i3iD8bS%jbdqZwX0{6y27F9^Rlz6 zB|D-SIE{ryvKR}us)zeqeT$j|d=EYsv-bvco!A>d%^2dghh2A5oIZpQ7)WL^)m(nA zu%cXE!YQ|VR8^4>&1MSgdR}fRm8eJ%Pj62QOnbrhtNQ8i@T9{Zl3Ahzjm zaBumVn0uSpYXzWgDt-3t4Tz0}O!Xr#!0S)&#cb&%f~W3P)>MY=ttHoLN64|u zGgZn&vJBG)BEjk>xVJvD;%D)0uS+UN87*)mL9G9&1 zKTOmJ8NXx2G+4Jost4aIvbDc?Tr4xa9}3SH)k{x4_#Wz6u=lvFefRZWVL^IlfVOk=n4*8IMSLWS2y#+qph+h%G){*mD^M2` zJSIMyOgs6NaYuL7upz4arq7gy+)FG}K2XVr`|N74jB2IE)*nC)@$APtY ztNaro;h2m)+2%92Q`@hEf7q0Q3E(66F*2CtGd-*f*iSCz06 zSA9gZ{_^xmC^HpOG}7;?`IGM3#_1cCYL1`a!qpM@oLf0O%MH~arm@Qo5Yb8cmlutX z$6P#pSwZKa8V$@qS6`t-!|QNgfv^^2WNp#01!5jJ901oOpeM&XsP7tlr>e`fmEQfM3??qBXZ>aT@IQkap=ik@g-}gZmcr`q?pV4gV%3>FU zo*~ww>P9wjV#p?7=>k_|+g01oY`6#kk#m1{k!7l4S4`7XRNt`iri|nJ&p%-de~cyV zQ^_l;4XvBH{whT<)O)q`RI1v3KQNMj!Fpoc97fk?1(h_fwYc@U>2)BwfuiU2!)l2n^9Pq9OGmXn#&8KdkE;-t6oKzxtaSt0y0~WUWSj4fIw+~R3-eDwcUG7 zL7G+0LerO3I@|x*oFb8&i_nU;d#Z*!@pqwxQJV(HDXeeuuI9KsDRRUG(8$&SC*aZ| zQ(r6mqC<4O!V>8n)ogW8UdqZ)?ae=u_P-l&4APUKpc(f$|BgH7WW}jPO}{8O1J`<4 zk#|8L{MqQ>mY?fNCq9bAWLGIA80q!-;tI9=rbysHsLf+8c zPLM~IR$p>9;{j=A#z_R+Tbw?i%cCISWIyx~WT=eCcef4DlVJDe$D`^gf+x2il|G&f zW7jY|*QSnaSihRn(t?;-oxNk2ZMF|*kcWm1gCHutJ*gEFqGD>Z6SVWh4n;mem~<-K zv)9M+f1x&xw4)^nQP|T+d}SB?THzp$AP(8Lty|Sdh8)z2z*mCy|F0a@uxvv}jjMr+e8$UFyNu z{l{mcv;t5_xaH&NKui}ceZfV(|IOb&TM(~3B+K5c$Zx`x5|>|((JW%~wusHbl1&cC z=o0zPa2i$tFU?(6G_O7{y$Bryvvfc6w;29DL@1JQnpha`LG|L~=j9;~v<9L4G7vG9 uSIrl2qQt4jCHy=+`{%L0Zi8a3tWPS@xZ{F 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 ZPjZp!suw@ORRZ8k?xE6y{CkEk{txAa2LJ#7 literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step6.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step6.png new file mode 100644 index 0000000000000000000000000000000000000000..577f96f3dc3a99df7719455187932cb34405821a GIT binary patch literal 69037 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%0AGOa@NImvuEuHjj*ME{fglwBKi_sDEVP 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 b@atQ|3&VF)menLtfFHRh%Cbe$CU5@_LIgsJ literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_example.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/unbounded_knapsack_example.png new file mode 100644 index 0000000000000000000000000000000000000000..016228998a857bfef8e15d3a111c1b2471bc4ba9 GIT binary patch literal 70520 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 literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem/index.html b/chapter_dynamic_programming/unbounded_knapsack_problem/index.html new file mode 100644 index 000000000..1766a64b6 --- /dev/null +++ b/chapter_dynamic_programming/unbounded_knapsack_problem/index.html @@ -0,0 +1,3202 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + 13.5.   完全背包问题（New） - Hello 算法 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

    +
    + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + +

    13.5.   完全背包问题

    +

    在本节，我们先求解 0-1 背包的一个变种问题：完全背包问题；再了解完全背包的一种特例问题：零钱兑换。

    +

    13.5.1.   完全背包问题

    +
    +

    Question

    +

    给定 \(n\) 种物品，第 \(i\) 个物品的重量为 \(wgt[i-1]\) 、价值为 \(val[i-1]\) ，现在有个容量为 \(cap\) 的背包，每种物品可以重复选取，问在不超过背包容量下背包中物品的最大价值。

    +
    +

    完全背包问题的示例数据

    +

    Fig. 完全背包问题的示例数据

    + +

    完全背包和 0-1 背包问题非常相似，区别仅在于不限制物品的选择次数。

    +
      +
    • 在 0-1 背包中，每个物品只有一个，因此将物品 \(i\) 放入背包后，只能从前 \(i-1\) 个物品中选择；
      • +
    • 在完全背包中，每个物品有无数个，因此将物品 \(i\) 放入背包后，仍可以从前 \(i\) 个物品中选择；
      • +
    +

    这就导致了状态转移的变化，对于状态 \([i, c]\) 有：

    +
      +
    • 不放入物品 \(i\) ：与 0-1 背包相同，转移至 \([i-1, c]\) ；
      • +
    • 放入物品 \(i\) ：状态转移至 \([i, c-wgt[i-1]]\) 而非 0-1 背包的 \([i-1, c-wgt[i-1]]\) ；
      • +
    +

    因此状态转移方程变为：

    +
    \[ +dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) +\]
    +

    对比两道题目的动态规划代码，状态转移中有一处从 \(i-1\) 变为 \(i\) ，其余完全一致。

    +
    +
    +
    +
    unbounded_knapsack.java
    /* 完全背包：动态规划 */
+int unboundedKnapsackDP(int[] wgt, int[] val, int cap) {
+    int n = wgt.length;
+    // 初始化 dp 表
+    int[][] dp = new int[n + 1][cap + 1];
+    // 状态转移
+    for (int i = 1; i <= n; i++) {
+        for (int c = 1; c <= cap; c++) {
+            if (wgt[i - 1] > c) {
+                // 若超过背包容量，则不选物品 i
+                dp[i][c] = dp[i - 1][c];
+            } else {
+                // 不选和选物品 i 这两种方案的较大值
+                dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
+            }
+        }
+    }
+    return dp[n][cap];
+}
+
    +
    +
    +
    unbounded_knapsack.cpp
    /* 完全背包：动态规划 */
+int unboundedKnapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
+    int n = wgt.size();
+    // 初始化 dp 表
+    vector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));
+    // 状态转移
+    for (int i = 1; i <= n; i++) {
+        for (int c = 1; c <= cap; c++) {
+            if (wgt[i - 1] > c) {
+                // 若超过背包容量，则不选物品 i
+                dp[i][c] = dp[i - 1][c];
+            } else {
+                // 不选和选物品 i 这两种方案的较大值
+                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
+            }
+        }
+    }
+    return dp[n][cap];
+}
+
    +
    +
    +
    unbounded_knapsack.py
    def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:
+    """完全背包：动态规划"""
+    n = len(wgt)
+    # 初始化 dp 表
+    dp = [[0] * (cap + 1) for _ in range(n + 1)]
+    # 状态转移
+    for i in range(1, n + 1):
+        for c in range(1, cap + 1):
+            if wgt[i - 1] > c:
+                # 若超过背包容量，则不选物品 i
+                dp[i][c] = dp[i - 1][c]
+            else:
+                # 不选和选物品 i 这两种方案的较大值
+                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])
+    return dp[n][cap]
+
    +
    +
    +
    unbounded_knapsack.go
    [class]{}-[func]{unboundedKnapsackDP}
+
    +
    +
    +
    unbounded_knapsack.js
    [class]{}-[func]{unboundedKnapsackDP}
+
    +
    +
    +
    unbounded_knapsack.ts
    [class]{}-[func]{unboundedKnapsackDP}
+
    +
    +
    +
    unbounded_knapsack.c
    [class]{}-[func]{unboundedKnapsackDP}
+
    +
    +
    +
    unbounded_knapsack.cs
    [class]{unbounded_knapsack}-[func]{unboundedKnapsackDP}
+
    +
    +
    +
    unbounded_knapsack.swift
    [class]{}-[func]{unboundedKnapsackDP}
+
    +
    +
    +
    unbounded_knapsack.zig
    [class]{}-[func]{unboundedKnapsackDP}
+
    +
    +
    +
    unbounded_knapsack.dart
    [class]{}-[func]{unboundedKnapsackDP}
+
    +
    +
    +
    +

    由于当前状态是从左边和上边的状态转移而来，因此状态压缩后应该对 \(dp\) 表中的每一行采取正序遍历，这个遍历顺序与 0-1 背包正好相反。请通过以下动画来理解为什么要改为正序遍历。

    +
    +
    +
    +

    unbounded_knapsack_dp_comp_step1

    +
    +
    +

    unbounded_knapsack_dp_comp_step2

    +
    +
    +

    unbounded_knapsack_dp_comp_step3

    +
    +
    +

    unbounded_knapsack_dp_comp_step4

    +
    +
    +

    unbounded_knapsack_dp_comp_step5

    +
    +
    +

    unbounded_knapsack_dp_comp_step6

    +
    +
    +
    +

    代码实现比较简单，仅需将数组 dp 的第一维删除。

    +
    +
    +
    +
    unbounded_knapsack.java
    /* 完全背包：状态压缩后的动态规划 */
+int unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {
+    int n = wgt.length;
+    // 初始化 dp 表
+    int[] dp = new int[cap + 1];
+    // 状态转移
+    for (int i = 1; i <= n; i++) {
+        for (int c = 1; c <= cap; c++) {
+            if (wgt[i - 1] > c) {
+                // 若超过背包容量，则不选物品 i
+                dp[c] = dp[c];
+            } else {
+                // 不选和选物品 i 这两种方案的较大值
+                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+            }
+        }
+    }
+    return dp[cap];
+}
+
    +
    +
    +
    unbounded_knapsack.cpp
    /* 完全背包：状态压缩后的动态规划 */
+int unboundedKnapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
+    int n = wgt.size();
+    // 初始化 dp 表
+    vector<int> dp(cap + 1, 0);
+    // 状态转移
+    for (int i = 1; i <= n; i++) {
+        for (int c = 1; c <= cap; c++) {
+            if (wgt[i - 1] > c) {
+                // 若超过背包容量，则不选物品 i
+                dp[c] = dp[c];
+            } else {
+                // 不选和选物品 i 这两种方案的较大值
+                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+            }
+        }
+    }
+    return dp[cap];
+}
+
    +
    +
    +
    unbounded_knapsack.py
    def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:
+    """完全背包：状态压缩后的动态规划"""
+    n = len(wgt)
+    # 初始化 dp 表
+    dp = [0] * (cap + 1)
+    # 状态转移
+    for i in range(1, n + 1):
+        # 正序遍历
+        for c in range(1, cap + 1):
+            if wgt[i - 1] > c:
+                # 若超过背包容量，则不选物品 i
+                dp[c] = dp[c]
+            else:
+                # 不选和选物品 i 这两种方案的较大值
+                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])
+    return dp[cap]
+
    +
    +
    +
    unbounded_knapsack.go
    [class]{}-[func]{unboundedKnapsackDPComp}
+
    +
    +
    +
    unbounded_knapsack.js
    [class]{}-[func]{unboundedKnapsackDPComp}
+
    +
    +
    +
    unbounded_knapsack.ts
    [class]{}-[func]{unboundedKnapsackDPComp}
+
    +
    +
    +
    unbounded_knapsack.c
    [class]{}-[func]{unboundedKnapsackDPComp}
+
    +
    +
    +
    unbounded_knapsack.cs
    [class]{unbounded_knapsack}-[func]{unboundedKnapsackDPComp}
+
    +
    +
    +
    unbounded_knapsack.swift
    [class]{}-[func]{unboundedKnapsackDPComp}
+
    +
    +
    +
    unbounded_knapsack.zig
    [class]{}-[func]{unboundedKnapsackDPComp}
+
    +
    +
    +
    unbounded_knapsack.dart
    [class]{}-[func]{unboundedKnapsackDPComp}
+
    +
    +
    +
    +

    13.5.2.   零钱兑换问题

    +

    背包问题是一大类动态规划问题的代表，其拥有很多的变种，例如零钱兑换问题。

    +
    +

    Question

    +

    给定 \(n\) 种硬币，第 \(i\) 个硬币的面值为 \(coins[i - 1]\) ，为目标金额 \(amt\) ，每种硬币可以重复选取，问能够凑出目标金额的最少硬币个数。如果无法凑出目标金额则返回 \(-1\) 。

    +
    +

    如下图所示，凑出 \(11\) 元最少需要 \(3\) 枚硬币，方案为 \(1 + 2 + 5 = 11\) 。

    +

    零钱兑换问题的示例数据

    +

    Fig. 零钱兑换问题的示例数据

    + +

    零钱兑换问题可以看作是完全背包问题的一种特殊情况，两者具有以下联系与不同点：

    +
      +
    • 两道题可以相互转换，“物品”对应于“硬币”、“物品重量”对应于“硬币面值”、“背包容量”对应于“目标金额”；
      • +
    • 目标不同，背包问题是要最大化物品价值，零钱兑换问题是要最小化硬币数量；
      • +
    • 背包问题是求“不超过”背包容量下的解，零钱兑换是求“恰好”凑到目标金额的解；
      • +
    +

    第一步：思考每轮的决策，定义状态，从而得到 \(dp\) 表

    +

    状态 \([i, a]\) 对应的子问题为：前 \(i\) 个硬币能够凑出金额 \(a\) 的最少硬币个数，记为 \(dp[i, a]\) 。

    +

    二维 \(dp\) 表的尺寸为 \((n+1) \times (amt+1)\) 。

    +

    第二步：找出最优子结构，进而推导出状态转移方程

    +

    与完全背包的状态转移方程基本相同，不同点在于：

    +
      +
    • 本题要求最小值，因此需将运算符 \(\max()\) 更改为 \(\min()\) ；
      • +
    • 优化主体是“硬币数量”而非”商品价值“，因此在选中硬币时执行 \(+1\) 即可；
      • +
    +
    \[ +dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) +\]
    +

    第三步：确定边界条件和状态转移顺序

    +

    当目标金额为 \(0\) 时，凑出它的最少硬币个数为 \(0\) ，即所有 \(dp[i, 0]\) 都等于 \(0\) 。当无硬币时，无法凑出任意 \(> 0\) 的目标金额，即是无效解。为使状态转移方程中的 \(\min()\) 函数能够识别并过滤无效解，我们考虑使用 \(+ \infty\) 来表示它们，即令所有 \(dp[0, a]\) 都等于 \(+ \infty\) 。

    +

    以上做法仅适用于 Python 语言，因为大多数编程语言并未提供 \(+ \infty\) 变量，所以只能使用整型 int 的最大值，而这又会导致大数越界：当 \(dp[i, a - coins[i-1]]\) 是无效解时，再执行 \(+ 1\) 操作会发生溢出。

    +

    为解决该问题，我们采用一个不可能达到的大数字 \(amt + 1\) 来表示无效解，因为凑出 \(amt\) 的硬币个数最多为 \(amt\) 个。

    +

    在最后返回前，判断 \(dp[n, amt]\) 是否等于 \(amt + 1\) ，若是则返回 \(-1\) ，代表无法凑出目标金额。

    +
    +
    +
    +
    coin_change.java
    /* 零钱兑换：动态规划 */
+int coinChangeDP(int[] coins, int amt) {
+    int n = coins.length;
+    int MAX = amt + 1;
+    // 初始化 dp 表
+    int[][] dp = new int[n + 1][amt + 1];
+    // 状态转移：首行首列
+    for (int a = 1; a <= amt; a++) {
+        dp[0][a] = MAX;
+    }
+    // 状态转移：其余行列
+    for (int i = 1; i <= n; i++) {
+        for (int a = 1; a <= amt; a++) {
+            if (coins[i - 1] > a) {
+                // 若超过背包容量，则不选硬币 i
+                dp[i][a] = dp[i - 1][a];
+            } else {
+                // 不选和选硬币 i 这两种方案的较小值
+                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
+            }
+        }
+    }
+    return dp[n][amt] != MAX ? dp[n][amt] : -1;
+}
+
    +
    +
    +
    coin_change.cpp
    /* 零钱兑换：动态规划 */
+int coinChangeDP(vector<int> &coins, int amt) {
+    int n = coins.size();
+    int MAX = amt + 1;
+    // 初始化 dp 表
+    vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));
+    // 状态转移：首行首列
+    for (int a = 1; a <= amt; a++) {
+        dp[0][a] = MAX;
+    }
+    // 状态转移：其余行列
+    for (int i = 1; i <= n; i++) {
+        for (int a = 1; a <= amt; a++) {
+            if (coins[i - 1] > a) {
+                // 若超过背包容量，则不选硬币 i
+                dp[i][a] = dp[i - 1][a];
+            } else {
+                // 不选和选硬币 i 这两种方案的较小值
+                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
+            }
+        }
+    }
+    return dp[n][amt] != MAX ? dp[n][amt] : -1;
+}
+
    +
    +
    +
    coin_change.py
    def coin_change_dp(coins: list[int], amt: int) -> int:
+    """零钱兑换：动态规划"""
+    n = len(coins)
+    MAX = amt + 1
+    # 初始化 dp 表
+    dp = [[0] * (amt + 1) for _ in range(n + 1)]
+    # 状态转移：首行首列
+    for a in range(1, amt + 1):
+        dp[0][a] = MAX
+    # 状态转移：其余行列
+    for i in range(1, n + 1):
+        for a in range(1, amt + 1):
+            if coins[i - 1] > a:
+                # 若超过背包容量，则不选硬币 i
+                dp[i][a] = dp[i - 1][a]
+            else:
+                # 不选和选硬币 i 这两种方案的较小值
+                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)
+    return dp[n][amt] if dp[n][amt] != MAX else -1
+
    +
    +
    +
    coin_change.go
    [class]{}-[func]{coinChangeDP}
+
    +
    +
    +
    coin_change.js
    [class]{}-[func]{coinChangeDP}
+
    +
    +
    +
    coin_change.ts
    [class]{}-[func]{coinChangeDP}
+
    +
    +
    +
    coin_change.c
    [class]{}-[func]{coinChangeDP}
+
    +
    +
    +
    coin_change.cs
    [class]{coin_change}-[func]{coinChangeDP}
+
    +
    +
    +
    coin_change.swift
    [class]{}-[func]{coinChangeDP}
+
    +
    +
    +
    coin_change.zig
    [class]{}-[func]{coinChangeDP}
+
    +
    +
    +
    coin_change.dart
    [class]{}-[func]{coinChangeDP}
+
    +
    +
    +
    +

    下图展示了零钱兑换的动态规划过程。

    +
    +
    +
    +

    coin_change_dp_step1

    +
    +
    +

    coin_change_dp_step2

    +
    +
    +

    coin_change_dp_step3

    +
    +
    +

    coin_change_dp_step4

    +
    +
    +

    coin_change_dp_step5

    +
    +
    +

    coin_change_dp_step6

    +
    +
    +

    coin_change_dp_step7

    +
    +
    +

    coin_change_dp_step8

    +
    +
    +

    coin_change_dp_step9

    +
    +
    +

    coin_change_dp_step10

    +
    +
    +

    coin_change_dp_step11

    +
    +
    +

    coin_change_dp_step12

    +
    +
    +

    coin_change_dp_step13

    +
    +
    +

    coin_change_dp_step14

    +
    +
    +

    coin_change_dp_step15

    +
    +
    +
    +

    由于零钱兑换和完全背包的状态转移方程如出一辙，因此状态压缩方式也相同。

    +
    +
    +
    +
    coin_change.java
    /* 零钱兑换：状态压缩后的动态规划 */
+int coinChangeDPComp(int[] coins, int amt) {
+    int n = coins.length;
+    int MAX = amt + 1;
+    // 初始化 dp 表
+    int[] dp = new int[amt + 1];
+    Arrays.fill(dp, MAX);
+    dp[0] = 0;
+    // 状态转移
+    for (int i = 1; i <= n; i++) {
+        for (int a = 1; a <= amt; a++) {
+            if (coins[i - 1] > a) {
+                // 若超过背包容量，则不选硬币 i
+                dp[a] = dp[a];
+            } else {
+                // 不选和选硬币 i 这两种方案的较小值
+                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);
+            }
+        }
+    }
+    return dp[amt] != MAX ? dp[amt] : -1;
+}
+
    +
    +
    +
    coin_change.cpp
    /* 零钱兑换：状态压缩后的动态规划 */
+int coinChangeDPComp(vector<int> &coins, int amt) {
+    int n = coins.size();
+    int MAX = amt + 1;
+    // 初始化 dp 表
+    vector<int> dp(amt + 1, MAX);
+    dp[0] = 0;
+    // 状态转移
+    for (int i = 1; i <= n; i++) {
+        for (int a = 1; a <= amt; a++) {
+            if (coins[i - 1] > a) {
+                // 若超过背包容量，则不选硬币 i
+                dp[a] = dp[a];
+            } else {
+                // 不选和选硬币 i 这两种方案的较小值
+                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);
+            }
+        }
+    }
+    return dp[amt] != MAX ? dp[amt] : -1;
+}
+
    +
    +
    +
    coin_change.py
    def coin_change_dp_comp(coins: list[int], amt: int) -> int:
+    """零钱兑换：状态压缩后的动态规划"""
+    n = len(coins)
+    MAX = amt + 1
+    # 初始化 dp 表
+    dp = [MAX] * (amt + 1)
+    dp[0] = 0
+    # 状态转移
+    for i in range(1, n + 1):
+        # 正序遍历
+        for a in range(1, amt + 1):
+            if coins[i - 1] > a:
+                # 若超过背包容量，则不选硬币 i
+                dp[a] = dp[a]
+            else:
+                # 不选和选硬币 i 这两种方案的较小值
+                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)
+    return dp[amt] if dp[amt] != MAX else -1
+
    +
    +
    +
    coin_change.go
    [class]{}-[func]{coinChangeDPComp}
+
    +
    +
    +
    coin_change.js
    [class]{}-[func]{coinChangeDPComp}
+
    +
    +
    +
    coin_change.ts
    [class]{}-[func]{coinChangeDPComp}
+
    +
    +
    +
    coin_change.c
    [class]{}-[func]{coinChangeDPComp}
+
    +
    +
    +
    coin_change.cs
    [class]{coin_change}-[func]{coinChangeDPComp}
+
    +
    +
    +
    coin_change.swift
    [class]{}-[func]{coinChangeDPComp}
+
    +
    +
    +
    coin_change.zig
    [class]{}-[func]{coinChangeDPComp}
+
    +
    +
    +
    coin_change.dart
    [class]{}-[func]{coinChangeDPComp}
+
    +
    +
    +
    +

    13.5.3.   零钱兑换问题 II

    +
    +

    Question

    +

    给定 \(n\) 种硬币，第 \(i\) 个硬币的面值为 \(coins[i - 1]\) ，目标金额为 \(amt\) ，每种硬币可以重复选取，问在凑出目标金额的硬币组合数量。

    +
    +

    零钱兑换问题 II 的示例数据

    +

    Fig. 零钱兑换问题 II 的示例数据

    + +

    相比于上一题，本题目标是组合数量，因此子问题变为：前 \(i\) 个硬币能够凑出金额 \(a\) 的组合数量。而 \(dp\) 表仍然是尺寸为 \((n+1) \times (amt + 1)\) 的二维矩阵。

    +

    当前状态的组合数量等于不选当前硬币与选当前硬币这两种决策的组合数量之和。状态转移方程为：

    +
    \[ +dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] +\]
    +

    当目标金额为 \(0\) 时，无需选择任何硬币即可凑出目标金额，因此应将所有 \(dp[i, 0]\) 都初始化为 \(1\) 。当无硬币时，无法凑出任何 \(>0\) 的目标金额，因此所有 \(dp[0, a]\) 都等于 \(0\) 。

    +
    +
    +
    +
    coin_change_ii.java
    /* 零钱兑换 II：动态规划 */
+int coinChangeIIDP(int[] coins, int amt) {
+    int n = coins.length;
+    // 初始化 dp 表
+    int[][] dp = new int[n + 1][amt + 1];
+    // 初始化首列
+    for (int i = 0; i <= n; i++) {
+        dp[i][0] = 1;
+    }
+    // 状态转移
+    for (int i = 1; i <= n; i++) {
+        for (int a = 1; a <= amt; a++) {
+            if (coins[i - 1] > a) {
+                // 若超过背包容量，则不选硬币 i
+                dp[i][a] = dp[i - 1][a];
+            } else {
+                // 不选和选硬币 i 这两种方案之和
+                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];
+            }
+        }
+    }
+    return dp[n][amt];
+}
+
    +
    +
    +
    coin_change_ii.cpp
    /* 零钱兑换 II：动态规划 */
+int coinChangeIIDP(vector<int> &coins, int amt) {
+    int n = coins.size();
+    // 初始化 dp 表
+    vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));
+    // 初始化首列
+    for (int i = 0; i <= n; i++) {
+        dp[i][0] = 1;
+    }
+    // 状态转移
+    for (int i = 1; i <= n; i++) {
+        for (int a = 1; a <= amt; a++) {
+            if (coins[i - 1] > a) {
+                // 若超过背包容量，则不选硬币 i
+                dp[i][a] = dp[i - 1][a];
+            } else {
+                // 不选和选硬币 i 这两种方案之和
+                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];
+            }
+        }
+    }
+    return dp[n][amt];
+}
+
    +
    +
    +
    coin_change_ii.py
    def coin_change_ii_dp(coins: list[int], amt: int) -> int:
+    """零钱兑换 II：动态规划"""
+    n = len(coins)
+    # 初始化 dp 表
+    dp = [[0] * (amt + 1) for _ in range(n + 1)]
+    # 初始化首列
+    for i in range(n + 1):
+        dp[i][0] = 1
+    # 状态转移
+    for i in range(1, n + 1):
+        for a in range(1, amt + 1):
+            if coins[i - 1] > a:
+                # 若超过背包容量，则不选硬币 i
+                dp[i][a] = dp[i - 1][a]
+            else:
+                # 不选和选硬币 i 这两种方案之和
+                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]
+    return dp[n][amt]
+
    +
    +
    +
    coin_change_ii.go
    [class]{}-[func]{coinChangeIIDP}
+
    +
    +
    +
    coin_change_ii.js
    [class]{}-[func]{coinChangeIIDP}
+
    +
    +
    +
    coin_change_ii.ts
    [class]{}-[func]{coinChangeIIDP}
+
    +
    +
    +
    coin_change_ii.c
    [class]{}-[func]{coinChangeIIDP}
+
    +
    +
    +
    coin_change_ii.cs
    [class]{coin_change_ii}-[func]{coinChangeIIDP}
+
    +
    +
    +
    coin_change_ii.swift
    [class]{}-[func]{coinChangeIIDP}
+
    +
    +
    +
    coin_change_ii.zig
    [class]{}-[func]{coinChangeIIDP}
+
    +
    +
    +
    coin_change_ii.dart
    [class]{}-[func]{coinChangeIIDP}
+
    +
    +
    +
    +

    状态压缩处理方式相同，删除硬币维度即可。

    +
    +
    +
    +
    coin_change_ii.java
    /* 零钱兑换 II：状态压缩后的动态规划 */
+int coinChangeIIDPComp(int[] coins, int amt) {
+    int n = coins.length;
+    // 初始化 dp 表
+    int[] dp = new int[amt + 1];
+    dp[0] = 1;
+    // 状态转移
+    for (int i = 1; i <= n; i++) {
+        for (int a = 1; a <= amt; a++) {
+            if (coins[i - 1] > a) {
+                // 若超过背包容量，则不选硬币 i
+                dp[a] = dp[a];
+            } else {
+                // 不选和选硬币 i 这两种方案之和
+                dp[a] = dp[a] + dp[a - coins[i - 1]];
+            }
+        }
+    }
+    return dp[amt];
+}
+
    +
    +
    +
    coin_change_ii.cpp
    /* 零钱兑换 II：状态压缩后的动态规划 */
+int coinChangeIIDPComp(vector<int> &coins, int amt) {
+    int n = coins.size();
+    // 初始化 dp 表
+    vector<int> dp(amt + 1, 0);
+    dp[0] = 1;
+    // 状态转移
+    for (int i = 1; i <= n; i++) {
+        for (int a = 1; a <= amt; a++) {
+            if (coins[i - 1] > a) {
+                // 若超过背包容量，则不选硬币 i
+                dp[a] = dp[a];
+            } else {
+                // 不选和选硬币 i 这两种方案之和
+                dp[a] = dp[a] + dp[a - coins[i - 1]];
+            }
+        }
+    }
+    return dp[amt];
+}
+
    +
    +
    +
    coin_change_ii.py
    def coin_change_ii_dp_comp(coins: list[int], amt: int) -> int:
+    """零钱兑换 II：状态压缩后的动态规划"""
+    n = len(coins)
+    # 初始化 dp 表
+    dp = [0] * (amt + 1)
+    dp[0] = 1
+    # 状态转移
+    for i in range(1, n + 1):
+        # 正序遍历
+        for a in range(1, amt + 1):
+            if coins[i - 1] > a:
+                # 若超过背包容量，则不选硬币 i
+                dp[a] = dp[a]
+            else:
+                # 不选和选硬币 i 这两种方案之和
+                dp[a] = dp[a] + dp[a - coins[i - 1]]
+    return dp[amt]
+
    +
    +
    +
    coin_change_ii.go
    [class]{}-[func]{coinChangeIIDPComp}
+
    +
    +
    +
    coin_change_ii.js
    [class]{}-[func]{coinChangeIIDPComp}
+
    +
    +
    +
    coin_change_ii.ts
    [class]{}-[func]{coinChangeIIDPComp}
+
    +
    +
    +
    coin_change_ii.c
    [class]{}-[func]{coinChangeIIDPComp}
+
    +
    +
    +
    coin_change_ii.cs
    [class]{coin_change_ii}-[func]{coinChangeIIDPComp}
+
    +
    +
    +
    coin_change_ii.swift
    [class]{}-[func]{coinChangeIIDPComp}
+
    +
    +
    +
    coin_change_ii.zig
    [class]{}-[func]{coinChangeIIDPComp}
+
    +
    +
    +
    coin_change_ii.dart
    [class]{}-[func]{coinChangeIIDPComp}
+
    +
    +
    +
    + + + + + +

    评论

    + + + + + + +
    +
    + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/chapter_graph/graph/index.html b/chapter_graph/graph/index.html index 59cbed2f3..4b33b8251 100644 --- a/chapter_graph/graph/index.html +++ b/chapter_graph/graph/index.html @@ -1988,6 +1988,8 @@ + + @@ -2066,6 +2068,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_graph/graph_operations/index.html b/chapter_graph/graph_operations/index.html index bf1e13b96..a12b4a30b 100644 --- a/chapter_graph/graph_operations/index.html +++ b/chapter_graph/graph_operations/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_graph/graph_traversal/index.html b/chapter_graph/graph_traversal/index.html index a7c3ae551..62c207726 100644 --- a/chapter_graph/graph_traversal/index.html +++ b/chapter_graph/graph_traversal/index.html @@ -1994,6 +1994,8 @@ + + @@ -2072,6 +2074,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_graph/index.html b/chapter_graph/index.html index 676bd7d52..062ca0702 100644 --- a/chapter_graph/index.html +++ b/chapter_graph/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_graph/summary/index.html b/chapter_graph/summary/index.html index 1c46515a8..c29157720 100644 --- a/chapter_graph/summary/index.html +++ b/chapter_graph/summary/index.html @@ -1947,6 +1947,8 @@ + + @@ -2025,6 +2027,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_hashing/hash_algorithm/index.html b/chapter_hashing/hash_algorithm/index.html index 08df7db13..0022b0a00 100644 --- a/chapter_hashing/hash_algorithm/index.html +++ b/chapter_hashing/hash_algorithm/index.html @@ -1968,6 +1968,8 @@ + + @@ -2046,6 +2048,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_hashing/hash_collision/index.html b/chapter_hashing/hash_collision/index.html index a3015ab9a..d8a59b605 100644 --- a/chapter_hashing/hash_collision/index.html +++ b/chapter_hashing/hash_collision/index.html @@ -1974,6 +1974,8 @@ + + @@ -2052,6 +2054,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_hashing/hash_map/index.html b/chapter_hashing/hash_map/index.html index 405b58e1d..69a207065 100644 --- a/chapter_hashing/hash_map/index.html +++ b/chapter_hashing/hash_map/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_hashing/index.html b/chapter_hashing/index.html index 09ebb8d06..58b3790c9 100644 --- a/chapter_hashing/index.html +++ b/chapter_hashing/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_hashing/summary/index.html b/chapter_hashing/summary/index.html index 9cda9f4d5..427406610 100644 --- a/chapter_hashing/summary/index.html +++ b/chapter_hashing/summary/index.html @@ -1947,6 +1947,8 @@ + + @@ -2025,6 +2027,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_heap/build_heap/index.html b/chapter_heap/build_heap/index.html index ba048b81c..d8716469d 100644 --- a/chapter_heap/build_heap/index.html +++ b/chapter_heap/build_heap/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_heap/heap/index.html b/chapter_heap/heap/index.html index 4b49a4e0c..6c26fcdd8 100644 --- a/chapter_heap/heap/index.html +++ b/chapter_heap/heap/index.html @@ -1995,6 +1995,8 @@ + + @@ -2073,6 +2075,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_heap/index.html b/chapter_heap/index.html index d92d1832d..c809cac33 100644 --- a/chapter_heap/index.html +++ b/chapter_heap/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_heap/summary/index.html b/chapter_heap/summary/index.html index 49ff974ca..7ca736f4b 100644 --- a/chapter_heap/summary/index.html +++ b/chapter_heap/summary/index.html @@ -1947,6 +1947,8 @@ + + @@ -2025,6 +2027,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_heap/top_k/index.html b/chapter_heap/top_k/index.html index c2196257f..b140d1011 100644 --- a/chapter_heap/top_k/index.html +++ b/chapter_heap/top_k/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_introduction/algorithms_are_everywhere/index.html b/chapter_introduction/algorithms_are_everywhere/index.html index 6125e4eaf..c192b288c 100644 --- a/chapter_introduction/algorithms_are_everywhere/index.html +++ b/chapter_introduction/algorithms_are_everywhere/index.html @@ -1916,6 +1916,8 @@ + + @@ -1994,6 +1996,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_introduction/index.html b/chapter_introduction/index.html index a2a79e986..522818e60 100644 --- a/chapter_introduction/index.html +++ b/chapter_introduction/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_introduction/summary/index.html b/chapter_introduction/summary/index.html index 8f375079b..c738cf80c 100644 --- a/chapter_introduction/summary/index.html +++ b/chapter_introduction/summary/index.html @@ -1916,6 +1916,8 @@ + + @@ -1994,6 +1996,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_introduction/what_is_dsa/index.html b/chapter_introduction/what_is_dsa/index.html index dbbca42b3..a630e8a41 100644 --- a/chapter_introduction/what_is_dsa/index.html +++ b/chapter_introduction/what_is_dsa/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_preface/about_the_book/index.html b/chapter_preface/about_the_book/index.html index 9f66c255b..27d778e54 100644 --- a/chapter_preface/about_the_book/index.html +++ b/chapter_preface/about_the_book/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_preface/index.html b/chapter_preface/index.html index 6399fb203..77798df8c 100644 --- a/chapter_preface/index.html +++ b/chapter_preface/index.html @@ -1904,6 +1904,8 @@ + + @@ -1982,6 +1984,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_preface/suggestions/index.html b/chapter_preface/suggestions/index.html index 14fa9c649..1f040e7a0 100644 --- a/chapter_preface/suggestions/index.html +++ b/chapter_preface/suggestions/index.html @@ -1975,6 +1975,8 @@ + + @@ -2053,6 +2055,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_preface/summary/index.html b/chapter_preface/summary/index.html index 6cca77052..abfab8696 100644 --- a/chapter_preface/summary/index.html +++ b/chapter_preface/summary/index.html @@ -1916,6 +1916,8 @@ + + @@ -1994,6 +1996,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_reference/index.html b/chapter_reference/index.html index c3af04d01..a1d76594d 100644 --- a/chapter_reference/index.html +++ b/chapter_reference/index.html @@ -1902,6 +1902,8 @@ + + @@ -1980,6 +1982,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_searching/binary_search/index.html b/chapter_searching/binary_search/index.html index 03ccf13be..60cc9989f 100644 --- a/chapter_searching/binary_search/index.html +++ b/chapter_searching/binary_search/index.html @@ -1954,6 +1954,8 @@ + + @@ -2032,6 +2034,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_searching/binary_search_edge/index.html b/chapter_searching/binary_search_edge/index.html index 6ba366224..598666c94 100644 --- a/chapter_searching/binary_search_edge/index.html +++ b/chapter_searching/binary_search_edge/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_searching/index.html b/chapter_searching/index.html index 2cd654521..cbafb449a 100644 --- a/chapter_searching/index.html +++ b/chapter_searching/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_searching/replace_linear_by_hashing/index.html b/chapter_searching/replace_linear_by_hashing/index.html index bf9262d7d..94353cdf4 100644 --- a/chapter_searching/replace_linear_by_hashing/index.html +++ b/chapter_searching/replace_linear_by_hashing/index.html @@ -1954,6 +1954,8 @@ + + @@ -2032,6 +2034,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_searching/searching_algorithm_revisited/index.html b/chapter_searching/searching_algorithm_revisited/index.html index e55797f25..578899771 100644 --- a/chapter_searching/searching_algorithm_revisited/index.html +++ b/chapter_searching/searching_algorithm_revisited/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_searching/summary/index.html b/chapter_searching/summary/index.html index 488357213..870360857 100644 --- a/chapter_searching/summary/index.html +++ b/chapter_searching/summary/index.html @@ -1916,6 +1916,8 @@ + + @@ -1994,6 +1996,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/bubble_sort/index.html b/chapter_sorting/bubble_sort/index.html index 7f87654d9..f871f0127 100644 --- a/chapter_sorting/bubble_sort/index.html +++ b/chapter_sorting/bubble_sort/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/bucket_sort/index.html b/chapter_sorting/bucket_sort/index.html index c754e32f2..b7e3e951f 100644 --- a/chapter_sorting/bucket_sort/index.html +++ b/chapter_sorting/bucket_sort/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/counting_sort/index.html b/chapter_sorting/counting_sort/index.html index 32dde18b6..72faf6589 100644 --- a/chapter_sorting/counting_sort/index.html +++ b/chapter_sorting/counting_sort/index.html @@ -1968,6 +1968,8 @@ + + @@ -2046,6 +2048,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/heap_sort/index.html b/chapter_sorting/heap_sort/index.html index 73f7f3f0e..eceb308b0 100644 --- a/chapter_sorting/heap_sort/index.html +++ b/chapter_sorting/heap_sort/index.html @@ -1954,6 +1954,8 @@ + + @@ -2032,6 +2034,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/index.html b/chapter_sorting/index.html index bf994a33b..277f43a25 100644 --- a/chapter_sorting/index.html +++ b/chapter_sorting/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/insertion_sort/index.html b/chapter_sorting/insertion_sort/index.html index 17378e1ec..8990a8697 100644 --- a/chapter_sorting/insertion_sort/index.html +++ b/chapter_sorting/insertion_sort/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/merge_sort/index.html b/chapter_sorting/merge_sort/index.html index 8dfc51151..22e539794 100644 --- a/chapter_sorting/merge_sort/index.html +++ b/chapter_sorting/merge_sort/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/quick_sort/index.html b/chapter_sorting/quick_sort/index.html index 168f4d719..d3459549f 100644 --- a/chapter_sorting/quick_sort/index.html +++ b/chapter_sorting/quick_sort/index.html @@ -1975,6 +1975,8 @@ + + @@ -2053,6 +2055,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/radix_sort/index.html b/chapter_sorting/radix_sort/index.html index 2d4f42774..06dca49d2 100644 --- a/chapter_sorting/radix_sort/index.html +++ b/chapter_sorting/radix_sort/index.html @@ -1954,6 +1954,8 @@ + + @@ -2032,6 +2034,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/selection_sort/index.html b/chapter_sorting/selection_sort/index.html index 26155aa07..8b32ef7af 100644 --- a/chapter_sorting/selection_sort/index.html +++ b/chapter_sorting/selection_sort/index.html @@ -1947,6 +1947,8 @@ + + @@ -2025,6 +2027,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/sorting_algorithm/index.html b/chapter_sorting/sorting_algorithm/index.html index af534d365..00e41ec3e 100644 --- a/chapter_sorting/sorting_algorithm/index.html +++ b/chapter_sorting/sorting_algorithm/index.html @@ -1954,6 +1954,8 @@ + + @@ -2032,6 +2034,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_sorting/summary/index.html b/chapter_sorting/summary/index.html index 97637b5d5..b985ece7a 100644 --- a/chapter_sorting/summary/index.html +++ b/chapter_sorting/summary/index.html @@ -1947,6 +1947,8 @@ + + @@ -2025,6 +2027,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_stack_and_queue/deque/index.html b/chapter_stack_and_queue/deque/index.html index 8e0fa562b..e0f389405 100644 --- a/chapter_stack_and_queue/deque/index.html +++ b/chapter_stack_and_queue/deque/index.html @@ -1981,6 +1981,8 @@ + + @@ -2059,6 +2061,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_stack_and_queue/index.html b/chapter_stack_and_queue/index.html index 940348846..bcd52708c 100644 --- a/chapter_stack_and_queue/index.html +++ b/chapter_stack_and_queue/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_stack_and_queue/queue/index.html b/chapter_stack_and_queue/queue/index.html index c7e35376d..cd50a9e7a 100644 --- a/chapter_stack_and_queue/queue/index.html +++ b/chapter_stack_and_queue/queue/index.html @@ -1981,6 +1981,8 @@ + + @@ -2059,6 +2061,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_stack_and_queue/stack/index.html b/chapter_stack_and_queue/stack/index.html index 08919aed3..c55fd684f 100644 --- a/chapter_stack_and_queue/stack/index.html +++ b/chapter_stack_and_queue/stack/index.html @@ -2015,6 +2015,8 @@ + + @@ -2093,6 +2095,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_stack_and_queue/summary/index.html b/chapter_stack_and_queue/summary/index.html index a68f484fe..24b0834a3 100644 --- a/chapter_stack_and_queue/summary/index.html +++ b/chapter_stack_and_queue/summary/index.html @@ -1947,6 +1947,8 @@ + + @@ -2025,6 +2027,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_tree/array_representation_of_tree/index.html b/chapter_tree/array_representation_of_tree/index.html index 08f7dd89d..65412bc15 100644 --- a/chapter_tree/array_representation_of_tree/index.html +++ b/chapter_tree/array_representation_of_tree/index.html @@ -1961,6 +1961,8 @@ + + @@ -2039,6 +2041,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_tree/avl_tree/index.html b/chapter_tree/avl_tree/index.html index 98de11a55..dac19084f 100644 --- a/chapter_tree/avl_tree/index.html +++ b/chapter_tree/avl_tree/index.html @@ -2056,6 +2056,8 @@ + + @@ -2134,6 +2136,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_tree/binary_search_tree/index.html b/chapter_tree/binary_search_tree/index.html index 71657eb4b..c63167846 100644 --- a/chapter_tree/binary_search_tree/index.html +++ b/chapter_tree/binary_search_tree/index.html @@ -1995,6 +1995,8 @@ + + @@ -2073,6 +2075,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_tree/binary_tree/index.html b/chapter_tree/binary_tree/index.html index b6f783e60..1f5926af6 100644 --- a/chapter_tree/binary_tree/index.html +++ b/chapter_tree/binary_tree/index.html @@ -2002,6 +2002,8 @@ + + @@ -2080,6 +2082,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_tree/binary_tree_traversal/index.html b/chapter_tree/binary_tree_traversal/index.html index c181106c0..1f0fbf78d 100644 --- a/chapter_tree/binary_tree_traversal/index.html +++ b/chapter_tree/binary_tree_traversal/index.html @@ -1994,6 +1994,8 @@ + + @@ -2072,6 +2074,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_tree/index.html b/chapter_tree/index.html index cf6f7a62e..40a2b0e33 100644 --- a/chapter_tree/index.html +++ b/chapter_tree/index.html @@ -1906,6 +1906,8 @@ + + @@ -1984,6 +1986,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/chapter_tree/summary/index.html b/chapter_tree/summary/index.html index 4ae9f6064..36a400348 100644 --- a/chapter_tree/summary/index.html +++ b/chapter_tree/summary/index.html @@ -1947,6 +1947,8 @@ + + @@ -2025,6 +2027,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/index.html b/index.html index 4d2852c1b..6e893ea67 100644 --- a/index.html +++ b/index.html @@ -1897,6 +1897,8 @@ + + @@ -1975,6 +1977,20 @@ + + + + + +
  • + + 13.5.   完全背包问题（New） + +
    • + + + + diff --git a/search/search_index.json b/search/search_index.json index 8b4cf8e45..2e70f33df 100644 --- a/search/search_index.json +++ b/search/search_index.json @@ -1 +1 @@ -{"config":{"lang":["ja"],"separator":"[\\s\\-\uff0c\u3002]+","pipeline":["stemmer"]},"docs":[{"location":"","title":"Home","text":"\u300a Hello \u7b97\u6cd5 \u300b

    \u52a8\u753b\u56fe\u89e3\u3001\u4e00\u952e\u8fd0\u884c\u7684\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u6559\u7a0b

    \u63a8\u8350\u8bed

    Quote

    \u201c\u4e00\u672c\u901a\u4fd7\u6613\u61c2\u7684\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u5165\u95e8\u4e66\uff0c\u5f15\u5bfc\u8bfb\u8005\u624b\u8111\u5e76\u7528\u5730\u5b66\u4e60\uff0c\u5f3a\u70c8\u63a8\u8350\u7b97\u6cd5\u521d\u5b66\u8005\u9605\u8bfb\u3002\u201d

    \u2014\u2014 \u9093\u4fca\u8f89\uff0c\u6e05\u534e\u5927\u5b66\u8ba1\u7b97\u673a\u7cfb\u6559\u6388

    Quote

    \u201c\u5982\u679c\u6211\u5f53\u5e74\u5b66\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u65f6\u5019\u6709\u300aHello \u7b97\u6cd5\u300b\uff0c\u5b66\u8d77\u6765\u5e94\u8be5\u4f1a\u7b80\u5355 10 \u500d\uff01\u201d

    \u2014\u2014 \u674e\u6c90\uff0c\u4e9a\u9a6c\u900a\u8d44\u6df1\u9996\u5e2d\u79d1\u5b66\u5bb6

    \u5168\u4e66\u52a8\u753b\u56fe\u89e3

    \u5185\u5bb9\u6e05\u6670\u6613\u61c2\u3001\u5b66\u4e60\u66f2\u7ebf\u5e73\u6ed1\u7535\u8111\u3001\u5e73\u677f\u3001\u624b\u673a\u5168\u7ec8\u7aef\u9605\u8bfb

    \"A picture is worth a thousand words.\"

    \u201c\u4e00\u56fe\u80dc\u5343\u8a00\u201d

    \u4ee3\u7801\u4e00\u952e\u8fd0\u884c

    \u63d0\u4f9b\u5404\u4e2a\u7b97\u6cd5\u4e0e\u6570\u636e\u7ed3\u6784\u7684\u7b80\u6d01\u5b9e\u73b0\u4e0e\u6d4b\u8bd5\u6837\u4f8b\uff0c\u7686\u53ef\u76f4\u63a5\u8fd0\u884c\u652f\u6301 Java, C++, Python, Go, JS, TS, C#, Swift, Zig \u7b49\u8bed\u8a00

    \"Talk is cheap. Show me the code.\"

    \u201c\u5c11\u5439\u725b\uff0c\u770b\u4ee3\u7801\u201d

    \u53ef\u8ba8\u8bba\u4e0e\u63d0\u95ee

    \u9f13\u52b1\u5c0f\u4f19\u4f34\u4eec\u4e92\u5e2e\u4e92\u52a9\u3001\u5171\u540c\u6210\u957f\u63d0\u95ee\u4e0e\u8bc4\u8bba\u4e00\u822c\u80fd\u5728\u4e24\u65e5\u5185\u5f97\u5230\u56de\u590d

    \u201c\u8ffd\u98ce\u8d76\u6708\u83ab\u505c\u7559\uff0c\u5e73\u829c\u5c3d\u5904\u662f\u6625\u5c71\u201d

    \u4e00\u8d77\u52a0\u6cb9\uff01

    \u5e8f

    \u4e24\u5e74\u524d\uff0c\u6211\u5728\u529b\u6263\u4e0a\u5206\u4eab\u4e86\u300a\u5251\u6307 Offer\u300b\u7cfb\u5217\u9898\u89e3\uff0c\u53d7\u5230\u4e86\u8bb8\u591a\u670b\u53cb\u7684\u559c\u7231\u4e0e\u652f\u6301\u3002\u5728\u6b64\u671f\u95f4\uff0c\u6211\u56de\u7b54\u4e86\u4f17\u591a\u8bfb\u8005\u7684\u8bc4\u8bba\u95ee\u9898\uff0c\u5176\u4e2d\u6700\u5e38\u89c1\u7684\u4e00\u4e2a\u95ee\u9898\u662f\u201c\u5982\u4f55\u5165\u95e8\u5b66\u4e60\u7b97\u6cd5\u201d\u3002\u6211\u9010\u6e10\u4e5f\u5bf9\u8fd9\u4e2a\u95ee\u9898\u4ea7\u751f\u4e86\u6d53\u539a\u7684\u5174\u8da3\u3002

    \u4e24\u773c\u4e00\u62b9\u9ed1\u5730\u5237\u9898\u4f3c\u4e4e\u662f\u6700\u53d7\u6b22\u8fce\u7684\u65b9\u6cd5\uff0c\u7b80\u5355\u76f4\u63a5\u4e14\u6709\u6548\u3002\u7136\u800c\uff0c\u5237\u9898\u5c31\u5982\u540c\u73a9\u201c\u626b\u96f7\u201d\u6e38\u620f\uff0c\u81ea\u5b66\u80fd\u529b\u5f3a\u7684\u540c\u5b66\u80fd\u591f\u987a\u5229\u5730\u5c06\u5730\u96f7\u9010\u4e2a\u6392\u6389\uff0c\u800c\u57fa\u7840\u4e0d\u8db3\u7684\u540c\u5b66\u5f88\u53ef\u80fd\u88ab\u70b8\u7684\u6ee1\u5934\u662f\u5305\uff0c\u5e76\u5728\u632b\u6298\u4e2d\u6b65\u6b65\u9000\u7f29\u3002\u901a\u8bfb\u6559\u6750\u4e66\u7c4d\u4e5f\u662f\u4e00\u79cd\u5e38\u89c1\u505a\u6cd5\uff0c\u4f46\u5bf9\u4e8e\u9762\u5411\u6c42\u804c\u7684\u540c\u5b66\u6765\u8bf4\uff0c\u6bd5\u4e1a\u5b63\u3001\u6295\u9012\u7b80\u5386\u3001\u51c6\u5907\u7b14\u8bd5\u9762\u8bd5\u5df2\u7ecf\u5360\u636e\u4e86\u5927\u90e8\u5206\u7cbe\u529b\uff0c\u539a\u91cd\u7684\u4e66\u7c4d\u5f80\u5f80\u53d8\u6210\u4e86\u4e00\u9879\u8270\u5de8\u7684\u6311\u6218\u3002

    \u5982\u679c\u4f60\u4e5f\u9762\u4e34\u7c7b\u4f3c\u7684\u56f0\u6270\uff0c\u90a3\u4e48\u5f88\u5e78\u8fd0\u8fd9\u672c\u4e66\u627e\u5230\u4e86\u4f60\u3002\u672c\u4e66\u662f\u6211\u5bf9\u6b64\u95ee\u9898\u7684\u7ed9\u51fa\u7684\u7b54\u6848\uff0c\u867d\u7136\u4e0d\u4e00\u5b9a\u6b63\u786e\uff0c\u4f46\u81f3\u5c11\u662f\u4e00\u6b21\u79ef\u6781\u7684\u5c1d\u8bd5\u3002\u8fd9\u672c\u4e66\u867d\u7136\u4e0d\u8db3\u4ee5\u8ba9\u4f60\u76f4\u63a5\u62ff\u5230 Offer \uff0c\u4f46\u4f1a\u5f15\u5bfc\u4f60\u63a2\u7d22\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u201c\u77e5\u8bc6\u5730\u56fe\u201d\uff0c\u5e26\u4f60\u4e86\u89e3\u4e0d\u540c\u201c\u5730\u96f7\u201d\u7684\u5f62\u72b6\u5927\u5c0f\u548c\u5206\u5e03\u4f4d\u7f6e\uff0c\u8ba9\u4f60\u638c\u63e1\u5404\u79cd\u201c\u6392\u96f7\u65b9\u6cd5\u201d\u3002\u6709\u4e86\u8fd9\u4e9b\u672c\u9886\uff0c\u76f8\u4fe1\u4f60\u53ef\u4ee5\u66f4\u52a0\u81ea\u5982\u5730\u5e94\u5bf9\u5237\u9898\u548c\u9605\u8bfb\u6587\u732e\uff0c\u9010\u6b65\u6784\u5efa\u8d77\u5b8c\u6574\u7684\u77e5\u8bc6\u4f53\u7cfb\u3002

    \u4f5c\u8005\u7b80\u4ecb

    \u9773\u5b87\u680b (Krahets)\uff0c\u5927\u5382\u9ad8\u7ea7\u7b97\u6cd5\u5de5\u7a0b\u5e08\uff0c\u4e0a\u6d77\u4ea4\u901a\u5927\u5b66\u7855\u58eb\u3002\u529b\u6263\uff08LeetCode\uff09\u5168\u7f51\u9605\u8bfb\u91cf\u6700\u9ad8\u535a\u4e3b\uff0c\u5176 LeetBook\u300a\u56fe\u89e3\u7b97\u6cd5\u6570\u636e\u7ed3\u6784\u300b\u5df2\u88ab\u8ba2\u9605 24 \u4e07\u672c\u3002

    \u81f4\u8c22

    \u672c\u4e66\u5728\u5f00\u6e90\u793e\u533a\u4f17\u591a\u8d21\u732e\u8005\u7684\u5171\u540c\u52aa\u529b\u4e0b\u4e0d\u65ad\u6210\u957f\u3002\u611f\u8c22\u6bcf\u4e00\u4f4d\u6295\u5165\u65f6\u95f4\u4e0e\u7cbe\u529b\u7684\u64b0\u7a3f\u4eba\uff0c\u662f\u4ed6\u4eec\u65e0\u79c1\u5949\u732e\u4f7f\u8fd9\u672c\u4e66\u8d8a\u53d8\u8d8a\u597d\uff0c\u4ed6\u4eec\u662f\uff08\u6309\u7167 GitHub \u81ea\u52a8\u751f\u6210\u7684\u987a\u5e8f\u6392\u5217\uff09\uff1a

    \u672c\u4e66\u7684\u4ee3\u7801\u5ba1\u9605\u5de5\u4f5c\u7531 Gonglja, gvenusleo, justin\u2010tse, krahets, nuomi1, Reanon, sjinzh \u5b8c\u6210\uff08\u6309\u7167\u9996\u5b57\u6bcd\u987a\u5e8f\u6392\u5217\uff09\u3002\u611f\u8c22\u4ed6\u4eec\u4ed8\u51fa\u7684\u65f6\u95f4\u4e0e\u7cbe\u529b\uff0c\u6b63\u662f\u4ed6\u4eec\u786e\u4fdd\u4e86\u5404\u8bed\u8a00\u4ee3\u7801\u7684\u89c4\u8303\u4e0e\u7edf\u4e00\u3002

    GongljaC / C++ gvenusleoDart hpstoryC# justin-tseJS / TS krahetsJava / Python nuomi1Swift ReanonGo / C sjinzhRust / Zig"},{"location":"chapter_appendix/contribution/","title":"14.2. \u00a0 \u4e00\u8d77\u53c2\u4e0e\u521b\u4f5c","text":"

    \u5f00\u6e90\u7684\u9b45\u529b

    \u7eb8\u8d28\u4e66\u7c4d\u7684\u4e24\u6b21\u5370\u5237\u7684\u95f4\u9694\u65f6\u95f4\u5f80\u5f80\u9700\u8981\u6570\u5e74\uff0c\u5185\u5bb9\u66f4\u65b0\u975e\u5e38\u4e0d\u65b9\u4fbf\u3002\u4f46\u5728\u672c\u5f00\u6e90\u4e66\u4e2d\uff0c\u5185\u5bb9\u66f4\u8fed\u7684\u65f6\u95f4\u88ab\u7f29\u77ed\u81f3\u6570\u65e5\u751a\u81f3\u51e0\u4e2a\u5c0f\u65f6\u3002

    \u7531\u4e8e\u4f5c\u8005\u80fd\u529b\u6709\u9650\uff0c\u4e66\u4e2d\u96be\u514d\u5b58\u5728\u4e00\u4e9b\u9057\u6f0f\u548c\u9519\u8bef\uff0c\u8bf7\u60a8\u8c05\u89e3\u3002\u5982\u679c\u60a8\u53d1\u73b0\u4e86\u7b14\u8bef\u3001\u5931\u6548\u94fe\u63a5\u3001\u5185\u5bb9\u7f3a\u5931\u3001\u6587\u5b57\u6b67\u4e49\u3001\u89e3\u91ca\u4e0d\u6e05\u6670\u6216\u884c\u6587\u7ed3\u6784\u4e0d\u5408\u7406\u7b49\u95ee\u9898\uff0c\u8bf7\u534f\u52a9\u6211\u4eec\u8fdb\u884c\u4fee\u6b63\uff0c\u4ee5\u5e2e\u52a9\u5176\u4ed6\u8bfb\u8005\u83b7\u5f97\u66f4\u4f18\u8d28\u7684\u5b66\u4e60\u8d44\u6e90\u3002\u6240\u6709\u64b0\u7a3f\u4eba\u5c06\u5728\u4ed3\u5e93\u548c\u7f51\u7ad9\u4e3b\u9875\u4e0a\u5c55\u793a\uff0c\u4ee5\u611f\u8c22\u4ed6\u4eec\u5bf9\u5f00\u6e90\u793e\u533a\u7684\u65e0\u79c1\u5949\u732e\uff01

    "},{"location":"chapter_appendix/contribution/#1421","title":"14.2.1. \u00a0 \u5185\u5bb9\u5fae\u8c03","text":"

    \u5728\u6bcf\u4e2a\u9875\u9762\u7684\u53f3\u4e0a\u89d2\u6709\u4e00\u4e2a\u300c\u7f16\u8f91\u300d\u56fe\u6807\uff0c\u60a8\u53ef\u4ee5\u6309\u7167\u4ee5\u4e0b\u6b65\u9aa4\u4fee\u6539\u6587\u672c\u6216\u4ee3\u7801\uff1a

    1. \u70b9\u51fb\u7f16\u8f91\u6309\u94ae\uff0c\u5982\u679c\u9047\u5230\u201c\u9700\u8981 Fork \u6b64\u4ed3\u5e93\u201d\u7684\u63d0\u793a\uff0c\u8bf7\u540c\u610f\u8be5\u64cd\u4f5c\uff1b
    2. \u4fee\u6539 Markdown \u6e90\u6587\u4ef6\u5185\u5bb9\uff0c\u5e76\u786e\u4fdd\u5185\u5bb9\u6b63\u786e\uff0c\u540c\u65f6\u5c3d\u91cf\u4fdd\u6301\u6392\u7248\u683c\u5f0f\u7684\u7edf\u4e00\uff1b
    3. \u5728\u9875\u9762\u5e95\u90e8\u586b\u5199\u4fee\u6539\u8bf4\u660e\uff0c\u7136\u540e\u70b9\u51fb\u201cPropose file change\u201d\u6309\u94ae\uff1b\u9875\u9762\u8df3\u8f6c\u540e\uff0c\u70b9\u51fb\u201cCreate pull request\u201d\u6309\u94ae\u5373\u53ef\u53d1\u8d77\u62c9\u53d6\u8bf7\u6c42\u3002

    Fig. \u9875\u9762\u7f16\u8f91\u6309\u952e

    \u7531\u4e8e\u56fe\u7247\u65e0\u6cd5\u76f4\u63a5\u4fee\u6539\uff0c\u56e0\u6b64\u9700\u8981\u901a\u8fc7\u65b0\u5efa Issue \u6216\u8bc4\u8bba\u7559\u8a00\u6765\u63cf\u8ff0\u56fe\u7247\u95ee\u9898\uff0c\u6211\u4eec\u4f1a\u5c3d\u5feb\u91cd\u65b0\u7ed8\u5236\u5e76\u66ff\u6362\u56fe\u7247\u3002

    "},{"location":"chapter_appendix/contribution/#1422","title":"14.2.2. \u00a0 \u5185\u5bb9\u521b\u4f5c","text":"

    \u5982\u679c\u60a8\u6709\u5174\u8da3\u53c2\u4e0e\u6b64\u5f00\u6e90\u9879\u76ee\uff0c\u5305\u62ec\u5c06\u4ee3\u7801\u7ffb\u8bd1\u6210\u5176\u4ed6\u7f16\u7a0b\u8bed\u8a00\u3001\u6269\u5c55\u6587\u7ae0\u5185\u5bb9\u7b49\uff0c\u90a3\u4e48\u9700\u8981\u5b9e\u65bd Pull Request \u5de5\u4f5c\u6d41\u7a0b\uff1a

    1. \u767b\u5f55 GitHub \uff0c\u5c06\u672c\u4ed3\u5e93 Fork \u5230\u4e2a\u4eba\u8d26\u53f7\u4e0b\uff1b
    2. \u8fdb\u5165\u60a8\u7684 Fork \u4ed3\u5e93\u7f51\u9875\uff0c\u4f7f\u7528 git clone \u547d\u4ee4\u5c06\u4ed3\u5e93\u514b\u9686\u81f3\u672c\u5730\uff1b
    3. \u5728\u672c\u5730\u8fdb\u884c\u5185\u5bb9\u521b\u4f5c\uff0c\u5e76\u901a\u8fc7\u8fd0\u884c\u6d4b\u8bd5\u4ee5\u9a8c\u8bc1\u4ee3\u7801\u7684\u6b63\u786e\u6027\uff1b
    4. \u5c06\u672c\u5730\u6240\u505a\u66f4\u6539 Commit \uff0c\u7136\u540e Push \u81f3\u8fdc\u7a0b\u4ed3\u5e93\uff1b
    5. \u5237\u65b0\u4ed3\u5e93\u7f51\u9875\uff0c\u70b9\u51fb\u201cCreate pull request\u201d\u6309\u94ae\u5373\u53ef\u53d1\u8d77\u62c9\u53d6\u8bf7\u6c42\uff1b
    "},{"location":"chapter_appendix/contribution/#1423-docker","title":"14.2.3. \u00a0 Docker \u90e8\u7f72","text":"

    \u6211\u4eec\u53ef\u4ee5\u901a\u8fc7 Docker \u6765\u90e8\u7f72\u672c\u9879\u76ee\u3002\u6267\u884c\u4ee5\u4e0b\u811a\u672c\uff0c\u7a0d\u7b49\u7247\u523b\u540e\uff0c\u5373\u53ef\u4f7f\u7528\u6d4f\u89c8\u5668\u6253\u5f00 http://localhost:8000 \u6765\u8bbf\u95ee\u672c\u9879\u76ee\u3002

    git clone https://github.com/krahets/hello-algo.git\ncd hello-algo\ndocker-compose up -d\n

    \u4f7f\u7528\u4ee5\u4e0b\u547d\u4ee4\u5373\u53ef\u5220\u9664\u90e8\u7f72\u3002

    docker-compose down\n
    "},{"location":"chapter_appendix/installation/","title":"14.1. \u00a0 \u7f16\u7a0b\u73af\u5883\u5b89\u88c5","text":""},{"location":"chapter_appendix/installation/#1411-vscode","title":"14.1.1. \u00a0 VSCode","text":"

    \u672c\u4e66\u63a8\u8350\u4f7f\u7528\u5f00\u6e90\u8f7b\u91cf\u7684 VSCode \u4f5c\u4e3a\u672c\u5730 IDE \uff0c\u4e0b\u8f7d\u5e76\u5b89\u88c5 VSCode \u3002

    "},{"location":"chapter_appendix/installation/#1412-java","title":"14.1.2. \u00a0 Java \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 OpenJDK\uff08\u7248\u672c\u9700\u6ee1\u8db3 > JDK 9\uff09\u3002
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 java \uff0c\u5b89\u88c5 Extension Pack for Java \u3002
    "},{"location":"chapter_appendix/installation/#1413-cc","title":"14.1.3. \u00a0 C/C++ \u73af\u5883","text":"
    1. Windows \u7cfb\u7edf\u9700\u8981\u5b89\u88c5 MinGW\uff08\u914d\u7f6e\u6559\u7a0b\uff09\uff0cMacOS \u81ea\u5e26 Clang \u65e0\u9700\u5b89\u88c5\u3002
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 c++ \uff0c\u5b89\u88c5 C/C++ Extension Pack \u3002
    3. \uff08\u53ef\u9009\uff09\u6253\u5f00 Settings \u9875\u9762\uff0c\u641c\u7d22 Clang_format_fallback Style \u4ee3\u7801\u683c\u5f0f\u5316\u9009\u9879\uff0c\u8bbe\u7f6e\u4e3a { BasedOnStyle: Microsoft, BreakBeforeBraces: Attach } \u3002
    "},{"location":"chapter_appendix/installation/#1414-python","title":"14.1.4. \u00a0 Python \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Miniconda3 \u3002
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 python \uff0c\u5b89\u88c5 Python Extension Pack \u3002
    3. \uff08\u53ef\u9009\uff09\u5728\u547d\u4ee4\u884c\u8f93\u5165 pip install black \uff0c\u5b89\u88c5\u4ee3\u7801\u683c\u5f0f\u5316\u5de5\u5177\u3002
    "},{"location":"chapter_appendix/installation/#1415-go","title":"14.1.5. \u00a0 Go \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 go \u3002
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 go \uff0c\u5b89\u88c5 Go \u3002
    3. \u5feb\u6377\u952e Ctrl + Shift + P \u547c\u51fa\u547d\u4ee4\u680f\uff0c\u8f93\u5165 go \uff0c\u9009\u62e9 Go: Install/Update Tools \uff0c\u5168\u90e8\u52fe\u9009\u5e76\u5b89\u88c5\u5373\u53ef\u3002
    "},{"location":"chapter_appendix/installation/#1416-javascript","title":"14.1.6. \u00a0 JavaScript \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 node.js \u3002
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 javascript \uff0c\u5b89\u88c5 JavaScript (ES6) code snippets \u3002
    3. \uff08\u53ef\u9009\uff09\u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 Prettier \uff0c\u5b89\u88c5\u4ee3\u7801\u683c\u5f0f\u5316\u5de5\u5177\u3002
    "},{"location":"chapter_appendix/installation/#1417-c","title":"14.1.7. \u00a0 C# \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 .Net 6.0 \uff1b
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 c# \uff0c\u5b89\u88c5 c# \u3002
    "},{"location":"chapter_appendix/installation/#1418-swift","title":"14.1.8. \u00a0 Swift \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Swift\uff1b
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 swift \uff0c\u5b89\u88c5 Swift for Visual Studio Code\u3002
    "},{"location":"chapter_appendix/installation/#1419-rust","title":"14.1.9. \u00a0 Rust \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Rust\uff1b
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 rust \uff0c\u5b89\u88c5 rust-analyzer\u3002
    "},{"location":"chapter_array_and_linkedlist/","title":"4. \u00a0 \u6570\u7ec4\u4e0e\u94fe\u8868","text":""},{"location":"chapter_array_and_linkedlist/array/","title":"4.1. \u00a0 \u6570\u7ec4","text":"

    \u300c\u6570\u7ec4 Array\u300d\u662f\u4e00\u79cd\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u5176\u5c06\u76f8\u540c\u7c7b\u578b\u5143\u7d20\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\u3002\u6211\u4eec\u5c06\u5143\u7d20\u5728\u6570\u7ec4\u4e2d\u7684\u4f4d\u7f6e\u79f0\u4e3a\u5143\u7d20\u7684\u300c\u7d22\u5f15 Index\u300d\u3002

    Fig. \u6570\u7ec4\u5b9a\u4e49\u4e0e\u5b58\u50a8\u65b9\u5f0f

    \u6570\u7ec4\u521d\u59cb\u5316\u3002\u901a\u5e38\u6709\u65e0\u521d\u59cb\u503c\u548c\u7ed9\u5b9a\u521d\u59cb\u503c\u4e24\u79cd\u65b9\u5f0f\uff0c\u6211\u4eec\u53ef\u6839\u636e\u9700\u6c42\u9009\u62e9\u5408\u9002\u7684\u65b9\u6cd5\u3002\u5728\u672a\u7ed9\u5b9a\u521d\u59cb\u503c\u7684\u60c5\u51b5\u4e0b\uff0c\u6570\u7ec4\u7684\u6240\u6709\u5143\u7d20\u901a\u5e38\u4f1a\u88ab\u521d\u59cb\u5316\u4e3a\u9ed8\u8ba4\u503c \\(0\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n
    array.cpp
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\n// \u5b58\u50a8\u5728\u6808\u4e0a\nint arr[5];\nint nums[5] { 1, 3, 2, 5, 4 };\n// \u5b58\u50a8\u5728\u5806\u4e0a\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n
    array.py
    # \u521d\u59cb\u5316\u6570\u7ec4\narr: List[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: List[int] = [1, 3, 2, 5, 4]  \n
    array.go
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nvar arr [5]int\n// \u5728 Go \u4e2d\uff0c\u6307\u5b9a\u957f\u5ea6\u65f6\uff08[5]int\uff09\u4e3a\u6570\u7ec4\uff0c\u4e0d\u6307\u5b9a\u957f\u5ea6\u65f6\uff08[]int\uff09\u4e3a\u5207\u7247\n// \u7531\u4e8e Go \u7684\u6570\u7ec4\u88ab\u8bbe\u8ba1\u4e3a\u5728\u7f16\u8bd1\u671f\u786e\u5b9a\u957f\u5ea6\uff0c\u56e0\u6b64\u53ea\u80fd\u4f7f\u7528\u5e38\u91cf\u6765\u6307\u5b9a\u957f\u5ea6\n// \u4e3a\u4e86\u65b9\u4fbf\u5b9e\u73b0\u6269\u5bb9 extend() \u65b9\u6cd5\uff0c\u4ee5\u4e0b\u5c06\u5207\u7247\uff08Slice\uff09\u770b\u4f5c\u6570\u7ec4\uff08Array\uff09\nnums := []int{1, 3, 2, 5, 4}\n
    array.js
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n
    array.ts
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n
    array.c
    int arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n
    array.cs
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n
    array.swift
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n
    array.zig
    // \u521d\u59cb\u5316\u6570\u7ec4\nvar arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }\nvar nums = [_]i32{ 1, 3, 2, 5, 4 };\n
    array.dart
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nList<int> arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList<int> nums = [1, 3, 2, 5, 4];\n
    "},{"location":"chapter_array_and_linkedlist/array/#411","title":"4.1.1. \u00a0 \u6570\u7ec4\u4f18\u70b9","text":"

    \u5728\u6570\u7ec4\u4e2d\u8bbf\u95ee\u5143\u7d20\u975e\u5e38\u9ad8\u6548\u3002\u7531\u4e8e\u6570\u7ec4\u5143\u7d20\u88ab\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\uff0c\u56e0\u6b64\u8ba1\u7b97\u6570\u7ec4\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\u975e\u5e38\u5bb9\u6613\u3002\u7ed9\u5b9a\u6570\u7ec4\u9996\u4e2a\u5143\u7d20\u7684\u5730\u5740\u548c\u67d0\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4ee5\u4e0b\u516c\u5f0f\u8ba1\u7b97\u5f97\u5230\u8be5\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\uff0c\u4ece\u800c\u76f4\u63a5\u8bbf\u95ee\u6b64\u5143\u7d20\u3002

    Fig. \u6570\u7ec4\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\u8ba1\u7b97 

    # \u5143\u7d20\u5185\u5b58\u5730\u5740 = \u6570\u7ec4\u5185\u5b58\u5730\u5740 + \u5143\u7d20\u957f\u5ea6 * \u5143\u7d20\u7d22\u5f15\nelementAddr = firtstElementAddr + elementLength * elementIndex\n

    \u4e3a\u4ec0\u4e48\u6570\u7ec4\u5143\u7d20\u7684\u7d22\u5f15\u8981\u4ece \\(0\\) \u5f00\u59cb\u7f16\u53f7\u5462\uff1f

    \u89c2\u5bdf\u4e0a\u56fe\uff0c\u6211\u4eec\u53d1\u73b0\u6570\u7ec4\u9996\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\u4e3a \\(0\\) \uff0c\u8fd9\u4f3c\u4e4e\u6709\u4e9b\u53cd\u76f4\u89c9\uff0c\u56e0\u4e3a\u4ece \\(1\\) \u5f00\u59cb\u8ba1\u6570\u4f1a\u66f4\u81ea\u7136\u3002

    \u7136\u800c\uff0c\u4ece\u5730\u5740\u8ba1\u7b97\u516c\u5f0f\u7684\u89d2\u5ea6\u770b\uff0c\u7d22\u5f15\u672c\u8d28\u4e0a\u8868\u793a\u7684\u662f\u5185\u5b58\u5730\u5740\u7684\u504f\u79fb\u91cf\u3002\u9996\u4e2a\u5143\u7d20\u7684\u5730\u5740\u504f\u79fb\u91cf\u662f \\(0\\) \uff0c\u56e0\u6b64\u7d22\u5f15\u4e3a \\(0\\) \u4e5f\u662f\u5408\u7406\u7684\u3002

    \u8bbf\u95ee\u5143\u7d20\u7684\u9ad8\u6548\u6027\u5e26\u6765\u4e86\u8bf8\u591a\u4fbf\u5229\u3002\u4f8b\u5982\uff0c\u6211\u4eec\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u968f\u673a\u83b7\u53d6\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u4e00\u4e2a\u5143\u7d20\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nint randomAccess(int[] nums) {\n// \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nint randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nint randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    array.cpp
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n// \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nint randomIndex = rand() % size;\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nint randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    array.py
    def random_access(nums: list[int]) -> int:\n\"\"\"\u968f\u673a\u8bbf\u95ee\u5143\u7d20\"\"\"\n# \u5728\u533a\u95f4 [0, len(nums)-1] \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nrandom_index = random.randint(0, len(nums) - 1)\n# \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nrandom_num = nums[random_index]\nreturn random_num\n
    array.go
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nfunc randomAccess(nums []int) (randomNum int) {\n// \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nrandomIndex := rand.Intn(len(nums))\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nrandomNum = nums[randomIndex]\nreturn\n}\n
    array.js
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nfunction randomAccess(nums) {\n// \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nconst random_index = Math.floor(Math.random() * nums.length);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nconst random_num = nums[random_index];\nreturn random_num;\n}\n
    array.ts
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nfunction randomAccess(nums: number[]): number {\n// \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nconst random_index = Math.floor(Math.random() * nums.length);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nconst random_num = nums[random_index];\nreturn random_num;\n}\n
    array.c
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n// \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nint randomIndex = rand() % size;\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nint randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    array.cs
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nint randomAccess(int[] nums) {\nRandom random = new();\n// \u5728\u533a\u95f4 [0, nums.Length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nint randomIndex = random.Next(nums.Length);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nint randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    array.swift
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nfunc randomAccess(nums: [Int]) -> Int {\n// \u5728\u533a\u95f4 [0, nums.count) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nlet randomIndex = nums.indices.randomElement()!\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nlet randomNum = nums[randomIndex]\nreturn randomNum\n}\n
    array.zig
    // \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20\nfn randomAccess(nums: []i32) i32 {\n// \u5728\u533a\u95f4 [0, nums.len) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6574\u6570\nvar randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nvar randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    array.dart
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nint randomAccess(List nums) {\n// \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nint randomIndex = Random().nextInt(nums.length);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nint randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    "},{"location":"chapter_array_and_linkedlist/array/#412","title":"4.1.2. \u00a0 \u6570\u7ec4\u7f3a\u70b9","text":"

    \u6570\u7ec4\u5728\u521d\u59cb\u5316\u540e\u957f\u5ea6\u4e0d\u53ef\u53d8\u3002\u7531\u4e8e\u7cfb\u7edf\u65e0\u6cd5\u4fdd\u8bc1\u6570\u7ec4\u4e4b\u540e\u7684\u5185\u5b58\u7a7a\u95f4\u662f\u53ef\u7528\u7684\uff0c\u56e0\u6b64\u6570\u7ec4\u957f\u5ea6\u65e0\u6cd5\u6269\u5c55\u3002\u800c\u82e5\u5e0c\u671b\u6269\u5bb9\u6570\u7ec4\uff0c\u5219\u9700\u65b0\u5efa\u4e00\u4e2a\u6570\u7ec4\uff0c\u7136\u540e\u628a\u539f\u6570\u7ec4\u5143\u7d20\u4f9d\u6b21\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\uff0c\u5728\u6570\u7ec4\u5f88\u5927\u7684\u60c5\u51b5\u4e0b\uff0c\u8fd9\u662f\u975e\u5e38\u8017\u65f6\u7684\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nint[] extend(int[] nums, int enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nint[] res = new int[nums.length + enlarge];\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (int i = 0; i < nums.length; i++) {\nres[i] = nums[i];\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.cpp
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nint *extend(int *nums, int size, int enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nint *res = new int[size + enlarge];\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (int i = 0; i < size; i++) {\nres[i] = nums[i];\n}\n// \u91ca\u653e\u5185\u5b58\ndelete[] nums;\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.py
    def extend(nums: list[int], enlarge: int) -> list[int]:\n\"\"\"\u6269\u5c55\u6570\u7ec4\u957f\u5ea6\"\"\"\n# \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nres = [0] * (len(nums) + enlarge)\n# \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor i in range(len(nums)):\nres[i] = nums[i]\n# \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res\n
    array.go
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfunc extend(nums []int, enlarge int) []int {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nres := make([]int, len(nums)+enlarge)\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor i, num := range nums {\nres[i] = num\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res\n}\n
    array.js
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\n// \u8bf7\u6ce8\u610f\uff0cJavaScript \u7684 Array \u662f\u52a8\u6001\u6570\u7ec4\uff0c\u53ef\u4ee5\u76f4\u63a5\u6269\u5c55\n// \u4e3a\u4e86\u65b9\u4fbf\u5b66\u4e60\uff0c\u672c\u51fd\u6570\u5c06 Array \u770b\u4f5c\u662f\u957f\u5ea6\u4e0d\u53ef\u53d8\u7684\u6570\u7ec4\nfunction extend(nums, enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nconst res = new Array(nums.length + enlarge).fill(0);\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (let i = 0; i < nums.length; i++) {\nres[i] = nums[i];\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.ts
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\n// \u8bf7\u6ce8\u610f\uff0cTypeScript \u7684 Array \u662f\u52a8\u6001\u6570\u7ec4\uff0c\u53ef\u4ee5\u76f4\u63a5\u6269\u5c55\n// \u4e3a\u4e86\u65b9\u4fbf\u5b66\u4e60\uff0c\u672c\u51fd\u6570\u5c06 Array \u770b\u4f5c\u662f\u957f\u5ea6\u4e0d\u53ef\u53d8\u7684\u6570\u7ec4\nfunction extend(nums: number[], enlarge: number): number[] {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nconst res = new Array(nums.length + enlarge).fill(0);\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (let i = 0; i < nums.length; i++) {\nres[i] = nums[i];\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.c
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nint *extend(int *nums, int size, int enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nint *res = (int *)malloc(sizeof(int) * (size + enlarge));\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (int i = 0; i < size; i++) {\nres[i] = nums[i];\n}\n// \u521d\u59cb\u5316\u6269\u5c55\u540e\u7684\u7a7a\u95f4\nfor (int i = size; i < size + enlarge; i++) {\nres[i] = 0;\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.cs
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nint[] extend(int[] nums, int enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nint[] res = new int[nums.Length + enlarge];\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (int i = 0; i < nums.Length; i++) {\nres[i] = nums[i];\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.swift
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfunc extend(nums: [Int], enlarge: Int) -> [Int] {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nvar res = Array(repeating: 0, count: nums.count + enlarge)\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor i in nums.indices {\nres[i] = nums[i]\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res\n}\n
    array.zig
    // \u6269\u5c55\u6570\u7ec4\u957f\u5ea6\nfn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nvar res = try mem_allocator.alloc(i32, nums.len + enlarge);\n@memset(res, 0);\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nstd.mem.copy(i32, res, nums);\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.dart
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nList extend(List nums, int enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nList<int> res = List.filled(nums.length + enlarge, 0);\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (var i = 0; i < nums.length; i++) {\nres[i] = nums[i];\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n

    \u6570\u7ec4\u4e2d\u63d2\u5165\u6216\u5220\u9664\u5143\u7d20\u6548\u7387\u4f4e\u4e0b\u3002\u5982\u679c\u6211\u4eec\u60f3\u8981\u5728\u6570\u7ec4\u4e2d\u95f4\u63d2\u5165\u4e00\u4e2a\u5143\u7d20\uff0c\u7531\u4e8e\u6570\u7ec4\u5143\u7d20\u5728\u5185\u5b58\u4e2d\u662f\u201c\u7d27\u6328\u7740\u7684\u201d\uff0c\u5b83\u4eec\u4e4b\u95f4\u6ca1\u6709\u7a7a\u95f4\u518d\u653e\u4efb\u4f55\u6570\u636e\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u4e0d\u5f97\u4e0d\u5c06\u6b64\u7d22\u5f15\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u7136\u540e\u518d\u628a\u5143\u7d20\u8d4b\u503c\u7ed9\u8be5\u7d22\u5f15\u3002

    Fig. \u6570\u7ec4\u63d2\u5165\u5143\u7d20

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nvoid insert(int[] nums, int num, int index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int i = nums.length - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.cpp
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nvoid insert(int *nums, int size, int num, int index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int i = size - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.py
    def insert(nums: list[int], num: int, index: int) -> None:\n\"\"\"\u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num\"\"\"\n# \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor i in range(len(nums) - 1, index, -1):\nnums[i] = nums[i - 1]\n# \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num\n
    array.go
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfunc insert(nums []int, num int, index int) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor i := len(nums) - 1; i > index; i-- {\nnums[i] = nums[i-1]\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num\n}\n
    array.js
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfunction insert(nums, num, index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (let i = nums.length - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.ts
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfunction insert(nums: number[], num: number, index: number): void {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (let i = nums.length - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.c
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nvoid insert(int *nums, int size, int num, int index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int i = size - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.cs
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nvoid insert(int[] nums, int num, int index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int i = nums.Length - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.swift
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfunc insert(nums: inout [Int], num: Int, index: Int) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor i in sequence(first: nums.count - 1, next: { $0 > index + 1 ? $0 - 1 : nil }) {\nnums[i] = nums[i - 1]\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num\n}\n
    array.zig
    // \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num\nfn insert(nums: []i32, num: i32, index: usize) void {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nvar i = nums.len - 1;\nwhile (i > index) : (i -= 1) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nvoid insert(List nums, int num, int index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (var i = nums.length - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n

    \u5220\u9664\u5143\u7d20\u4e5f\u7c7b\u4f3c\uff0c\u5982\u679c\u6211\u4eec\u60f3\u8981\u5220\u9664\u7d22\u5f15 \\(i\\) \u5904\u7684\u5143\u7d20\uff0c\u5219\u9700\u8981\u628a\u7d22\u5f15 \\(i\\) \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u5220\u9664\u5143\u7d20\u540e\uff0c\u539f\u5148\u672b\u5c3e\u7684\u5143\u7d20\u53d8\u5f97\u201c\u65e0\u610f\u4e49\u201d\u4e86\uff0c\u6211\u4eec\u65e0\u9700\u7279\u610f\u53bb\u4fee\u6539\u5b83\u3002

    Fig. \u6570\u7ec4\u5220\u9664\u5143\u7d20

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nvoid remove(int[] nums, int index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int i = index; i < nums.length - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.cpp
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nvoid remove(int *nums, int size, int index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int i = index; i < size - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.py
    def remove(nums: list[int], index: int) -> None:\n\"\"\"\u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20\"\"\"\n# \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor i in range(index, len(nums) - 1):\nnums[i] = nums[i + 1]\n
    array.go
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nfunc remove(nums []int, index int) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor i := index; i < len(nums)-1; i++ {\nnums[i] = nums[i+1]\n}\n}\n
    array.js
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nfunction remove(nums, index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (let i = index; i < nums.length - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.ts
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nfunction remove(nums: number[], index: number): void {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (let i = index; i < nums.length - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.c
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\n// \u6ce8\u610f\uff1astdio.h \u5360\u7528\u4e86 remove \u5173\u952e\u8bcd\nvoid removeItem(int *nums, int size, int index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int i = index; i < size - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.cs
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nvoid remove(int[] nums, int index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int i = index; i < nums.Length - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.swift
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nfunc remove(nums: inout [Int], index: Int) {\nlet count = nums.count\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor i in sequence(first: index, next: { $0 < count - 1 - 1 ? $0 + 1 : nil }) {\nnums[i] = nums[i + 1]\n}\n}\n
    array.zig
    // \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20\nfn remove(nums: []i32, index: usize) void {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nvar i = index;\nwhile (i < nums.len - 1) : (i += 1) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.dart
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nvoid remove(List nums, int index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (var i = index; i < nums.length - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n

    \u603b\u7ed3\u6765\u770b\uff0c\u6570\u7ec4\u7684\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u6709\u4ee5\u4e0b\u7f3a\u70b9\uff1a

    • \u65f6\u95f4\u590d\u6742\u5ea6\u9ad8\uff1a\u6570\u7ec4\u7684\u63d2\u5165\u548c\u5220\u9664\u7684\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(n)\\) \uff0c\u5176\u4e2d \\(n\\) \u4e3a\u6570\u7ec4\u957f\u5ea6\u3002
    • \u4e22\u5931\u5143\u7d20\uff1a\u7531\u4e8e\u6570\u7ec4\u7684\u957f\u5ea6\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u5728\u63d2\u5165\u5143\u7d20\u540e\uff0c\u8d85\u51fa\u6570\u7ec4\u957f\u5ea6\u8303\u56f4\u7684\u5143\u7d20\u4f1a\u4e22\u5931\u3002
    • \u5185\u5b58\u6d6a\u8d39\uff1a\u6211\u4eec\u53ef\u4ee5\u521d\u59cb\u5316\u4e00\u4e2a\u6bd4\u8f83\u957f\u7684\u6570\u7ec4\uff0c\u53ea\u7528\u524d\u9762\u4e00\u90e8\u5206\uff0c\u8fd9\u6837\u5728\u63d2\u5165\u6570\u636e\u65f6\uff0c\u4e22\u5931\u7684\u672b\u5c3e\u5143\u7d20\u90fd\u662f\u6211\u4eec\u4e0d\u5173\u5fc3\u7684\uff0c\u4f46\u8fd9\u6837\u505a\u540c\u65f6\u4e5f\u4f1a\u9020\u6210\u5185\u5b58\u7a7a\u95f4\u7684\u6d6a\u8d39\u3002
    "},{"location":"chapter_array_and_linkedlist/array/#413","title":"4.1.3. \u00a0 \u6570\u7ec4\u5e38\u7528\u64cd\u4f5c","text":"

    \u6570\u7ec4\u904d\u5386\u3002\u4ee5\u4e0b\u4ecb\u7ecd\u4e24\u79cd\u5e38\u7528\u7684\u904d\u5386\u65b9\u6cd5\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int[] nums) {\nint count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (int i = 0; i < nums.length; i++) {\ncount++;\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor (int num : nums) {\ncount++;\n}\n}\n
    array.cpp
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\nint count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (int i = 0; i < size; i++) {\ncount++;\n}\n}\n
    array.py
    def traverse(nums: list[int]) -> None:\n\"\"\"\u904d\u5386\u6570\u7ec4\"\"\"\ncount = 0\n# \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor i in range(len(nums)):\ncount += 1\n# \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor num in nums:\ncount += 1\n# \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\nfor i, num in enumerate(nums):\ncount += 1\n
    array.go
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums []int) {\ncount := 0\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor i := 0; i < len(nums); i++ {\ncount++\n}\ncount = 0\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor range nums {\ncount++\n}\n}\n
    array.js
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums) {\nlet count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (let i = 0; i < nums.length; i++) {\ncount++;\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor (let num of nums) {\ncount += 1;\n}\n}\n
    array.ts
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums: number[]): void {\nlet count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (let i = 0; i < nums.length; i++) {\ncount++;\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor (let num of nums) {\ncount += 1;\n}\n}\n
    array.c
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\nint count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (int i = 0; i < size; i++) {\ncount++;\n}\n}\n
    array.cs
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int[] nums) {\nint count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (int i = 0; i < nums.Length; i++) {\ncount++;\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nforeach (int num in nums) {\ncount++;\n}\n}\n
    array.swift
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums: [Int]) {\nvar count = 0\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor _ in nums.indices {\ncount += 1\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor _ in nums {\ncount += 1\n}\n}\n
    array.zig
    // \u904d\u5386\u6570\u7ec4\nfn traverse(nums: []i32) void {\nvar count: i32 = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nvar i: i32 = 0;\nwhile (i < nums.len) : (i += 1) {\ncount += 1;\n}\ncount = 0;\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor (nums) |_| {\ncount += 1;\n}\n}\n
    array.dart
    /* \u904d\u5386\u6570\u7ec4\u5143\u7d20 */\nvoid traverse(List nums) {\nvar count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (var i = 0; i < nums.length; i++) {\ncount++;\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor (var num in nums) {\ncount++;\n}\n// \u901a\u8fc7 forEach \u65b9\u6cd5\u904d\u5386\u6570\u7ec4\nnums.forEach((element) {\ncount++;\n});\n}\n

    \u6570\u7ec4\u67e5\u627e\u3002\u901a\u8fc7\u904d\u5386\u6570\u7ec4\uff0c\u67e5\u627e\u6570\u7ec4\u5185\u7684\u6307\u5b9a\u5143\u7d20\uff0c\u5e76\u8f93\u51fa\u5bf9\u5e94\u7d22\u5f15\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int[] nums, int target) {\nfor (int i = 0; i < nums.length; i++) {\nif (nums[i] == target)\nreturn i;\n}\nreturn -1;\n}\n
    array.cpp
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\nfor (int i = 0; i < size; i++) {\nif (nums[i] == target)\nreturn i;\n}\nreturn -1;\n}\n
    array.py
    def find(nums: list[int], target: int) -> int:\n\"\"\"\u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\"\"\"\nfor i in range(len(nums)):\nif nums[i] == target:\nreturn i\nreturn -1\n
    array.go
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums []int, target int) (index int) {\nindex = -1\nfor i := 0; i < len(nums); i++ {\nif nums[i] == target {\nindex = i\nbreak\n}\n}\nreturn\n}\n
    array.js
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums, target) {\nfor (let i = 0; i < nums.length; i++) {\nif (nums[i] == target) return i;\n}\nreturn -1;\n}\n
    array.ts
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums: number[], target: number): number {\nfor (let i = 0; i < nums.length; i++) {\nif (nums[i] === target) {\nreturn i;\n}\n}\nreturn -1;\n}\n
    array.c
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\nfor (int i = 0; i < size; i++) {\nif (nums[i] == target)\nreturn i;\n}\nreturn -1;\n}\n
    array.cs
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int[] nums, int target) {\nfor (int i = 0; i < nums.Length; i++) {\nif (nums[i] == target)\nreturn i;\n}\nreturn -1;\n}\n
    array.swift
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums: [Int], target: Int) -> Int {\nfor i in nums.indices {\nif nums[i] == target {\nreturn i\n}\n}\nreturn -1\n}\n
    array.zig
    // \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\nfn find(nums: []i32, target: i32) i32 {\nfor (nums, 0..) |num, i| {\nif (num == target) return @intCast(i);\n}\nreturn -1;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(List nums, int target) {\nfor (var i = 0; i < nums.length; i++) {\nif (nums[i] == target) return i;\n}\nreturn -1;\n}\n
    "},{"location":"chapter_array_and_linkedlist/array/#414","title":"4.1.4. \u00a0 \u6570\u7ec4\u5178\u578b\u5e94\u7528","text":"

    \u968f\u673a\u8bbf\u95ee\u3002\u5982\u679c\u6211\u4eec\u60f3\u8981\u968f\u673a\u62bd\u53d6\u4e00\u4e9b\u6837\u672c\uff0c\u90a3\u4e48\u53ef\u4ee5\u7528\u6570\u7ec4\u5b58\u50a8\uff0c\u5e76\u751f\u6210\u4e00\u4e2a\u968f\u673a\u5e8f\u5217\uff0c\u6839\u636e\u7d22\u5f15\u5b9e\u73b0\u6837\u672c\u7684\u968f\u673a\u62bd\u53d6\u3002

    \u4e8c\u5206\u67e5\u627e\u3002\u4f8b\u5982\u524d\u6587\u67e5\u5b57\u5178\u7684\u4f8b\u5b50\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5b57\u5178\u4e2d\u7684\u6240\u6709\u5b57\u6309\u7167\u62fc\u97f3\u987a\u5e8f\u5b58\u50a8\u5728\u6570\u7ec4\u4e2d\uff0c\u7136\u540e\u4f7f\u7528\u4e0e\u65e5\u5e38\u67e5\u7eb8\u8d28\u5b57\u5178\u76f8\u540c\u7684\u201c\u7ffb\u5f00\u4e2d\u95f4\uff0c\u6392\u9664\u4e00\u534a\u201d\u7684\u65b9\u5f0f\uff0c\u6765\u5b9e\u73b0\u4e00\u4e2a\u67e5\u7535\u5b50\u5b57\u5178\u7684\u7b97\u6cd5\u3002

    \u6df1\u5ea6\u5b66\u4e60\u3002\u795e\u7ecf\u7f51\u7edc\u4e2d\u5927\u91cf\u4f7f\u7528\u4e86\u5411\u91cf\u3001\u77e9\u9635\u3001\u5f20\u91cf\u4e4b\u95f4\u7684\u7ebf\u6027\u4ee3\u6570\u8fd0\u7b97\uff0c\u8fd9\u4e9b\u6570\u636e\u90fd\u662f\u4ee5\u6570\u7ec4\u7684\u5f62\u5f0f\u6784\u5efa\u7684\u3002\u6570\u7ec4\u662f\u795e\u7ecf\u7f51\u7edc\u7f16\u7a0b\u4e2d\u6700\u5e38\u4f7f\u7528\u7684\u6570\u636e\u7ed3\u6784\u3002

    "},{"location":"chapter_array_and_linkedlist/linked_list/","title":"4.2. \u00a0 \u94fe\u8868","text":"

    \u5185\u5b58\u7a7a\u95f4\u662f\u6240\u6709\u7a0b\u5e8f\u7684\u516c\u5171\u8d44\u6e90\uff0c\u6392\u9664\u5df2\u88ab\u5360\u7528\u7684\u5185\u5b58\u7a7a\u95f4\uff0c\u7a7a\u95f2\u5185\u5b58\u7a7a\u95f4\u901a\u5e38\u6563\u843d\u5728\u5185\u5b58\u5404\u5904\u3002\u5728\u4e0a\u4e00\u8282\u4e2d\uff0c\u6211\u4eec\u63d0\u5230\u5b58\u50a8\u6570\u7ec4\u7684\u5185\u5b58\u7a7a\u95f4\u5fc5\u987b\u662f\u8fde\u7eed\u7684\uff0c\u800c\u5f53\u6211\u4eec\u9700\u8981\u7533\u8bf7\u4e00\u4e2a\u975e\u5e38\u5927\u7684\u6570\u7ec4\u65f6\uff0c\u7a7a\u95f2\u5185\u5b58\u4e2d\u53ef\u80fd\u6ca1\u6709\u8fd9\u4e48\u5927\u7684\u8fde\u7eed\u7a7a\u95f4\u3002\u4e0e\u6570\u7ec4\u76f8\u6bd4\uff0c\u94fe\u8868\u66f4\u5177\u7075\u6d3b\u6027\uff0c\u5b83\u53ef\u4ee5\u88ab\u5b58\u50a8\u5728\u975e\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\u3002

    \u300c\u94fe\u8868 Linked List\u300d\u662f\u4e00\u79cd\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u5176\u6bcf\u4e2a\u5143\u7d20\u90fd\u662f\u4e00\u4e2a\u8282\u70b9\u5bf9\u8c61\uff0c\u5404\u4e2a\u8282\u70b9\u4e4b\u95f4\u901a\u8fc7\u6307\u9488\u8fde\u63a5\uff0c\u4ece\u5f53\u524d\u8282\u70b9\u901a\u8fc7\u6307\u9488\u53ef\u4ee5\u8bbf\u95ee\u5230\u4e0b\u4e00\u4e2a\u8282\u70b9\u3002\u7531\u4e8e\u6307\u9488\u8bb0\u5f55\u4e86\u4e0b\u4e2a\u8282\u70b9\u7684\u5185\u5b58\u5730\u5740\uff0c\u56e0\u6b64\u65e0\u9700\u4fdd\u8bc1\u5185\u5b58\u5730\u5740\u7684\u8fde\u7eed\u6027\uff0c\u4ece\u800c\u53ef\u4ee5\u5c06\u5404\u4e2a\u8282\u70b9\u5206\u6563\u5b58\u50a8\u5728\u5185\u5b58\u5404\u5904\u3002

    \u94fe\u8868\u300c\u8282\u70b9 Node\u300d\u5305\u542b\u4e24\u9879\u6570\u636e\uff0c\u4e00\u662f\u8282\u70b9\u300c\u503c Value\u300d\uff0c\u4e8c\u662f\u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u300c\u6307\u9488 Pointer\u300d\uff0c\u6216\u79f0\u300c\u5f15\u7528 Reference\u300d\u3002

    Fig. \u94fe\u8868\u5b9a\u4e49\u4e0e\u5b58\u50a8\u65b9\u5f0f

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nint val;        // \u8282\u70b9\u503c\nListNode next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(int x) { val = x; }  // \u6784\u9020\u51fd\u6570\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\nint val;         // \u8282\u70b9\u503c\nListNode *next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(int x) : val(x), next(nullptr) {}  // \u6784\u9020\u51fd\u6570\n};\n
    class ListNode:\n\"\"\"\u94fe\u8868\u8282\u70b9\u7c7b\"\"\"\ndef __init__(self, val: int):\nself.val: int = val                  # \u8282\u70b9\u503c\nself.next: Optional[ListNode] = None # \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype ListNode struct {\nVal  int       // \u8282\u70b9\u503c\nNext *ListNode // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n}\n// NewListNode \u6784\u9020\u51fd\u6570\uff0c\u521b\u5efa\u4e00\u4e2a\u65b0\u7684\u94fe\u8868\nfunc NewListNode(val int) *ListNode {\nreturn &ListNode{\nVal:  val,\nNext: nil,\n}\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nval;\nnext;\nconstructor(val, next) {\nthis.val = (val === undefined ? 0 : val);       // \u8282\u70b9\u503c\nthis.next = (next === undefined ? null : next); // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n}\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nval: number;\nnext: ListNode | null;\nconstructor(val?: number, next?: ListNode | null) {\nthis.val = val === undefined ? 0 : val;        // \u8282\u70b9\u503c\nthis.next = next === undefined ? null : next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n}\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\nint val;               // \u8282\u70b9\u503c\nstruct ListNode *next; // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n};\ntypedef struct ListNode ListNode;\n/* \u6784\u9020\u51fd\u6570 */\nListNode *newListNode(int val) {\nListNode *node, *next;\nnode = (ListNode *) malloc(sizeof(ListNode));\nnode->val = val;\nnode->next = NULL;\nreturn node;\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode\n{\nint val;         // \u8282\u70b9\u503c\nListNode next;   // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\nListNode(int x) => val = x;  //\u6784\u9020\u51fd\u6570\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nvar val: Int // \u8282\u70b9\u503c\nvar next: ListNode? // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\ninit(x: Int) { // \u6784\u9020\u51fd\u6570\nval = x\n}\n}\n
    // \u94fe\u8868\u8282\u70b9\u7c7b\npub fn ListNode(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nval: T = 0, // \u8282\u70b9\u503c\nnext: ?*Self = null, // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n// \u6784\u9020\u51fd\u6570\npub fn init(self: *Self, x: i32) void {\nself.val = x;\nself.next = null;\n}\n};\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nint val; // \u8282\u70b9\u503c\nListNode? next; // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(this.val, [this.next]); // \u6784\u9020\u51fd\u6570\n}\n

    \u5c3e\u8282\u70b9\u6307\u5411\u4ec0\u4e48\uff1f

    \u6211\u4eec\u5c06\u94fe\u8868\u7684\u6700\u540e\u4e00\u4e2a\u8282\u70b9\u79f0\u4e3a\u300c\u5c3e\u8282\u70b9\u300d\uff0c\u5176\u6307\u5411\u7684\u662f\u201c\u7a7a\u201d\uff0c\u5728 Java, C++, Python \u4e2d\u5206\u522b\u8bb0\u4e3a \\(\\text{null}\\) , \\(\\text{nullptr}\\) , \\(\\text{None}\\) \u3002\u5728\u4e0d\u5f15\u8d77\u6b67\u4e49\u7684\u524d\u63d0\u4e0b\uff0c\u672c\u4e66\u90fd\u4f7f\u7528 \\(\\text{None}\\) \u6765\u8868\u793a\u7a7a\u3002

    \u5982\u4f55\u79f0\u547c\u94fe\u8868\uff1f

    \u5728\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u6570\u7ec4\u6574\u4f53\u5c31\u662f\u4e00\u4e2a\u53d8\u91cf\uff0c\u4f8b\u5982\u6570\u7ec4 nums \uff0c\u5305\u542b\u5404\u4e2a\u5143\u7d20 nums[0] , nums[1] \u7b49\u7b49\u3002\u800c\u94fe\u8868\u662f\u7531\u591a\u4e2a\u8282\u70b9\u5bf9\u8c61\u7ec4\u6210\uff0c\u6211\u4eec\u901a\u5e38\u5c06\u5934\u8282\u70b9\u5f53\u4f5c\u94fe\u8868\u7684\u4ee3\u79f0\uff0c\u4f8b\u5982\u5934\u8282\u70b9 head \u548c\u94fe\u8868 head \u5b9e\u9645\u4e0a\u662f\u540c\u4e49\u7684\u3002

    \u94fe\u8868\u521d\u59cb\u5316\u65b9\u6cd5\u3002\u5efa\u7acb\u94fe\u8868\u5206\u4e3a\u4e24\u6b65\uff0c\u7b2c\u4e00\u6b65\u662f\u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\u5bf9\u8c61\uff0c\u7b2c\u4e8c\u6b65\u662f\u6784\u5efa\u5f15\u7528\u6307\u5411\u5173\u7cfb\u3002\u5b8c\u6210\u540e\uff0c\u5373\u53ef\u4ee5\u4ece\u94fe\u8868\u7684\u5934\u8282\u70b9\uff08\u5373\u9996\u4e2a\u8282\u70b9\uff09\u51fa\u53d1\uff0c\u901a\u8fc7\u6307\u9488 next \u4f9d\u6b21\u8bbf\u95ee\u6240\u6709\u8282\u70b9\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linked_list.java
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.cpp
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nListNode* n0 = new ListNode(1);\nListNode* n1 = new ListNode(3);\nListNode* n2 = new ListNode(2);\nListNode* n3 = new ListNode(5);\nListNode* n4 = new ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    linked_list.py
    # \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4\n# \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n
    linked_list.go
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n
    linked_list.js
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.ts
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.c
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    linked_list.cs
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.swift
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nlet n0 = ListNode(x: 1)\nlet n1 = ListNode(x: 3)\nlet n2 = ListNode(x: 2)\nlet n3 = ListNode(x: 5)\nlet n4 = ListNode(x: 4)\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n
    linked_list.zig
    // \u521d\u59cb\u5316\u94fe\u8868\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nvar n0 = inc.ListNode(i32){.val = 1};\nvar n1 = inc.ListNode(i32){.val = 3};\nvar n2 = inc.ListNode(i32){.val = 2};\nvar n3 = inc.ListNode(i32){.val = 5};\nvar n4 = inc.ListNode(i32){.val = 4};\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = &n1;\nn1.next = &n2;\nn2.next = &n3;\nn3.next = &n4;\n
    linked_list.dart
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\\\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    "},{"location":"chapter_array_and_linkedlist/linked_list/#421","title":"4.2.1. \u00a0 \u94fe\u8868\u4f18\u70b9","text":"

    \u94fe\u8868\u4e2d\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u7684\u64cd\u4f5c\u6548\u7387\u9ad8\u3002\u4f8b\u5982\uff0c\u5982\u679c\u6211\u4eec\u60f3\u5728\u94fe\u8868\u4e2d\u95f4\u7684\u4e24\u4e2a\u8282\u70b9 A , B \u4e4b\u95f4\u63d2\u5165\u4e00\u4e2a\u65b0\u8282\u70b9 P \uff0c\u6211\u4eec\u53ea\u9700\u8981\u6539\u53d8\u4e24\u4e2a\u8282\u70b9\u6307\u9488\u5373\u53ef\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \uff1b\u76f8\u6bd4\u4e4b\u4e0b\uff0c\u6570\u7ec4\u7684\u63d2\u5165\u64cd\u4f5c\u6548\u7387\u8981\u4f4e\u5f97\u591a\u3002

    Fig. \u94fe\u8868\u63d2\u5165\u8282\u70b9

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linked_list.java
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode n0, ListNode P) {\nListNode n1 = n0.next;\nP.next = n1;\nn0.next = P;\n}\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode *n0, ListNode *P) {\nListNode *n1 = n0->next;\nP->next = n1;\nn0->next = P;\n}\n
    linked_list.py
    def insert(n0: ListNode, P: ListNode) -> None:\n\"\"\"\u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P\"\"\"\nn1 = n0.next\nP.next = n1\nn0.next = P\n
    linked_list.go
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunc insertNode(n0 *ListNode, P *ListNode) {\nn1 := n0.Next\nP.Next = n1\nn0.Next = P\n}\n
    linked_list.js
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunction insert(n0, P) {\nconst n1 = n0.next;\nP.next = n1;\nn0.next = P;\n}\n
    linked_list.ts
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunction insert(n0: ListNode, P: ListNode): void {\nconst n1 = n0.next;\nP.next = n1;\nn0.next = P;\n}\n
    linked_list.c
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode *n0, ListNode *P) {\nListNode *n1 = n0->next;\nP->next = n1;\nn0->next = P;\n}\n
    linked_list.cs
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode n0, ListNode P) {\nListNode? n1 = n0.next;\nP.next = n1;\nn0.next = P;\n}\n
    linked_list.swift
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunc insert(n0: ListNode, P: ListNode) {\nlet n1 = n0.next\nP.next = n1\nn0.next = P\n}\n
    linked_list.zig
    // \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P\nfn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {\nvar n1 = n0.?.next;\nP.?.next = n1;\nn0.?.next = P;\n}\n
    linked_list.dart
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode n0, ListNode P) {\nListNode? n1 = n0.next;\nP.next = n1;\nn0.next = P;\n}\n

    \u5728\u94fe\u8868\u4e2d\u5220\u9664\u8282\u70b9\u4e5f\u975e\u5e38\u65b9\u4fbf\uff0c\u53ea\u9700\u6539\u53d8\u4e00\u4e2a\u8282\u70b9\u7684\u6307\u9488\u5373\u53ef\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5c3d\u7ba1\u5728\u5220\u9664\u64cd\u4f5c\u5b8c\u6210\u540e\uff0c\u8282\u70b9 P \u4ecd\u7136\u6307\u5411 n1 \uff0c\u4f46\u5b9e\u9645\u4e0a P \u5df2\u7ecf\u4e0d\u518d\u5c5e\u4e8e\u6b64\u94fe\u8868\uff0c\u56e0\u4e3a\u904d\u5386\u6b64\u94fe\u8868\u65f6\u65e0\u6cd5\u8bbf\u95ee\u5230 P \u3002

    Fig. \u94fe\u8868\u5220\u9664\u8282\u70b9

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linked_list.java
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode n0) {\nif (n0.next == null)\nreturn;\n// n0 -> P -> n1\nListNode P = n0.next;\nListNode n1 = P.next;\nn0.next = n1;\n}\n
    linked_list.cpp
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode *n0) {\nif (n0->next == nullptr)\nreturn;\n// n0 -> P -> n1\nListNode *P = n0->next;\nListNode *n1 = P->next;\nn0->next = n1;\n// \u91ca\u653e\u5185\u5b58\ndelete P;\n}\n
    linked_list.py
    def remove(n0: ListNode) -> None:\n\"\"\"\u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9\"\"\"\nif not n0.next:\nreturn\n# n0 -> P -> n1\nP = n0.next\nn1 = P.next\nn0.next = n1\n
    linked_list.go
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunc removeNode(n0 *ListNode) {\nif n0.Next == nil {\nreturn\n}\n// n0 -> P -> n1\nP := n0.Next\nn1 := P.Next\nn0.Next = n1\n}\n
    linked_list.js
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunction remove(n0) {\nif (!n0.next) return;\n// n0 -> P -> n1\nconst P = n0.next;\nconst n1 = P.next;\nn0.next = n1;\n}\n
    linked_list.ts
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunction remove(n0: ListNode): void {\nif (!n0.next) {\nreturn;\n}\n// n0 -> P -> n1\nconst P = n0.next;\nconst n1 = P.next;\nn0.next = n1;\n}\n
    linked_list.c
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\n// \u6ce8\u610f\uff1astdio.h \u5360\u7528\u4e86 remove \u5173\u952e\u8bcd\nvoid removeNode(ListNode *n0) {\nif (!n0->next)\nreturn;\n// n0 -> P -> n1\nListNode *P = n0->next;\nListNode *n1 = P->next;\nn0->next = n1;\n// \u91ca\u653e\u5185\u5b58\nfree(P);\n}\n
    linked_list.cs
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode n0) {\nif (n0.next == null)\nreturn;\n// n0 -> P -> n1\nListNode P = n0.next;\nListNode? n1 = P.next;\nn0.next = n1;\n}\n
    linked_list.swift
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunc remove(n0: ListNode) {\nif n0.next == nil {\nreturn\n}\n// n0 -> P -> n1\nlet P = n0.next\nlet n1 = P?.next\nn0.next = n1\nP?.next = nil\n}\n
    linked_list.zig
    // \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9\nfn remove(n0: ?*inc.ListNode(i32)) void {\nif (n0.?.next == null) return;\n// n0 -> P -> n1\nvar P = n0.?.next;\nvar n1 = P.?.next;\nn0.?.next = n1;\n}\n
    linked_list.dart
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode n0) {\nif (n0.next == null) return;\n// n0 -> P -> n1\nListNode P = n0.next!;\nListNode? n1 = P.next;\nn0.next = n1;\n}\n
    "},{"location":"chapter_array_and_linkedlist/linked_list/#422","title":"4.2.2. \u00a0 \u94fe\u8868\u7f3a\u70b9","text":"

    \u94fe\u8868\u8bbf\u95ee\u8282\u70b9\u6548\u7387\u8f83\u4f4e\u3002\u5982\u4e0a\u8282\u6240\u8ff0\uff0c\u6570\u7ec4\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u4e0b\u8bbf\u95ee\u4efb\u610f\u5143\u7d20\u3002\u7136\u800c\uff0c\u94fe\u8868\u65e0\u6cd5\u76f4\u63a5\u8bbf\u95ee\u4efb\u610f\u8282\u70b9\uff0c\u8fd9\u662f\u56e0\u4e3a\u7cfb\u7edf\u9700\u8981\u4ece\u5934\u8282\u70b9\u51fa\u53d1\uff0c\u9010\u4e2a\u5411\u540e\u904d\u5386\u76f4\u81f3\u627e\u5230\u76ee\u6807\u8282\u70b9\u3002\u4f8b\u5982\uff0c\u82e5\u8981\u8bbf\u95ee\u94fe\u8868\u7d22\u5f15\u4e3a index\uff08\u5373\u7b2c index + 1 \u4e2a\uff09\u7684\u8282\u70b9\uff0c\u5219\u9700\u8981\u5411\u540e\u904d\u5386 index \u8f6e\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linked_list.java
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode access(ListNode head, int index) {\nfor (int i = 0; i < index; i++) {\nif (head == null)\nreturn null;\nhead = head.next;\n}\nreturn head;\n}\n
    linked_list.cpp
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\nfor (int i = 0; i < index; i++) {\nif (head == nullptr)\nreturn nullptr;\nhead = head->next;\n}\nreturn head;\n}\n
    linked_list.py
    def access(head: ListNode, index: int) -> ListNode | None:\n\"\"\"\u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9\"\"\"\nfor _ in range(index):\nif not head:\nreturn None\nhead = head.next\nreturn head\n
    linked_list.go
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunc access(head *ListNode, index int) *ListNode {\nfor i := 0; i < index; i++ {\nif head == nil {\nreturn nil\n}\nhead = head.Next\n}\nreturn head\n}\n
    linked_list.js
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunction access(head, index) {\nfor (let i = 0; i < index; i++) {\nif (!head) {\nreturn null;\n}\nhead = head.next;\n}\nreturn head;\n}\n
    linked_list.ts
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunction access(head: ListNode | null, index: number): ListNode | null {\nfor (let i = 0; i < index; i++) {\nif (!head) {\nreturn null;\n}\nhead = head.next;\n}\nreturn head;\n}\n
    linked_list.c
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\nwhile (head && head->next && index) {\nhead = head->next;\nindex--;\n}\nreturn head;\n}\n
    linked_list.cs
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? access(ListNode head, int index) {\nfor (int i = 0; i < index; i++) {\nif (head == null)\nreturn null;\nhead = head.next;\n}\nreturn head;\n}\n
    linked_list.swift
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunc access(head: ListNode, index: Int) -> ListNode? {\nvar head: ListNode? = head\nfor _ in 0 ..< index {\nif head == nil {\nreturn nil\n}\nhead = head?.next\n}\nreturn head\n}\n
    linked_list.zig
    // \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9\nfn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {\nvar head = node;\nvar i: i32 = 0;\nwhile (i < index) : (i += 1) {\nhead = head.?.next;\nif (head == null) return null;\n}\nreturn head;\n}\n
    linked_list.dart
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? access(ListNode? head, int index) {\nfor (var i = 0; i < index; i++) {\nif (head == null) return null;\nhead = head.next;\n}\nreturn head;\n}\n

    \u94fe\u8868\u7684\u5185\u5b58\u5360\u7528\u8f83\u5927\u3002\u94fe\u8868\u4ee5\u8282\u70b9\u4e3a\u5355\u4f4d\uff0c\u6bcf\u4e2a\u8282\u70b9\u9664\u4e86\u4fdd\u5b58\u503c\u4e4b\u5916\uff0c\u8fd8\u9700\u989d\u5916\u4fdd\u5b58\u6307\u9488\uff08\u5f15\u7528\uff09\u3002\u8fd9\u610f\u5473\u7740\u5728\u76f8\u540c\u6570\u636e\u91cf\u7684\u60c5\u51b5\u4e0b\uff0c\u94fe\u8868\u6bd4\u6570\u7ec4\u9700\u8981\u5360\u7528\u66f4\u591a\u7684\u5185\u5b58\u7a7a\u95f4\u3002

    "},{"location":"chapter_array_and_linkedlist/linked_list/#423","title":"4.2.3. \u00a0 \u94fe\u8868\u5e38\u7528\u64cd\u4f5c","text":"

    \u904d\u5386\u94fe\u8868\u67e5\u627e\u3002\u904d\u5386\u94fe\u8868\uff0c\u67e5\u627e\u94fe\u8868\u5185\u503c\u4e3a target \u7684\u8282\u70b9\uff0c\u8f93\u51fa\u8282\u70b9\u5728\u94fe\u8868\u4e2d\u7684\u7d22\u5f15\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linked_list.java
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode head, int target) {\nint index = 0;\nwhile (head != null) {\nif (head.val == target)\nreturn index;\nhead = head.next;\nindex++;\n}\nreturn -1;\n}\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode *head, int target) {\nint index = 0;\nwhile (head != nullptr) {\nif (head->val == target)\nreturn index;\nhead = head->next;\nindex++;\n}\nreturn -1;\n}\n
    linked_list.py
    def find(head: ListNode, target: int) -> int:\n\"\"\"\u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9\"\"\"\nindex = 0\nwhile head:\nif head.val == target:\nreturn index\nhead = head.next\nindex += 1\nreturn -1\n
    linked_list.go
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunc findNode(head *ListNode, target int) int {\nindex := 0\nfor head != nil {\nif head.Val == target {\nreturn index\n}\nhead = head.Next\nindex++\n}\nreturn -1\n}\n
    linked_list.js
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunction find(head, target) {\nlet index = 0;\nwhile (head !== null) {\nif (head.val === target) {\nreturn index;\n}\nhead = head.next;\nindex += 1;\n}\nreturn -1;\n}\n
    linked_list.ts
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunction find(head: ListNode | null, target: number): number {\nlet index = 0;\nwhile (head !== null) {\nif (head.val === target) {\nreturn index;\n}\nhead = head.next;\nindex += 1;\n}\nreturn -1;\n}\n
    linked_list.c
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode *head, int target) {\nint index = 0;\nwhile (head) {\nif (head->val == target)\nreturn index;\nhead = head->next;\nindex++;\n}\nreturn -1;\n}\n
    linked_list.cs
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode head, int target) {\nint index = 0;\nwhile (head != null) {\nif (head.val == target)\nreturn index;\nhead = head.next;\nindex++;\n}\nreturn -1;\n}\n
    linked_list.swift
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunc find(head: ListNode, target: Int) -> Int {\nvar head: ListNode? = head\nvar index = 0\nwhile head != nil {\nif head?.val == target {\nreturn index\n}\nhead = head?.next\nindex += 1\n}\nreturn -1\n}\n
    linked_list.zig
    // \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9\nfn find(node: ?*inc.ListNode(i32), target: i32) i32 {\nvar head = node;\nvar index: i32 = 0;\nwhile (head != null) {\nif (head.?.val == target) return index;\nhead = head.?.next;\nindex += 1;\n}\nreturn -1;\n}\n
    linked_list.dart
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode? head, int target) {\nint index = 0;\nwhile (head != null) {\nif (head.val == target) {\nreturn index;\n}\nhead = head.next;\nindex++;\n}\nreturn -1;\n}\n
    "},{"location":"chapter_array_and_linkedlist/linked_list/#424","title":"4.2.4. \u00a0 \u5e38\u89c1\u94fe\u8868\u7c7b\u578b","text":"

    \u5355\u5411\u94fe\u8868\u3002\u5373\u4e0a\u8ff0\u4ecb\u7ecd\u7684\u666e\u901a\u94fe\u8868\u3002\u5355\u5411\u94fe\u8868\u7684\u8282\u70b9\u5305\u542b\u503c\u548c\u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\u4e24\u9879\u6570\u636e\u3002\u6211\u4eec\u5c06\u9996\u4e2a\u8282\u70b9\u79f0\u4e3a\u5934\u8282\u70b9\uff0c\u5c06\u6700\u540e\u4e00\u4e2a\u8282\u70b9\u6210\u4e3a\u5c3e\u8282\u70b9\uff0c\u5c3e\u8282\u70b9\u6307\u5411\u7a7a \\(\\text{None}\\) \u3002

    \u73af\u5f62\u94fe\u8868\u3002\u5982\u679c\u6211\u4eec\u4ee4\u5355\u5411\u94fe\u8868\u7684\u5c3e\u8282\u70b9\u6307\u5411\u5934\u8282\u70b9\uff08\u5373\u9996\u5c3e\u76f8\u63a5\uff09\uff0c\u5219\u5f97\u5230\u4e00\u4e2a\u73af\u5f62\u94fe\u8868\u3002\u5728\u73af\u5f62\u94fe\u8868\u4e2d\uff0c\u4efb\u610f\u8282\u70b9\u90fd\u53ef\u4ee5\u89c6\u4f5c\u5934\u8282\u70b9\u3002

    \u53cc\u5411\u94fe\u8868\u3002\u4e0e\u5355\u5411\u94fe\u8868\u76f8\u6bd4\uff0c\u53cc\u5411\u94fe\u8868\u8bb0\u5f55\u4e86\u4e24\u4e2a\u65b9\u5411\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\u3002\u53cc\u5411\u94fe\u8868\u7684\u8282\u70b9\u5b9a\u4e49\u540c\u65f6\u5305\u542b\u6307\u5411\u540e\u7ee7\u8282\u70b9\uff08\u4e0b\u4e00\u8282\u70b9\uff09\u548c\u524d\u9a71\u8282\u70b9\uff08\u4e0a\u4e00\u8282\u70b9\uff09\u7684\u6307\u9488\u3002\u76f8\u8f83\u4e8e\u5355\u5411\u94fe\u8868\uff0c\u53cc\u5411\u94fe\u8868\u66f4\u5177\u7075\u6d3b\u6027\uff0c\u53ef\u4ee5\u671d\u4e24\u4e2a\u65b9\u5411\u904d\u5386\u94fe\u8868\uff0c\u4f46\u76f8\u5e94\u5730\u4e5f\u9700\u8981\u5360\u7528\u66f4\u591a\u7684\u5185\u5b58\u7a7a\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nint val;        // \u8282\u70b9\u503c\nListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(int x) { val = x; }  // \u6784\u9020\u51fd\u6570\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\nint val;         // \u8282\u70b9\u503c\nListNode *next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode *prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // \u6784\u9020\u51fd\u6570\n};\n
    class ListNode:\n\"\"\"\u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\"\"\"\ndef __init__(self, val: int):\nself.val: int = val                   # \u8282\u70b9\u503c\nself.next: Optional[ListNode] = None  # \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nself.prev: Optional[ListNode] = None  # \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype DoublyListNode struct {\nVal  int             // \u8282\u70b9\u503c\nNext *DoublyListNode // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nPrev *DoublyListNode // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n}\n// NewDoublyListNode \u521d\u59cb\u5316\nfunc NewDoublyListNode(val int) *DoublyListNode {\nreturn &DoublyListNode{\nVal:  val,\nNext: nil,\nPrev: nil,\n}\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nval;\nnext;\nprev;\nconstructor(val, next, prev) {\nthis.val = val  ===  undefined ? 0 : val;        // \u8282\u70b9\u503c\nthis.next = next  ===  undefined ? null : next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nthis.prev = prev  ===  undefined ? null : prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n}\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nval: number;\nnext: ListNode | null;\nprev: ListNode | null;\nconstructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\nthis.val = val  ===  undefined ? 0 : val;        // \u8282\u70b9\u503c\nthis.next = next  ===  undefined ? null : next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nthis.prev = prev  ===  undefined ? null : prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n}\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\nint val;               // \u8282\u70b9\u503c\nstruct ListNode *next; // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nstruct ListNode *prev; // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n};\ntypedef struct ListNode ListNode;\n/* \u6784\u9020\u51fd\u6570 */\nListNode *newListNode(int val) {\nListNode *node, *next;\nnode = (ListNode *) malloc(sizeof(ListNode));\nnode->val = val;\nnode->next = NULL;\nnode->prev = NULL;\nreturn node;\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nint val;        // \u8282\u70b9\u503c\nListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(int x) => val = x;  // \u6784\u9020\u51fd\u6570\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nvar val: Int // \u8282\u70b9\u503c\nvar next: ListNode? // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nvar prev: ListNode? // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\ninit(x: Int) { // \u6784\u9020\u51fd\u6570\nval = x\n}\n}\n
    // \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\npub fn ListNode(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nval: T = 0, // \u8282\u70b9\u503c\nnext: ?*Self = null, // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nprev: ?*Self = null, // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n// \u6784\u9020\u51fd\u6570\npub fn init(self: *Self, x: i32) void {\nself.val = x;\nself.next = null;\nself.prev = null;\n}\n};\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nint val;        // \u8282\u70b9\u503c\nListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(this.val, [this.next, this.prev]);  // \u6784\u9020\u51fd\u6570\n}\n

    Fig. \u5e38\u89c1\u94fe\u8868\u79cd\u7c7b

    "},{"location":"chapter_array_and_linkedlist/list/","title":"4.3. \u00a0 \u5217\u8868","text":"

    \u6570\u7ec4\u957f\u5ea6\u4e0d\u53ef\u53d8\u5bfc\u81f4\u5b9e\u7528\u6027\u964d\u4f4e\u3002\u5728\u8bb8\u591a\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u4e8b\u5148\u65e0\u6cd5\u786e\u5b9a\u9700\u8981\u5b58\u50a8\u591a\u5c11\u6570\u636e\uff0c\u8fd9\u4f7f\u6570\u7ec4\u957f\u5ea6\u7684\u9009\u62e9\u53d8\u5f97\u56f0\u96be\u3002\u82e5\u957f\u5ea6\u8fc7\u5c0f\uff0c\u9700\u8981\u5728\u6301\u7eed\u6dfb\u52a0\u6570\u636e\u65f6\u9891\u7e41\u6269\u5bb9\u6570\u7ec4\uff1b\u82e5\u957f\u5ea6\u8fc7\u5927\uff0c\u5219\u4f1a\u9020\u6210\u5185\u5b58\u7a7a\u95f4\u7684\u6d6a\u8d39\u3002

    \u4e3a\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u51fa\u73b0\u4e86\u4e00\u79cd\u88ab\u79f0\u4e3a\u300c\u52a8\u6001\u6570\u7ec4 Dynamic Array\u300d\u7684\u6570\u636e\u7ed3\u6784\uff0c\u5373\u957f\u5ea6\u53ef\u53d8\u7684\u6570\u7ec4\uff0c\u4e5f\u5e38\u88ab\u79f0\u4e3a\u300c\u5217\u8868 List\u300d\u3002\u5217\u8868\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\uff0c\u7ee7\u627f\u4e86\u6570\u7ec4\u7684\u4f18\u70b9\uff0c\u5e76\u4e14\u53ef\u4ee5\u5728\u7a0b\u5e8f\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u52a8\u6001\u6269\u5bb9\u3002\u5728\u5217\u8868\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u81ea\u7531\u6dfb\u52a0\u5143\u7d20\uff0c\u800c\u65e0\u9700\u62c5\u5fc3\u8d85\u8fc7\u5bb9\u91cf\u9650\u5236\u3002

    "},{"location":"chapter_array_and_linkedlist/list/#431","title":"4.3.1. \u00a0 \u5217\u8868\u5e38\u7528\u64cd\u4f5c","text":"

    \u521d\u59cb\u5316\u5217\u8868\u3002\u901a\u5e38\u6211\u4eec\u4f1a\u4f7f\u7528\u201c\u65e0\u521d\u59cb\u503c\u201d\u548c\u201c\u6709\u521d\u59cb\u503c\u201d\u7684\u4e24\u79cd\u521d\u59cb\u5316\u65b9\u6cd5\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<Integer> list1 = new ArrayList<>();\n// \u6709\u521d\u59cb\u503c\uff08\u6ce8\u610f\u6570\u7ec4\u7684\u5143\u7d20\u7c7b\u578b\u9700\u4e3a int[] \u7684\u5305\u88c5\u7c7b Integer[]\uff09\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList<Integer> list = new ArrayList<>(Arrays.asList(numbers));\n
    list.cpp
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u9700\u6ce8\u610f\uff0cC++ \u4e2d vector \u5373\u662f\u672c\u6587\u63cf\u8ff0\u7684 list\n// \u65e0\u521d\u59cb\u503c\nvector<int> list1;\n// \u6709\u521d\u59cb\u503c\nvector<int> list = { 1, 3, 2, 5, 4 };\n
    list.py
    # \u521d\u59cb\u5316\u5217\u8868\n# \u65e0\u521d\u59cb\u503c\nlist1: List[int] = []\n# \u6709\u521d\u59cb\u503c\nlist: List[int] = [1, 3, 2, 5, 4]\n
    list_test.go
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nlist1 := []int\n// \u6709\u521d\u59cb\u503c\nlist := []int{1, 3, 2, 5, 4}\n
    list.js
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nconst list1 = [];\n// \u6709\u521d\u59cb\u503c\nconst list = [1, 3, 2, 5, 4];\n
    list.ts
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nconst list1: number[] = [];\n// \u6709\u521d\u59cb\u503c\nconst list: number[] = [1, 3, 2, 5, 4];\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<int> list1 = new ();\n// \u6709\u521d\u59cb\u503c\nint[] numbers = new int[] { 1, 3, 2, 5, 4 };\nList<int> list = numbers.ToList();\n
    list.swift
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nlet list1: [Int] = []\n// \u6709\u521d\u59cb\u503c\nvar list = [1, 3, 2, 5, 4]\n
    list.zig
    // \u521d\u59cb\u5316\u5217\u8868\nvar list = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer list.deinit();\ntry list.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });\n
    list.dart
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<int> list1 = [];\n// \u6709\u521d\u59cb\u503c\nList<int> list = [1, 3, 2, 5, 4];\n

    \u8bbf\u95ee\u4e0e\u66f4\u65b0\u5143\u7d20\u3002\u7531\u4e8e\u5217\u8868\u7684\u5e95\u5c42\u6570\u636e\u7ed3\u6784\u662f\u6570\u7ec4\uff0c\u56e0\u6b64\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u8bbf\u95ee\u548c\u66f4\u65b0\u5143\u7d20\uff0c\u6548\u7387\u5f88\u9ad8\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = list.get(1);  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist.set(1, 0);  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.cpp
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = list[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.py
    # \u8bbf\u95ee\u5143\u7d20\nnum: int = list[1]  # \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n# \u66f4\u65b0\u5143\u7d20\nlist[1] = 0    # \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list_test.go
    /* \u8bbf\u95ee\u5143\u7d20 */\nnum := list[1]  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0     // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.js
    /* \u8bbf\u95ee\u5143\u7d20 */\nconst num = list[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.ts
    /* \u8bbf\u95ee\u5143\u7d20 */\nconst num: number = list[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = list[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.swift
    /* \u8bbf\u95ee\u5143\u7d20 */\nlet num = list[1] // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0 // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.zig
    // \u8bbf\u95ee\u5143\u7d20\nvar num = list.items[1]; // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n// \u66f4\u65b0\u5143\u7d20\nlist.items[1] = 0; // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0  \n
    list.dart
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = list[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n

    \u5728\u5217\u8868\u4e2d\u6dfb\u52a0\u3001\u63d2\u5165\u3001\u5220\u9664\u5143\u7d20\u3002\u76f8\u8f83\u4e8e\u6570\u7ec4\uff0c\u5217\u8868\u53ef\u4ee5\u81ea\u7531\u5730\u6dfb\u52a0\u4e0e\u5220\u9664\u5143\u7d20\u3002\u5728\u5217\u8868\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \uff0c\u4f46\u63d2\u5165\u548c\u5220\u9664\u5143\u7d20\u7684\u6548\u7387\u4ecd\u4e0e\u6570\u7ec4\u76f8\u540c\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(N)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.clear();\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.add(1);\nlist.add(3);\nlist.add(2);\nlist.add(5);\nlist.add(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.add(3, 6);  // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n/* \u5220\u9664\u5143\u7d20 */\nlist.remove(3);  // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list.cpp
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.clear();\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.push_back(1);\nlist.push_back(3);\nlist.push_back(2);\nlist.push_back(5);\nlist.push_back(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.insert(list.begin() + 3, 6);  // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n/* \u5220\u9664\u5143\u7d20 */\nlist.erase(list.begin() + 3);      // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list.py
    # \u6e05\u7a7a\u5217\u8868\nlist.clear()\n# \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\nlist.append(1)\nlist.append(3)\nlist.append(2)\nlist.append(5)\nlist.append(4)\n# \u4e2d\u95f4\u63d2\u5165\u5143\u7d20\nlist.insert(3, 6)  # \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n# \u5220\u9664\u5143\u7d20\nlist.pop(3)        # \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list_test.go
    /* \u6e05\u7a7a\u5217\u8868 */\nlist = nil\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist = append(list, 1)\nlist = append(list, 3)\nlist = append(list, 2)\nlist = append(list, 5)\nlist = append(list, 4)\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist = append(list[:3], append([]int{6}, list[3:]...)...) // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n/* \u5220\u9664\u5143\u7d20 */\nlist = append(list[:3], list[4:]...) // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list.js
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.length = 0;\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.push(1);\nlist.push(3);\nlist.push(2);\nlist.push(5);\nlist.push(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.splice(3, 0, 6);\n/* \u5220\u9664\u5143\u7d20 */\nlist.splice(3, 1);\n
    list.ts
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.length = 0;\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.push(1);\nlist.push(3);\nlist.push(2);\nlist.push(5);\nlist.push(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.splice(3, 0, 6);\n/* \u5220\u9664\u5143\u7d20 */\nlist.splice(3, 1);\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.Clear();\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.Add(1);\nlist.Add(3);\nlist.Add(2);\nlist.Add(5);\nlist.Add(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.Insert(3, 6);\n/* \u5220\u9664\u5143\u7d20 */\nlist.RemoveAt(3);\n
    list.swift
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.removeAll()\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.append(1)\nlist.append(3)\nlist.append(2)\nlist.append(5)\nlist.append(4)\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.insert(6, at: 3) // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n/* \u5220\u9664\u5143\u7d20 */\nlist.remove(at: 3) // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list.zig
    // \u6e05\u7a7a\u5217\u8868\nlist.clearRetainingCapacity();\n// \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\ntry list.append(1);\ntry list.append(3);\ntry list.append(2);\ntry list.append(5);\ntry list.append(4);\n// \u4e2d\u95f4\u63d2\u5165\u5143\u7d20\ntry list.insert(3, 6); // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n// \u5220\u9664\u5143\u7d20\n_ = list.orderedRemove(3); // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list.dart
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.clear();\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.add(1);\nlist.add(3);\nlist.add(2);\nlist.add(5);\nlist.add(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.insert(3, 6); // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n/* \u5220\u9664\u5143\u7d20 */\nlist.removeAt(3); // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n

    \u904d\u5386\u5217\u8868\u3002\u4e0e\u6570\u7ec4\u4e00\u6837\uff0c\u5217\u8868\u53ef\u4ee5\u6839\u636e\u7d22\u5f15\u904d\u5386\uff0c\u4e5f\u53ef\u4ee5\u76f4\u63a5\u904d\u5386\u5404\u5143\u7d20\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < list.size(); i++) {\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (int n : list) {\ncount++;\n}\n
    list.cpp
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < list.size(); i++) {\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (int n : list) {\ncount++;\n}\n
    list.py
    # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\ncount = 0\nfor i in range(len(list)):\ncount += 1\n# \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\ncount = 0\nfor n in list:\ncount += 1\n
    list_test.go
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\ncount := 0\nfor i := 0; i < len(list); i++ {\ncount++\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0\nfor range list {\ncount++\n}\n
    list.js
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nlet count = 0;\nfor (let i = 0; i < list.length; i++) {\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (const n of list) {\ncount++;\n}\n
    list.ts
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nlet count = 0;\nfor (let i = 0; i < list.length; i++) {\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (const n of list) {\ncount++;\n}\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < list.Count(); i++)\n{\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nforeach (int n in list)\n{\ncount++;\n}\n
    list.swift
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nvar count = 0\nfor _ in list.indices {\ncount += 1\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0\nfor _ in list {\ncount += 1\n}\n
    list.zig
    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\nvar count: i32 = 0;\nvar i: i32 = 0;\nwhile (i < list.items.len) : (i += 1) {\ncount += 1;\n}\n// \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\ncount = 0;\nfor (list.items) |_| {\ncount += 1;\n}\n
    list.dart
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < list.length; i++) {\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (int n in list) {\ncount++;\n}\n

    \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\u3002\u7ed9\u5b9a\u4e00\u4e2a\u65b0\u5217\u8868 list1 \uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u8be5\u5217\u8868\u62fc\u63a5\u5230\u539f\u5217\u8868\u7684\u5c3e\u90e8\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<Integer> list1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nlist.addAll(list1);  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.cpp
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nvector<int> list1 = { 6, 8, 7, 10, 9 };\n// \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\nlist.insert(list.end(), list1.begin(), list1.end());\n
    list.py
    # \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\nlist1: List[int] = [6, 8, 7, 10, 9]\nlist += list1  # \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list_test.go
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nlist1 := []int{6, 8, 7, 10, 9}\nlist = append(list, list1...)  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.js
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nconst list1 = [6, 8, 7, 10, 9];\nlist.push(...list1);  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.ts
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nconst list1: number[] = [6, 8, 7, 10, 9];\nlist.push(...list1);  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<int> list1 = new() { 6, 8, 7, 10, 9 };\nlist.AddRange(list1);  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.swift
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nlet list1 = [6, 8, 7, 10, 9]\nlist.append(contentsOf: list1) // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.zig
    // \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\nvar list1 = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer list1.deinit();\ntry list1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });\ntry list.insertSlice(list.items.len, list1.items); // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.dart
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<int> list1 = [6, 8, 7, 10, 9];\nlist.addAll(list1);  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n

    \u6392\u5e8f\u5217\u8868\u3002\u6392\u5e8f\u4e5f\u662f\u5e38\u7528\u7684\u65b9\u6cd5\u4e4b\u4e00\u3002\u5b8c\u6210\u5217\u8868\u6392\u5e8f\u540e\uff0c\u6211\u4eec\u4fbf\u53ef\u4ee5\u4f7f\u7528\u5728\u6570\u7ec4\u7c7b\u7b97\u6cd5\u9898\u4e2d\u7ecf\u5e38\u8003\u5bdf\u7684\u300c\u4e8c\u5206\u67e5\u627e\u300d\u548c\u300c\u53cc\u6307\u9488\u300d\u7b97\u6cd5\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u6392\u5e8f\u5217\u8868 */\nCollections.sort(list);  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.cpp
    /* \u6392\u5e8f\u5217\u8868 */\nsort(list.begin(), list.end());  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.py
    # \u6392\u5e8f\u5217\u8868\nlist.sort()  # \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list_test.go
    /* \u6392\u5e8f\u5217\u8868 */\nsort.Ints(list)  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.js
    /* \u6392\u5e8f\u5217\u8868 */  list.sort((a, b) => a - b);  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.ts
    /* \u6392\u5e8f\u5217\u8868 */\nlist.sort((a, b) => a - b);  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u6392\u5e8f\u5217\u8868 */\nlist.Sort(); // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.swift
    /* \u6392\u5e8f\u5217\u8868 */\nlist.sort() // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.zig
    // \u6392\u5e8f\u5217\u8868\nstd.sort.sort(i32, list.items, {}, comptime std.sort.asc(i32));\n
    list.dart
    /* \u6392\u5e8f\u5217\u8868 */\nlist.sort(); // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    "},{"location":"chapter_array_and_linkedlist/list/#432","title":"4.3.2. \u00a0 \u5217\u8868\u5b9e\u73b0 *","text":"

    \u4e3a\u4e86\u5e2e\u52a9\u52a0\u6df1\u5bf9\u5217\u8868\u7684\u7406\u89e3\uff0c\u6211\u4eec\u5728\u6b64\u63d0\u4f9b\u4e00\u4e2a\u7b80\u6613\u7248\u5217\u8868\u5b9e\u73b0\u3002\u9700\u8981\u5173\u6ce8\u4e09\u4e2a\u6838\u5fc3\u70b9\uff1a

    • \u521d\u59cb\u5bb9\u91cf\uff1a\u9009\u53d6\u4e00\u4e2a\u5408\u7406\u7684\u6570\u7ec4\u521d\u59cb\u5bb9\u91cf\u3002\u5728\u672c\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u9009\u62e9 10 \u4f5c\u4e3a\u521d\u59cb\u5bb9\u91cf\u3002
    • \u6570\u91cf\u8bb0\u5f55\uff1a\u58f0\u660e\u4e00\u4e2a\u53d8\u91cf size\uff0c\u7528\u4e8e\u8bb0\u5f55\u5217\u8868\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff0c\u5e76\u968f\u7740\u5143\u7d20\u63d2\u5165\u548c\u5220\u9664\u5b9e\u65f6\u66f4\u65b0\u3002\u6839\u636e\u6b64\u53d8\u91cf\uff0c\u6211\u4eec\u53ef\u4ee5\u5b9a\u4f4d\u5217\u8868\u5c3e\u90e8\uff0c\u4ee5\u53ca\u5224\u65ad\u662f\u5426\u9700\u8981\u6269\u5bb9\u3002
    • \u6269\u5bb9\u673a\u5236\uff1a\u63d2\u5165\u5143\u7d20\u65f6\u53ef\u80fd\u8d85\u51fa\u5217\u8868\u5bb9\u91cf\uff0c\u6b64\u65f6\u9700\u8981\u6269\u5bb9\u5217\u8868\u3002\u6269\u5bb9\u65b9\u6cd5\u662f\u6839\u636e\u6269\u5bb9\u500d\u6570\u521b\u5efa\u4e00\u4e2a\u66f4\u5927\u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u5f53\u524d\u6570\u7ec4\u7684\u6240\u6709\u5143\u7d20\u4f9d\u6b21\u79fb\u52a8\u81f3\u65b0\u6570\u7ec4\u3002\u5728\u672c\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u89c4\u5b9a\u6bcf\u6b21\u5c06\u6570\u7ec4\u6269\u5bb9\u81f3\u4e4b\u524d\u7684 2 \u500d\u3002

    \u672c\u793a\u4f8b\u65e8\u5728\u5e2e\u52a9\u8bfb\u8005\u76f4\u89c2\u7406\u89e3\u5217\u8868\u7684\u5de5\u4f5c\u673a\u5236\u3002\u5b9e\u9645\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u5217\u8868\u5b9e\u73b0\u66f4\u52a0\u6807\u51c6\u548c\u590d\u6742\uff0c\u5404\u4e2a\u53c2\u6570\u7684\u8bbe\u5b9a\u4e5f\u975e\u5e38\u6709\u8003\u7a76\uff0c\u4f8b\u5982\u521d\u59cb\u5bb9\u91cf\u3001\u6269\u5bb9\u500d\u6570\u7b49\u3002\u611f\u5174\u8da3\u7684\u8bfb\u8005\u53ef\u4ee5\u67e5\u9605\u6e90\u7801\u8fdb\u884c\u5b66\u4e60\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_list.java
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nprivate int[] nums; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nprivate int capacity = 10; // \u5217\u8868\u5bb9\u91cf\nprivate int size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nprivate int extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\npublic MyList() {\nnums = new int[capacity];\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\npublic int size() {\nreturn size;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\npublic int capacity() {\nreturn capacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\npublic int get(int index) {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 || index >= size)\nthrow new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\nreturn nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\npublic void set(int index, int num) {\nif (index < 0 || index >= size)\nthrow new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\nnums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\npublic void add(int num) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (size == capacity())\nextendCapacity();\nnums[size] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nsize++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\npublic void insert(int index, int num) {\nif (index < 0 || index >= size)\nthrow new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (size == capacity())\nextendCapacity();\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int j = size - 1; j >= index; j--) {\nnums[j + 1] = nums[j];\n}\nnums[index] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nsize++;\n}\n/* \u5220\u9664\u5143\u7d20 */\npublic int remove(int index) {\nif (index < 0 || index >= size)\nthrow new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\nint num = nums[index];\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int j = index; j < size - 1; j++) {\nnums[j] = nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nsize--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\npublic void extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nnums = Arrays.copyOf(nums, capacity() * extendRatio);\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\ncapacity = nums.length;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\npublic int[] toArray() {\nint size = size();\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] nums = new int[size];\nfor (int i = 0; i < size; i++) {\nnums[i] = get(i);\n}\nreturn nums;\n}\n}\n
    my_list.cpp
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nprivate:\nint *nums;             // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nint numsCapacity = 10; // \u5217\u8868\u5bb9\u91cf\nint numsSize = 0;      // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nint extendRatio = 2;   // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nMyList() {\nnums = new int[numsCapacity];\n}\n/* \u6790\u6784\u65b9\u6cd5 */\n~MyList() {\ndelete[] nums;\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\nint size() {\nreturn numsSize;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nint capacity() {\nreturn numsCapacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\nint get(int index) {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 || index >= size())\nthrow out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\nreturn nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nvoid set(int index, int num) {\nif (index < 0 || index >= size())\nthrow out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\nnums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nvoid add(int num) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (size() == capacity())\nextendCapacity();\nnums[size()] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nvoid insert(int index, int num) {\nif (index < 0 || index >= size())\nthrow out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (size() == capacity())\nextendCapacity();\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int j = size() - 1; j >= index; j--) {\nnums[j + 1] = nums[j];\n}\nnums[index] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize++;\n}\n/* \u5220\u9664\u5143\u7d20 */\nint remove(int index) {\nif (index < 0 || index >= size())\nthrow out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\nint num = nums[index];\n// \u7d22\u5f15 i \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int j = index; j < size() - 1; j++) {\nnums[j] = nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\nvoid extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\nint newCapacity = capacity() * extendRatio;\nint *tmp = nums;\nnums = new int[newCapacity];\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (int i = 0; i < size(); i++) {\nnums[i] = tmp[i];\n}\n// \u91ca\u653e\u5185\u5b58\ndelete[] tmp;\nnumsCapacity = newCapacity;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Vector \u7528\u4e8e\u6253\u5370 */\nvector<int> toVector() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvector<int> vec(size());\nfor (int i = 0; i < size(); i++) {\nvec[i] = nums[i];\n}\nreturn vec;\n}\n};\n
    my_list.py
    class MyList:\n\"\"\"\u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__capacity: int = 10  # \u5217\u8868\u5bb9\u91cf\nself.__nums: list[int] = [0] * self.__capacity  # \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nself.__size: int = 0  # \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nself.__extend_ratio: int = 2  # \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\"\"\"\nreturn self.__size\ndef capacity(self) -> int:\n\"\"\"\u83b7\u53d6\u5217\u8868\u5bb9\u91cf\"\"\"\nreturn self.__capacity\ndef get(self, index: int) -> int:\n\"\"\"\u8bbf\u95ee\u5143\u7d20\"\"\"\n# \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif index < 0 or index >= self.__size:\nraise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\nreturn self.__nums[index]\ndef set(self, num: int, index: int) -> None:\n\"\"\"\u66f4\u65b0\u5143\u7d20\"\"\"\nif index < 0 or index >= self.__size:\nraise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\nself.__nums[index] = num\ndef add(self, num: int) -> None:\n\"\"\"\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\"\"\"\n# \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif self.size() == self.capacity():\nself.extend_capacity()\nself.__nums[self.__size] = num\nself.__size += 1\ndef insert(self, num: int, index: int) -> None:\n\"\"\"\u4e2d\u95f4\u63d2\u5165\u5143\u7d20\"\"\"\nif index < 0 or index >= self.__size:\nraise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n# \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif self.__size == self.capacity():\nself.extend_capacity()\n# \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor j in range(self.__size - 1, index - 1, -1):\nself.__nums[j + 1] = self.__nums[j]\nself.__nums[index] = num\n# \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nself.__size += 1\ndef remove(self, index: int) -> int:\n\"\"\"\u5220\u9664\u5143\u7d20\"\"\"\nif index < 0 or index >= self.__size:\nraise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\nnum = self.__nums[index]\n# \u7d22\u5f15 i \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor j in range(index, self.__size - 1):\nself.__nums[j] = self.__nums[j + 1]\n# \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nself.__size -= 1\n# \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num\ndef extend_capacity(self) -> None:\n\"\"\"\u5217\u8868\u6269\u5bb9\"\"\"\n# \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 __extend_ratio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nself.__nums = self.__nums + [0] * self.capacity() * (self.__extend_ratio - 1)\n# \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nself.__capacity = len(self.__nums)\ndef to_array(self) -> list[int]:\n\"\"\"\u8fd4\u56de\u6709\u6548\u957f\u5ea6\u7684\u5217\u8868\"\"\"\nreturn self.__nums[: self.__size]\n
    my_list.go
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\ntype myList struct {\nnumsCapacity int\nnums         []int\nnumsSize     int\nextendRatio  int\n}\n/* \u6784\u9020\u51fd\u6570 */\nfunc newMyList() *myList {\nreturn &myList{\nnumsCapacity: 10,              // \u5217\u8868\u5bb9\u91cf\nnums:         make([]int, 10), // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nnumsSize:     0,               // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nextendRatio:  2,               // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n}\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\nfunc (l *myList) size() int {\nreturn l.numsSize\n}\n/*  \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nfunc (l *myList) capacity() int {\nreturn l.numsCapacity\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\nfunc (l *myList) get(index int) int {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif index < 0 || index >= l.numsSize {\npanic(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nreturn l.nums[index]\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nfunc (l *myList) set(num, index int) {\nif index < 0 || index >= l.numsSize {\npanic(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nl.nums[index] = num\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nfunc (l *myList) add(num int) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif l.numsSize == l.numsCapacity {\nl.extendCapacity()\n}\nl.nums[l.numsSize] = num\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nl.numsSize++\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nfunc (l *myList) insert(num, index int) {\nif index < 0 || index >= l.numsSize {\npanic(\"\u7d22\u5f15\u8d8a\u754c\")\n}\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif l.numsSize == l.numsCapacity {\nl.extendCapacity()\n}\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor j := l.numsSize - 1; j >= index; j-- {\nl.nums[j+1] = l.nums[j]\n}\nl.nums[index] = num\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nl.numsSize++\n}\n/* \u5220\u9664\u5143\u7d20 */\nfunc (l *myList) remove(index int) int {\nif index < 0 || index >= l.numsSize {\npanic(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nnum := l.nums[index]\n// \u7d22\u5f15 i \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor j := index; j < l.numsSize-1; j++ {\nl.nums[j] = l.nums[j+1]\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nl.numsSize--\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num\n}\n/* \u5217\u8868\u6269\u5bb9 */\nfunc (l *myList) extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nl.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...)\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nl.numsCapacity = len(l.nums)\n}\n/* \u8fd4\u56de\u6709\u6548\u957f\u5ea6\u7684\u5217\u8868 */\nfunc (l *myList) toArray() []int {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nreturn l.nums[:l.numsSize]\n}\n
    my_list.js
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\n#nums = new Array(); // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n#capacity = 10; // \u5217\u8868\u5bb9\u91cf\n#size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n#extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor() {\nthis.#nums = new Array(this.#capacity);\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\nsize() {\nreturn this.#size;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\ncapacity() {\nreturn this.#capacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\nget(index) {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nreturn this.#nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nset(index, num) {\nif (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nthis.#nums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nadd(num) {\n// \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\nif (this.#size === this.#capacity) {\nthis.extendCapacity();\n}\n// \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\nthis.#nums[this.#size] = num;\nthis.#size++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\ninsert(index, num) {\nif (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (this.#size === this.#capacity) {\nthis.extendCapacity();\n}\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (let j = this.#size - 1; j >= index; j--) {\nthis.#nums[j + 1] = this.#nums[j];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nthis.#nums[index] = num;\nthis.#size++;\n}\n/* \u5220\u9664\u5143\u7d20 */\nremove(index) {\nif (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nlet num = this.#nums[index];\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (let j = index; j < this.#size - 1; j++) {\nthis.#nums[j] = this.#nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nthis.#size--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\nextendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nthis.#nums = this.#nums.concat(\nnew Array(this.capacity() * (this.#extendRatio - 1))\n);\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nthis.#capacity = this.#nums.length;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\ntoArray() {\nlet size = this.size();\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst nums = new Array(size);\nfor (let i = 0; i < size; i++) {\nnums[i] = this.get(i);\n}\nreturn nums;\n}\n}\n
    my_list.ts
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nprivate nums: Array<number>; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nprivate _capacity: number = 10; // \u5217\u8868\u5bb9\u91cf\nprivate _size: number = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nprivate extendRatio: number = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor() {\nthis.nums = new Array(this._capacity);\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\npublic size(): number {\nreturn this._size;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\npublic capacity(): number {\nreturn this._capacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\npublic get(index: number): number {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nreturn this.nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\npublic set(index: number, num: number): void {\nif (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nthis.nums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\npublic add(num: number): void {\n// \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\nif (this._size === this._capacity) this.extendCapacity();\n// \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\nthis.nums[this._size] = num;\nthis._size++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\npublic insert(index: number, num: number): void {\nif (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (this._size === this._capacity) {\nthis.extendCapacity();\n}\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (let j = this._size - 1; j >= index; j--) {\nthis.nums[j + 1] = this.nums[j];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nthis.nums[index] = num;\nthis._size++;\n}\n/* \u5220\u9664\u5143\u7d20 */\npublic remove(index: number): number {\nif (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nlet num = this.nums[index];\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (let j = index; j < this._size - 1; j++) {\nthis.nums[j] = this.nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nthis._size--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\npublic extendCapacity(): void {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nthis.nums = this.nums.concat(\nnew Array(this.capacity() * (this.extendRatio - 1))\n);\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nthis._capacity = this.nums.length;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\npublic toArray(): number[] {\nlet size = this.size();\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst nums = new Array(size);\nfor (let i = 0; i < size; i++) {\nnums[i] = this.get(i);\n}\nreturn nums;\n}\n}\n
    my_list.c
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nstruct myList {\nint *nums;       // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nint capacity;    // \u5217\u8868\u5bb9\u91cf\nint size;        // \u5217\u8868\u5927\u5c0f\nint extendRatio; // \u5217\u8868\u6bcf\u6b21\u6269\u5bb9\u7684\u500d\u6570\n};\ntypedef struct myList myList;\n/* \u6784\u9020\u51fd\u6570 */\nmyList *newMyList() {\nmyList *list = malloc(sizeof(myList));\nlist->capacity = 10;\nlist->nums = malloc(sizeof(int) * list->capacity);\nlist->size = 0;\nlist->extendRatio = 2;\nreturn list;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delMyList(myList *list) {\nfree(list->nums);\nfree(list);\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6 */\nint size(myList *list) {\nreturn list->size;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nint capacity(myList *list) {\nreturn list->capacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\nint get(myList *list, int index) {\nassert(index >= 0 && index < list->size);\nreturn list->nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nvoid set(myList *list, int index, int num) {\nassert(index >= 0 && index < list->size);\nlist->nums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nvoid add(myList *list, int num) {\nif (size(list) == capacity(list)) {\nextendCapacity(list); // \u6269\u5bb9\n}\nlist->nums[size(list)] = num;\nlist->size++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nvoid insert(myList *list, int index, int num) {\nassert(index >= 0 && index < size(list));\nfor (int i = size(list); i > index; --i) {\nlist->nums[i] = list->nums[i - 1];\n}\nlist->nums[index] = num;\nlist->size++;\n}\n/* \u5220\u9664\u5143\u7d20 */\n// \u6ce8\u610f\uff1astdio.h \u5360\u7528\u4e86 remove \u5173\u952e\u8bcd\nint removeNum(myList *list, int index) {\nassert(index >= 0 && index < size(list));\nint num = list->nums[index];\nfor (int i = index; i < size(list) - 1; i++) {\nlist->nums[i] = list->nums[i + 1];\n}\nlist->size--;\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\nvoid extendCapacity(myList *list) {\n// \u5148\u5206\u914d\u7a7a\u95f4\nint newCapacity = capacity(list) * list->extendRatio;\nint *extend = (int *)malloc(sizeof(int) * newCapacity);\nint *temp = list->nums;\n// \u62f7\u8d1d\u65e7\u6570\u636e\u5230\u65b0\u6570\u636e\nfor (int i = 0; i < size(list); i++)\nextend[i] = list->nums[i];\n// \u91ca\u653e\u65e7\u6570\u636e\nfree(temp);\n// \u66f4\u65b0\u65b0\u6570\u636e\nlist->nums = extend;\nlist->capacity = newCapacity;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Array \u7528\u4e8e\u6253\u5370 */\nint *toArray(myList *list) {\nreturn list->nums;\n}\n
    my_list.cs
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nprivate int[] nums;           // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nprivate int numsCapacity = 10;    // \u5217\u8868\u5bb9\u91cf\nprivate int numsSize = 0;         // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nprivate int extendRatio = 2;  // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\npublic MyList() {\nnums = new int[numsCapacity];\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\npublic int size() {\nreturn numsSize;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\npublic int capacity() {\nreturn numsCapacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\npublic int get(int index) {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 || index >= numsSize)\nthrow new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\nreturn nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\npublic void set(int index, int num) {\nif (index < 0 || index >= numsSize)\nthrow new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\nnums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\npublic void add(int num) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (numsSize == numsCapacity)\nextendCapacity();\nnums[numsSize] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\npublic void insert(int index, int num) {\nif (index < 0 || index >= numsSize)\nthrow new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (numsSize == numsCapacity)\nextendCapacity();\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int j = numsSize - 1; j >= index; j--) {\nnums[j + 1] = nums[j];\n}\nnums[index] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize++;\n}\n/* \u5220\u9664\u5143\u7d20 */\npublic int remove(int index) {\nif (index < 0 || index >= numsSize)\nthrow new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\nint num = nums[index];\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int j = index; j < numsSize - 1; j++) {\nnums[j] = nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\npublic void extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a numsCapacity * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nSystem.Array.Resize(ref nums, numsCapacity * extendRatio);\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nnumsCapacity = nums.Length;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\npublic int[] toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] nums = new int[numsSize];\nfor (int i = 0; i < numsSize; i++) {\nnums[i] = get(i);\n}\nreturn nums;\n}\n}\n
    my_list.swift
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nprivate var nums: [Int] // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nprivate var _capacity = 10 // \u5217\u8868\u5bb9\u91cf\nprivate var _size = 0 // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nprivate let extendRatio = 2 // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\ninit() {\nnums = Array(repeating: 0, count: _capacity)\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\nfunc size() -> Int {\n_size\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nfunc capacity() -> Int {\n_capacity\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\nfunc get(index: Int) -> Int {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u9519\u8bef\uff0c\u4e0b\u540c\nif index < 0 || index >= _size {\nfatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nreturn nums[index]\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nfunc set(index: Int, num: Int) {\nif index < 0 || index >= _size {\nfatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nnums[index] = num\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nfunc add(num: Int) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif _size == _capacity {\nextendCapacity()\n}\nnums[_size] = num\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size += 1\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nfunc insert(index: Int, num: Int) {\nif index < 0 || index >= _size {\nfatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n}\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif _size == _capacity {\nextendCapacity()\n}\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor j in sequence(first: _size - 1, next: { $0 >= index + 1 ? $0 - 1 : nil }) {\nnums[j + 1] = nums[j]\n}\nnums[index] = num\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size += 1\n}\n/* \u5220\u9664\u5143\u7d20 */\n@discardableResult\nfunc remove(index: Int) -> Int {\nif index < 0 || index >= _size {\nfatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nlet num = nums[index]\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor j in index ..< (_size - 1) {\nnums[j] = nums[j + 1]\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size -= 1\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num\n}\n/* \u5217\u8868\u6269\u5bb9 */\nfunc extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nnums = nums + Array(repeating: 0, count: _capacity * (extendRatio - 1))\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n_capacity = nums.count\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\nfunc toArray() -> [Int] {\nvar nums = Array(repeating: 0, count: _size)\nfor i in 0 ..< _size {\nnums[i] = get(index: i)\n}\nreturn nums\n}\n}\n
    my_list.zig
    // \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0\nfn MyList(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nnums: []T = undefined,                        // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nnumsCapacity: usize = 10,                     // \u5217\u8868\u5bb9\u91cf\nnumSize: usize = 0,                           // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nextendRatio: usize = 2,                       // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\nmem_arena: ?std.heap.ArenaAllocator = null,\nmem_allocator: std.mem.Allocator = undefined, // \u5185\u5b58\u5206\u914d\u5668\n// \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u5217\u8868\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator) !void {\nif (self.mem_arena == null) {\nself.mem_arena = std.heap.ArenaAllocator.init(allocator);\nself.mem_allocator = self.mem_arena.?.allocator();\n}\nself.nums = try self.mem_allocator.alloc(T, self.numsCapacity);\n@memset(self.nums, @as(T, 0));\n}\n// \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.mem_arena == null) return;\nself.mem_arena.?.deinit();\n}\n// \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\npub fn size(self: *Self) usize {\nreturn self.numSize;\n}\n// \u83b7\u53d6\u5217\u8868\u5bb9\u91cf\npub fn capacity(self: *Self) usize {\nreturn self.numsCapacity;\n}\n// \u8bbf\u95ee\u5143\u7d20\npub fn get(self: *Self, index: usize) T {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\nreturn self.nums[index];\n}  // \u66f4\u65b0\u5143\u7d20\npub fn set(self: *Self, index: usize, num: T) void {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\nself.nums[index] = num;\n}  // \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\npub fn add(self: *Self, num: T) !void {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (self.size() == self.capacity()) try self.extendCapacity();\nself.nums[self.size()] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nself.numSize += 1;\n}  // \u4e2d\u95f4\u63d2\u5165\u5143\u7d20\npub fn insert(self: *Self, index: usize, num: T) !void {\nif (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (self.size() == self.capacity()) try self.extendCapacity();\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nvar j = self.size() - 1;\nwhile (j >= index) : (j -= 1) {\nself.nums[j + 1] = self.nums[j];\n}\nself.nums[index] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nself.numSize += 1;\n}\n// \u5220\u9664\u5143\u7d20\npub fn remove(self: *Self, index: usize) T {\nif (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\nvar num = self.nums[index];\n// \u7d22\u5f15 i \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nvar j = index;\nwhile (j < self.size() - 1) : (j += 1) {\nself.nums[j] = self.nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nself.numSize -= 1;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n// \u5217\u8868\u6269\u5bb9\npub fn extendCapacity(self: *Self) !void {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nvar newCapacity = self.capacity() * self.extendRatio;\nvar extend = try self.mem_allocator.alloc(T, newCapacity);\n@memset(extend, @as(T, 0));\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nstd.mem.copy(T, extend, self.nums);\nself.nums = extend;\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nself.numsCapacity = newCapacity;\n}\n// \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\npub fn toArray(self: *Self) ![]T {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvar nums = try self.mem_allocator.alloc(T, self.size());\n@memset(nums, @as(T, 0));\nfor (nums, 0..) |*num, i| {\nnum.* = self.get(i);\n}\nreturn nums;\n}\n};\n}\n
    my_list.dart
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nlate List<int> _nums; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nint _capacity = 10; // \u5217\u8868\u5bb9\u91cf\nint _size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nint _extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\nMyList() {\n_nums = List.filled(_capacity, 0);\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\nint size() => _size;\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nint capacity() => _capacity;\n/* \u8bbf\u95ee\u5143\u7d20 */\nint get(int index) {\nif (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\nreturn _nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nvoid set(int index, int num) {\nif (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n_nums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nvoid add(int num) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (_size == _capacity) extendCapacity();\n_nums[_size] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nvoid insert(int index, int num) {\nif (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (_size == _capacity) extendCapacity();\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (var j = _size - 1; j >= index; j--) {\n_nums[j + 1] = _nums[j];\n}\n_nums[index] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size++;\n}\n/* \u5220\u9664\u5143\u7d20 */\nint remove(int index) {\nif (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\nint num = _nums[index];\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (var j = index; j < _size - 1; j++) {\n_nums[j] = _nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\nvoid extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 _extendRatio \u500d\u7684\u65b0\u6570\u7ec4\nfinal _newNums = List.filled(_capacity * _extendRatio, 0);\n// \u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nList.copyRange(_newNums, 0, _nums);\n// \u66f4\u65b0 _nums \u7684\u5f15\u7528\n_nums = _newNums;\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n_capacity = _nums.length;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\nList<int> toArray() {\nList<int> nums = [];\nfor (var i = 0; i < _size; i++) {\nnums.add(get(i));\n}\nreturn nums;\n}\n}\n
    "},{"location":"chapter_array_and_linkedlist/summary/","title":"4.4. \u00a0 \u5c0f\u7ed3","text":"
    • \u6570\u7ec4\u548c\u94fe\u8868\u662f\u4e24\u79cd\u57fa\u672c\u6570\u636e\u7ed3\u6784\uff0c\u5206\u522b\u4ee3\u8868\u6570\u636e\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u7684\u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u548c\u79bb\u6563\u7a7a\u95f4\u5b58\u50a8\u65b9\u5f0f\u3002\u4e24\u8005\u7684\u4f18\u7f3a\u70b9\u5448\u73b0\u51fa\u4e92\u8865\u7684\u7279\u6027\u3002
    • \u6570\u7ec4\u652f\u6301\u968f\u673a\u8bbf\u95ee\u3001\u5360\u7528\u5185\u5b58\u8f83\u5c11\uff1b\u4f46\u63d2\u5165\u548c\u5220\u9664\u5143\u7d20\u6548\u7387\u4f4e\uff0c\u4e14\u521d\u59cb\u5316\u540e\u957f\u5ea6\u4e0d\u53ef\u53d8\u3002
    • \u94fe\u8868\u901a\u8fc7\u66f4\u6539\u6307\u9488\u5b9e\u73b0\u9ad8\u6548\u7684\u8282\u70b9\u63d2\u5165\u4e0e\u5220\u9664\uff0c\u4e14\u53ef\u4ee5\u7075\u6d3b\u8c03\u6574\u957f\u5ea6\uff1b\u4f46\u8282\u70b9\u8bbf\u95ee\u6548\u7387\u4f4e\u3001\u5360\u7528\u5185\u5b58\u8f83\u591a\u3002\u5e38\u89c1\u7684\u94fe\u8868\u7c7b\u578b\u5305\u62ec\u5355\u5411\u94fe\u8868\u3001\u5faa\u73af\u94fe\u8868\u3001\u53cc\u5411\u94fe\u8868\u3002
    • \u52a8\u6001\u6570\u7ec4\uff0c\u53c8\u79f0\u5217\u8868\uff0c\u662f\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u4e00\u79cd\u6570\u636e\u7ed3\u6784\u3002\u5b83\u4fdd\u7559\u4e86\u6570\u7ec4\u7684\u4f18\u52bf\uff0c\u540c\u65f6\u53ef\u4ee5\u7075\u6d3b\u8c03\u6574\u957f\u5ea6\u3002\u5217\u8868\u7684\u51fa\u73b0\u6781\u5927\u5730\u63d0\u9ad8\u4e86\u6570\u7ec4\u7684\u6613\u7528\u6027\uff0c\u4f46\u53ef\u80fd\u5bfc\u81f4\u90e8\u5206\u5185\u5b58\u7a7a\u95f4\u6d6a\u8d39\u3002
    • \u4e0b\u8868\u603b\u7ed3\u5e76\u5bf9\u6bd4\u4e86\u6570\u7ec4\u4e0e\u94fe\u8868\u7684\u5404\u9879\u7279\u6027\u4e0e\u64cd\u4f5c\u6548\u7387\u3002
    \u6570\u7ec4 \u94fe\u8868 \u5b58\u50a8\u65b9\u5f0f \u8fde\u7eed\u5185\u5b58\u7a7a\u95f4 \u79bb\u6563\u5185\u5b58\u7a7a\u95f4 \u6570\u636e\u7ed3\u6784\u957f\u5ea6 \u957f\u5ea6\u4e0d\u53ef\u53d8 \u957f\u5ea6\u53ef\u53d8 \u5185\u5b58\u4f7f\u7528\u7387 \u5360\u7528\u5185\u5b58\u5c11\u3001\u7f13\u5b58\u5c40\u90e8\u6027\u597d \u5360\u7528\u5185\u5b58\u591a \u4f18\u52bf\u64cd\u4f5c \u968f\u673a\u8bbf\u95ee \u63d2\u5165\u3001\u5220\u9664 \u8bbf\u95ee\u5143\u7d20 \\(O(1)\\) \\(O(N)\\) \u6dfb\u52a0\u5143\u7d20 \\(O(N)\\) \\(O(1)\\) \u5220\u9664\u5143\u7d20 \\(O(N)\\) \\(O(1)\\)

    \u7f13\u5b58\u5c40\u90e8\u6027

    \u5728\u8ba1\u7b97\u673a\u4e2d\uff0c\u6570\u636e\u8bfb\u5199\u901f\u5ea6\u6392\u5e8f\u662f\u201c\u786c\u76d8 < \u5185\u5b58 < CPU \u7f13\u5b58\u201d\u3002\u5f53\u6211\u4eec\u8bbf\u95ee\u6570\u7ec4\u5143\u7d20\u65f6\uff0c\u8ba1\u7b97\u673a\u4e0d\u4ec5\u4f1a\u52a0\u8f7d\u5b83\uff0c\u8fd8\u4f1a\u7f13\u5b58\u5176\u5468\u56f4\u7684\u5176\u4ed6\u6570\u636e\uff0c\u4ece\u800c\u501f\u52a9\u9ad8\u901f\u7f13\u5b58\u6765\u63d0\u5347\u540e\u7eed\u64cd\u4f5c\u7684\u6267\u884c\u901f\u5ea6\u3002\u94fe\u8868\u5219\u4e0d\u7136\uff0c\u8ba1\u7b97\u673a\u53ea\u80fd\u6328\u4e2a\u5730\u7f13\u5b58\u5404\u4e2a\u8282\u70b9\uff0c\u8fd9\u6837\u7684\u591a\u6b21\u201c\u642c\u8fd0\u201d\u964d\u4f4e\u4e86\u6574\u4f53\u6548\u7387\u3002

    "},{"location":"chapter_array_and_linkedlist/summary/#441-q-a","title":"4.4.1. \u00a0 Q & A","text":"

    \u6570\u7ec4\u5b58\u50a8\u5728\u6808\u4e0a\u548c\u5b58\u50a8\u5728\u5806\u4e0a\uff0c\u5bf9\u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u662f\u5426\u6709\u5f71\u54cd\uff1f

    \u6808\u5185\u5b58\u5206\u914d\u7531\u7f16\u8bd1\u5668\u81ea\u52a8\u5b8c\u6210\uff0c\u800c\u5806\u5185\u5b58\u7531\u7a0b\u5e8f\u5458\u5728\u4ee3\u7801\u4e2d\u5206\u914d\uff08\u6ce8\u610f\uff0c\u8fd9\u91cc\u7684\u6808\u548c\u5806\u548c\u6570\u636e\u7ed3\u6784\u4e2d\u7684\u6808\u548c\u5806\u4e0d\u662f\u540c\u4e00\u6982\u5ff5\uff09\u3002

    1. \u6808\u4e0d\u7075\u6d3b\uff0c\u5206\u914d\u7684\u5185\u5b58\u5927\u5c0f\u4e0d\u53ef\u66f4\u6539\uff1b\u5806\u76f8\u5bf9\u7075\u6d3b\uff0c\u53ef\u4ee5\u52a8\u6001\u5206\u914d\u5185\u5b58\uff1b
    2. \u6808\u662f\u4e00\u5757\u6bd4\u8f83\u5c0f\u7684\u5185\u5b58\uff0c\u5bb9\u6613\u51fa\u73b0\u5185\u5b58\u4e0d\u8db3\uff1b\u5806\u5185\u5b58\u5f88\u5927\uff0c\u4f46\u662f\u7531\u4e8e\u662f\u52a8\u6001\u5206\u914d\uff0c\u5bb9\u6613\u788e\u7247\u5316\uff0c\u7ba1\u7406\u5806\u5185\u5b58\u7684\u96be\u5ea6\u66f4\u5927\u3001\u6210\u672c\u66f4\u9ad8\uff1b
    3. \u8bbf\u95ee\u6808\u6bd4\u8bbf\u95ee\u5806\u66f4\u5feb\uff0c\u56e0\u4e3a\u6808\u5185\u5b58\u8f83\u5c0f\u3001\u5bf9\u7f13\u5b58\u53cb\u597d\uff0c\u5806\u5e27\u5206\u6563\u5728\u5f88\u5927\u7684\u7a7a\u95f4\u5185\uff0c\u4f1a\u51fa\u73b0\u66f4\u591a\u7684\u7f13\u5b58\u672a\u547d\u4e2d\uff1b

    \u4e3a\u4ec0\u4e48\u6570\u7ec4\u4f1a\u5f3a\u8c03\u8981\u6c42\u76f8\u540c\u7c7b\u578b\u7684\u5143\u7d20\uff0c\u800c\u5728\u94fe\u8868\u4e2d\u5374\u6ca1\u6709\u5f3a\u8c03\u540c\u7c7b\u578b\u5462\uff1f

    \u94fe\u8868\u7531\u7ed3\u70b9\u7ec4\u6210\uff0c\u7ed3\u70b9\u4e4b\u95f4\u7531\u6307\u9488\u8fde\u63a5\uff0c\u5404\u4e2a\u7ed3\u70b9\u53ef\u4ee5\u5b58\u50a8\u4e0d\u540c\u7c7b\u578b\u7684\u6570\u636e\uff0c\u4f8b\u5982 int, double, string, object \u7b49\u3002

    \u76f8\u5bf9\u5730\uff0c\u6570\u7ec4\u5143\u7d20\u5219\u5fc5\u987b\u662f\u76f8\u540c\u7c7b\u578b\u7684\uff0c\u8fd9\u6837\u624d\u80fd\u901a\u8fc7\u8ba1\u7b97\u504f\u79fb\u91cf\u6765\u83b7\u53d6\u5bf9\u5e94\u5143\u7d20\u4f4d\u7f6e\u3002\u4f8b\u5982\uff0c\u5982\u679c\u6570\u7ec4\u540c\u65f6\u5305\u542b int \u548c long \u4e24\u79cd\u7c7b\u578b\uff0c\u5355\u4e2a\u5143\u7d20\u5206\u522b\u5360\u7528 4 bytes \u548c 8 bytes \uff0c\u90a3\u4e48\u6b64\u65f6\u5c31\u4e0d\u80fd\u7528\u4ee5\u4e0b\u516c\u5f0f\u8ba1\u7b97\u504f\u79fb\u91cf\u4e86\uff0c\u56e0\u4e3a\u6570\u7ec4\u4e2d\u5305\u542b\u4e86\u4e24\u79cd elementLength \u3002

    // \u5143\u7d20\u5185\u5b58\u5730\u5740 = \u6570\u7ec4\u5185\u5b58\u5730\u5740 + \u5143\u7d20\u957f\u5ea6 * \u5143\u7d20\u7d22\u5f15\nelementAddr = firtstElementAddr + elementLength * elementIndex\n

    \u5220\u9664\u8282\u70b9\u540e\uff0c\u662f\u5426\u9700\u8981\u628a P.next \u8bbe\u4e3a \\(\\text{None}\\) \u5462\uff1f

    \u4e0d\u4fee\u6539 P.next \u4e5f\u53ef\u4ee5\u3002\u4ece\u8be5\u94fe\u8868\u7684\u89d2\u5ea6\u770b\uff0c\u4ece\u5934\u7ed3\u70b9\u904d\u5386\u5230\u5c3e\u7ed3\u70b9\u5df2\u7ecf\u9047\u4e0d\u5230 P \u4e86\u3002\u8fd9\u610f\u5473\u7740\u7ed3\u70b9 P \u5df2\u7ecf\u4ece\u94fe\u8868\u4e2d\u5220\u9664\u4e86\uff0c\u6b64\u65f6\u7ed3\u70b9 P \u6307\u5411\u54ea\u91cc\u90fd\u4e0d\u4f1a\u5bf9\u8fd9\u6761\u94fe\u8868\u4ea7\u751f\u5f71\u54cd\u4e86\u3002

    \u4ece\u5783\u573e\u56de\u6536\u7684\u89d2\u5ea6\u770b\uff0c\u5bf9\u4e8e Java, Python, Go \u7b49\u62e5\u6709\u81ea\u52a8\u5783\u573e\u56de\u6536\u7684\u8bed\u8a00\u6765\u8bf4\uff0c\u8282\u70b9 P \u662f\u5426\u88ab\u56de\u6536\u53d6\u51b3\u4e8e\u662f\u5426\u6709\u4ecd\u5b58\u5728\u6307\u5411\u5b83\u7684\u5f15\u7528\uff0c\u800c\u4e0d\u662f P.next \u7684\u503c\u3002\u5728 C, C++ \u7b49\u8bed\u8a00\u4e2d\uff0c\u6211\u4eec\u9700\u8981\u624b\u52a8\u91ca\u653e\u8282\u70b9\u5185\u5b58\u3002

    \u5728\u94fe\u8868\u4e2d\u63d2\u5165\u548c\u5220\u9664\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(1)\\) \u3002\u4f46\u662f\u589e\u5220\u4e4b\u524d\u90fd\u9700\u8981 \\(O(n)\\) \u67e5\u627e\u5143\u7d20\uff0c\u90a3\u4e3a\u4ec0\u4e48\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u662f \\(O(n)\\) \u5462\uff1f

    \u5982\u679c\u662f\u5148\u67e5\u627e\u5143\u7d20\u3001\u518d\u5220\u9664\u5143\u7d20\uff0c\u786e\u5b9e\u662f \\(O(n)\\) \u3002\u7136\u800c\uff0c\u94fe\u8868\u7684 \\(O(1)\\) \u589e\u5220\u7684\u4f18\u52bf\u53ef\u4ee5\u5728\u5176\u4ed6\u5e94\u7528\u4e0a\u5f97\u5230\u4f53\u73b0\u3002\u4f8b\u5982\uff0c\u53cc\u5411\u961f\u5217\u9002\u5408\u4f7f\u7528\u94fe\u8868\u5b9e\u73b0\uff0c\u6211\u4eec\u7ef4\u62a4\u4e00\u4e2a\u6307\u9488\u53d8\u91cf\u59cb\u7ec8\u6307\u5411\u5934\u7ed3\u70b9\u3001\u5c3e\u7ed3\u70b9\uff0c\u6bcf\u6b21\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u90fd\u662f \\(O(1)\\) \u3002

    \u56fe\u7247\u201c\u94fe\u8868\u5b9a\u4e49\u4e0e\u5b58\u50a8\u65b9\u5f0f\u201d\u4e2d\uff0c\u6d45\u84dd\u8272\u7684\u5b58\u50a8\u7ed3\u70b9\u6307\u9488\u662f\u5360\u7528\u4e00\u5757\u5185\u5b58\u5730\u5740\u5417\uff1f\u8fd8\u662f\u548c\u7ed3\u70b9\u503c\u5404\u5360\u4e00\u534a\u5462\uff1f

    \u6587\u4e2d\u53ea\u662f\u4e00\u4e2a\u793a\u610f\u56fe\uff0c\u53ea\u662f\u5b9a\u6027\u8868\u793a\u3002\u5b9a\u91cf\u7684\u8bdd\u9700\u8981\u6839\u636e\u5177\u4f53\u60c5\u51b5\u5206\u6790\uff1a

    • \u4e0d\u540c\u7c7b\u578b\u7684\u7ed3\u70b9\u503c\u5360\u7528\u7684\u7a7a\u95f4\u662f\u4e0d\u540c\u7684\uff0c\u6bd4\u5982 int, long, double, \u6216\u8005\u662f\u7c7b\u7684\u5b9e\u4f8b\u7b49\u7b49\u3002
    • \u6307\u9488\u53d8\u91cf\u5360\u7528\u7684\u5185\u5b58\u7a7a\u95f4\u5927\u5c0f\u6839\u636e\u6240\u4f7f\u7528\u7684\u64cd\u4f5c\u7cfb\u7edf\u53ca\u7f16\u8bd1\u73af\u5883\u800c\u5b9a\uff0c\u5927\u591a\u4e3a 8 \u5b57\u8282\u6216 4 \u5b57\u8282\u3002

    \u5728\u5217\u8868\u672b\u5c3e\u6dfb\u52a0\u5143\u7d20\u662f\u5426\u65f6\u65f6\u523b\u523b\u90fd\u4e3a \\(O(1)\\) \uff1f

    \u5982\u679c\u6dfb\u52a0\u5143\u7d20\u65f6\u8d85\u51fa\u5217\u8868\u957f\u5ea6\uff0c\u5219\u9700\u8981\u5148\u6269\u5bb9\u5217\u8868\u518d\u6dfb\u52a0\u3002\u7cfb\u7edf\u4f1a\u7533\u8bf7\u4e00\u5757\u65b0\u7684\u5185\u5b58\uff0c\u5e76\u5c06\u539f\u5217\u8868\u7684\u6240\u6709\u5143\u7d20\u642c\u8fd0\u8fc7\u53bb\uff0c\u8fd9\u65f6\u5019\u65f6\u95f4\u590d\u6742\u5ea6\u5c31\u4f1a\u662f \\(O(n)\\) \u3002

    \u201c\u5217\u8868\u7684\u51fa\u73b0\u5927\u5927\u63d0\u5347\u4e86\u6570\u7ec4\u7684\u5b9e\u7528\u6027\uff0c\u4f46\u526f\u4f5c\u7528\u662f\u4f1a\u9020\u6210\u90e8\u5206\u5185\u5b58\u7a7a\u95f4\u6d6a\u8d39\u201d\uff0c\u8fd9\u91cc\u7684\u7a7a\u95f4\u6d6a\u8d39\u662f\u6307\u989d\u5916\u589e\u52a0\u7684\u53d8\u91cf\u5982\u5bb9\u91cf\u3001\u957f\u5ea6\u3001\u6269\u5bb9\u500d\u6570\u6240\u5360\u7684\u5185\u5b58\u5417\uff1f

    \u8fd9\u91cc\u7684\u7a7a\u95f4\u6d6a\u8d39\u4e3b\u8981\u6709\u4e24\u65b9\u9762\u542b\u4e49\uff1a\u4e00\u65b9\u9762\uff0c\u5217\u8868\u90fd\u4f1a\u8bbe\u5b9a\u4e00\u4e2a\u521d\u59cb\u957f\u5ea6\uff0c\u6211\u4eec\u4e0d\u4e00\u5b9a\u9700\u8981\u7528\u8fd9\u4e48\u591a\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u4e3a\u4e86\u9632\u6b62\u9891\u7e41\u6269\u5bb9\uff0c\u6269\u5bb9\u4e00\u822c\u90fd\u4f1a\u4e58\u4ee5\u4e00\u4e2a\u7cfb\u6570\uff0c\u6bd4\u5982 \\(\\times 1.5\\) \u3002\u8fd9\u6837\u4e00\u6765\uff0c\u4e5f\u4f1a\u51fa\u73b0\u5f88\u591a\u7a7a\u4f4d\uff0c\u6211\u4eec\u901a\u5e38\u4e0d\u80fd\u5b8c\u5168\u586b\u6ee1\u5b83\u4eec\u3002

    \u5728 Python \u4e2d\u521d\u59cb\u5316 n = [1, 2, 3] \u540e\uff0c\u8fd9 3 \u4e2a\u5143\u7d20\u7684\u5730\u5740\u662f\u76f8\u8fde\u7684\uff0c\u4f46\u662f\u521d\u59cb\u5316 m = [2, 1, 3] \u4f1a\u53d1\u73b0\u5b83\u4eec\u6bcf\u4e2a\u5143\u7d20\u7684 id \u5e76\u4e0d\u662f\u8fde\u7eed\u7684\uff0c\u800c\u662f\u5206\u522b\u8ddf n \u4e2d\u7684\u76f8\u540c\u3002\u8fd9\u4e9b\u5143\u7d20\u5730\u5740\u4e0d\u8fde\u7eed\uff0c\u90a3\u4e48 m \u8fd8\u662f\u6570\u7ec4\u5417\uff1f

    \u5047\u5982\u628a\u5217\u8868\u5143\u7d20\u6362\u6210\u94fe\u8868\u8282\u70b9 n = [n1, n2, n3, n4, n5] \uff0c\u901a\u5e38\u60c5\u51b5\u4e0b\u8fd9\u4e94\u4e2a\u8282\u70b9\u5bf9\u8c61\u4e5f\u662f\u88ab\u5206\u6563\u5b58\u50a8\u5728\u5185\u5b58\u5404\u5904\u7684\u3002\u7136\u800c\uff0c\u7ed9\u5b9a\u4e00\u4e2a\u5217\u8868\u7d22\u5f15\uff0c\u6211\u4eec\u4ecd\u7136\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u83b7\u53d6\u5230\u8282\u70b9\u5185\u5b58\u5730\u5740\uff0c\u4ece\u800c\u8bbf\u95ee\u5230\u5bf9\u5e94\u7684\u8282\u70b9\u3002\u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u4e2d\u5b58\u50a8\u7684\u662f\u8282\u70b9\u7684\u5f15\u7528\uff0c\u800c\u975e\u8282\u70b9\u672c\u8eab\u3002

    \u4e0e\u8bb8\u591a\u8bed\u8a00\u4e0d\u540c\u7684\u662f\uff0c\u5728 Python \u4e2d\u6570\u5b57\u4e5f\u88ab\u5305\u88c5\u4e3a\u5bf9\u8c61\uff0c\u5217\u8868\u4e2d\u5b58\u50a8\u7684\u4e0d\u662f\u6570\u5b57\u672c\u8eab\uff0c\u800c\u662f\u5bf9\u6570\u5b57\u7684\u5f15\u7528\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u4f1a\u53d1\u73b0\u4e24\u4e2a\u6570\u7ec4\u4e2d\u7684\u76f8\u540c\u6570\u5b57\u62e5\u6709\u540c\u4e00\u4e2a id \uff0c\u5e76\u4e14\u8fd9\u4e9b\u6570\u5b57\u7684\u5185\u5b58\u5730\u5740\u662f\u65e0\u9700\u8fde\u7eed\u7684\u3002

    "},{"location":"chapter_backtracking/","title":"12. \u00a0 \u56de\u6eaf","text":""},{"location":"chapter_backtracking/backtracking_algorithm/","title":"12.1. \u00a0 \u56de\u6eaf\u7b97\u6cd5","text":"

    \u300c\u56de\u6eaf\u7b97\u6cd5 Backtracking Algorithm\u300d\u662f\u4e00\u79cd\u901a\u8fc7\u7a77\u4e3e\u6765\u89e3\u51b3\u95ee\u9898\u7684\u65b9\u6cd5\uff0c\u5b83\u7684\u6838\u5fc3\u601d\u60f3\u662f\u4ece\u4e00\u4e2a\u521d\u59cb\u72b6\u6001\u51fa\u53d1\uff0c\u66b4\u529b\u641c\u7d22\u6240\u6709\u53ef\u80fd\u7684\u89e3\u51b3\u65b9\u6848\uff0c\u5f53\u9047\u5230\u6b63\u786e\u7684\u89e3\u5219\u5c06\u5176\u8bb0\u5f55\uff0c\u76f4\u5230\u627e\u5230\u89e3\u6216\u8005\u5c1d\u8bd5\u4e86\u6240\u6709\u53ef\u80fd\u7684\u9009\u62e9\u90fd\u65e0\u6cd5\u627e\u5230\u89e3\u4e3a\u6b62\u3002

    \u56de\u6eaf\u7b97\u6cd5\u901a\u5e38\u91c7\u7528\u300c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u300d\u6765\u904d\u5386\u89e3\u7a7a\u95f4\u3002\u5728\u4e8c\u53c9\u6811\u7ae0\u8282\u4e2d\uff0c\u6211\u4eec\u63d0\u5230\u524d\u5e8f\u3001\u4e2d\u5e8f\u548c\u540e\u5e8f\u904d\u5386\u90fd\u5c5e\u4e8e\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u3002\u4e0b\u9762\uff0c\u6211\u4eec\u5c06\u4ece\u524d\u5e8f\u904d\u5386\u5165\u624b\uff0c\u9010\u6b65\u4e86\u89e3\u56de\u6eaf\u7b97\u6cd5\u7684\u5de5\u4f5c\u539f\u7406\u3002

    \u4f8b\u9898\u4e00

    \u7ed9\u5b9a\u4e00\u4e2a\u4e8c\u53c9\u6811\uff0c\u641c\u7d22\u5e76\u8bb0\u5f55\u6240\u6709\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\uff0c\u8fd4\u56de\u8282\u70b9\u5217\u8868\u3002

    \u89e3\u9898\u601d\u8def\uff1a\u524d\u5e8f\u904d\u5386\u8fd9\u9897\u6811\uff0c\u5e76\u5224\u65ad\u5f53\u524d\u8282\u70b9\u7684\u503c\u662f\u5426\u4e3a \\(7\\) \uff0c\u82e5\u662f\u5219\u5c06\u8be5\u8282\u70b9\u7684\u503c\u52a0\u5165\u5230\u7ed3\u679c\u5217\u8868 res \u4e4b\u4e2d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart preorder_traversal_i_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode root) {\nif (root == null) {\nreturn;\n}\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.add(root);\n}\npreOrder(root.left);\npreOrder(root.right);\n}\n
    preorder_traversal_i_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode *root) {\nif (root == nullptr) {\nreturn;\n}\nif (root->val == 7) {\n// \u8bb0\u5f55\u89e3\nres.push_back(root);\n}\npreOrder(root->left);\npreOrder(root->right);\n}\n
    preorder_traversal_i_compact.py
    def pre_order(root: TreeNode) -> None:\n\"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00\"\"\"\nif root is None:\nreturn\nif root.val == 7:\n# \u8bb0\u5f55\u89e3\nres.append(root)\npre_order(root.left)\npre_order(root.right)\n
    preorder_traversal_i_compact.go
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\nif root == nil {\nreturn\n}\nif int(root.Val) == 7 {\n// \u8bb0\u5f55\u89e3\n*res = append(*res, root)\n}\npreOrderI(root.Left, res)\npreOrderI(root.Right, res)\n}\n
    preorder_traversal_i_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunction preOrder(root, res) {\nif (root === null) {\nreturn;\n}\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push(root);\n}\npreOrder(root.left, res);\npreOrder(root.right, res);\n}\n
    preorder_traversal_i_compact.ts
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunction preOrder(root: TreeNode | null, res: TreeNode[]): void {\nif (root === null) {\nreturn;\n}\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push(root);\n}\npreOrder(root.left, res);\npreOrder(root.right, res);\n}\n
    preorder_traversal_i_compact.c
    [class]{}-[func]{preOrder}\n
    preorder_traversal_i_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode root) {\nif (root == null) {\nreturn;\n}\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.Add(root);\n}\npreOrder(root.left);\npreOrder(root.right);\n}\n
    preorder_traversal_i_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunc preOrder(root: TreeNode?) {\nguard let root = root else {\nreturn\n}\nif root.val == 7 {\n// \u8bb0\u5f55\u89e3\nres.append(root)\n}\npreOrder(root: root.left)\npreOrder(root: root.right)\n}\n
    preorder_traversal_i_compact.zig
    [class]{}-[func]{preOrder}\n
    preorder_traversal_i_compact.dart
    [class]{}-[func]{preOrder}\n

    Fig. \u5728\u524d\u5e8f\u904d\u5386\u4e2d\u641c\u7d22\u8282\u70b9

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1211","title":"12.1.1. \u00a0 \u5c1d\u8bd5\u4e0e\u56de\u9000","text":"

    \u4e4b\u6240\u4ee5\u79f0\u4e4b\u4e3a\u56de\u6eaf\u7b97\u6cd5\uff0c\u662f\u56e0\u4e3a\u8be5\u7b97\u6cd5\u5728\u641c\u7d22\u89e3\u7a7a\u95f4\u65f6\u4f1a\u91c7\u7528\u201c\u5c1d\u8bd5\u201d\u4e0e\u201c\u56de\u9000\u201d\u7684\u7b56\u7565\u3002\u5f53\u7b97\u6cd5\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u9047\u5230\u67d0\u4e2a\u72b6\u6001\u65e0\u6cd5\u7ee7\u7eed\u524d\u8fdb\u6216\u65e0\u6cd5\u5f97\u5230\u6ee1\u8db3\u6761\u4ef6\u7684\u89e3\u65f6\uff0c\u5b83\u4f1a\u64a4\u9500\u4e0a\u4e00\u6b65\u7684\u9009\u62e9\uff0c\u9000\u56de\u5230\u4e4b\u524d\u7684\u72b6\u6001\uff0c\u5e76\u5c1d\u8bd5\u5176\u4ed6\u53ef\u80fd\u7684\u9009\u62e9\u3002

    \u5bf9\u4e8e\u4f8b\u9898\u4e00\uff0c\u8bbf\u95ee\u6bcf\u4e2a\u8282\u70b9\u90fd\u4ee3\u8868\u4e00\u6b21\u201c\u5c1d\u8bd5\u201d\uff0c\u800c\u8d8a\u8fc7\u53f6\u7ed3\u70b9\u6216\u8fd4\u56de\u7236\u8282\u70b9\u7684 return \u5219\u8868\u793a\u201c\u56de\u9000\u201d\u3002

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\u56de\u9000\u5e76\u4e0d\u7b49\u4ef7\u4e8e\u51fd\u6570\u8fd4\u56de\u3002\u4e3a\u89e3\u91ca\u8fd9\u4e00\u70b9\uff0c\u6211\u4eec\u5bf9\u4f8b\u9898\u4e00\u7a0d\u4f5c\u62d3\u5c55\u3002

    \u4f8b\u9898\u4e8c

    \u5728\u4e8c\u53c9\u6811\u4e2d\u641c\u7d22\u6240\u6709\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\uff0c\u8fd4\u56de\u6839\u8282\u70b9\u5230\u8fd9\u4e9b\u8282\u70b9\u7684\u8def\u5f84\u3002

    \u89e3\u9898\u601d\u8def\uff1a\u5728\u4f8b\u9898\u4e00\u4ee3\u7801\u7684\u57fa\u7840\u4e0a\uff0c\u6211\u4eec\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u5217\u8868 path \u8bb0\u5f55\u8bbf\u95ee\u8fc7\u7684\u8282\u70b9\u8def\u5f84\u3002\u5f53\u8bbf\u95ee\u5230\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\u65f6\uff0c\u5219\u590d\u5236 path \u5e76\u6dfb\u52a0\u8fdb\u7ed3\u679c\u5217\u8868 res \u3002\u904d\u5386\u5b8c\u6210\u540e\uff0cres \u4e2d\u4fdd\u5b58\u7684\u5c31\u662f\u6240\u6709\u7684\u89e3\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart preorder_traversal_ii_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode root) {\nif (root == null) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.add(root);\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.add(new ArrayList<>(path));\n}\npreOrder(root.left);\npreOrder(root.right);\n// \u56de\u9000\npath.remove(path.size() - 1);\n}\n
    preorder_traversal_ii_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode *root) {\nif (root == nullptr) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push_back(root);\nif (root->val == 7) {\n// \u8bb0\u5f55\u89e3\nres.push_back(path);\n}\npreOrder(root->left);\npreOrder(root->right);\n// \u56de\u9000\npath.pop_back();\n}\n
    preorder_traversal_ii_compact.py
    def pre_order(root: TreeNode) -> None:\n\"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c\"\"\"\nif root is None:\nreturn\n# \u5c1d\u8bd5\npath.append(root)\nif root.val == 7:\n# \u8bb0\u5f55\u89e3\nres.append(list(path))\npre_order(root.left)\npre_order(root.right)\n# \u56de\u9000\npath.pop()\n
    preorder_traversal_ii_compact.go
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\nif root == nil {\nreturn\n}\n// \u5c1d\u8bd5\n*path = append(*path, root)\nif int(root.Val) == 7 {\n// \u8bb0\u5f55\u89e3\n*res = append(*res, *path)\n}\npreOrderII(root.Left, res, path)\npreOrderII(root.Right, res, path)\n// \u56de\u9000\n*path = (*path)[:len(*path)-1]\n}\n
    preorder_traversal_ii_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunction preOrder(root, path, res) {\nif (root === null) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push(root);\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push([...path]);\n}\npreOrder(root.left, path, res);\npreOrder(root.right, path, res);\n// \u56de\u9000\npath.pop();\n}\n
    preorder_traversal_ii_compact.ts
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunction preOrder(\nroot: TreeNode | null,\npath: TreeNode[],\nres: TreeNode[][]\n): void {\nif (root === null) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push(root);\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push([...path]);\n}\npreOrder(root.left, path, res);\npreOrder(root.right, path, res);\n// \u56de\u9000\npath.pop();\n}\n
    preorder_traversal_ii_compact.c
    [class]{}-[func]{preOrder}\n
    preorder_traversal_ii_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode root) {\nif (root == null) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.Add(root);\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.Add(new List<TreeNode>(path));\n}\npreOrder(root.left);\npreOrder(root.right);\n// \u56de\u9000\npath.RemoveAt(path.Count - 1);\n}\n
    preorder_traversal_ii_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunc preOrder(root: TreeNode?) {\nguard let root = root else {\nreturn\n}\n// \u5c1d\u8bd5\npath.append(root)\nif root.val == 7 {\n// \u8bb0\u5f55\u89e3\nres.append(path)\n}\npreOrder(root: root.left)\npreOrder(root: root.right)\n// \u56de\u9000\npath.removeLast()\n}\n
    preorder_traversal_ii_compact.zig
    [class]{}-[func]{preOrder}\n
    preorder_traversal_ii_compact.dart
    [class]{}-[func]{preOrder}\n

    \u5728\u6bcf\u6b21\u201c\u5c1d\u8bd5\u201d\u4e2d\uff0c\u6211\u4eec\u901a\u8fc7\u5c06\u5f53\u524d\u8282\u70b9\u6dfb\u52a0\u8fdb path \u6765\u8bb0\u5f55\u8def\u5f84\uff1b\u800c\u5728\u201c\u56de\u9000\u201d\u524d\uff0c\u6211\u4eec\u9700\u8981\u5c06\u8be5\u8282\u70b9\u4ece path \u4e2d\u5f39\u51fa\uff0c\u4ee5\u6062\u590d\u672c\u6b21\u5c1d\u8bd5\u4e4b\u524d\u7684\u72b6\u6001\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5c1d\u8bd5\u548c\u56de\u9000\u7406\u89e3\u4e3a\u201c\u524d\u8fdb\u201d\u4e0e\u201c\u64a4\u9500\u201d\uff0c\u4e24\u4e2a\u64cd\u4f5c\u662f\u4e92\u4e3a\u76f8\u53cd\u7684\u3002

    <1><2><3><4><5><6><7><8><9><10><11>

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1212","title":"12.1.2. \u00a0 \u526a\u679d","text":"

    \u590d\u6742\u7684\u56de\u6eaf\u95ee\u9898\u901a\u5e38\u5305\u542b\u4e00\u4e2a\u6216\u591a\u4e2a\u7ea6\u675f\u6761\u4ef6\uff0c\u7ea6\u675f\u6761\u4ef6\u901a\u5e38\u53ef\u7528\u4e8e\u201c\u526a\u679d\u201d\u3002

    \u4f8b\u9898\u4e09

    \u5728\u4e8c\u53c9\u6811\u4e2d\u641c\u7d22\u6240\u6709\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\uff0c\u8fd4\u56de\u6839\u8282\u70b9\u5230\u8fd9\u4e9b\u8282\u70b9\u7684\u8def\u5f84\uff0c\u8def\u5f84\u4e2d\u4e0d\u80fd\u5305\u542b\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u3002

    \u89e3\u9898\u601d\u8def\uff1a\u5728\u4f8b\u9898\u4e8c\u7684\u57fa\u7840\u4e0a\u6dfb\u52a0\u526a\u679d\u64cd\u4f5c\uff0c\u5f53\u9047\u5230\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u65f6\uff0c\u5219\u7ec8\u6b62\u7ee7\u7eed\u641c\u7d22\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart preorder_traversal_iii_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode root) {\n// \u526a\u679d\nif (root == null || root.val == 3) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.add(root);\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.add(new ArrayList<>(path));\n}\npreOrder(root.left);\npreOrder(root.right);\n// \u56de\u9000\npath.remove(path.size() - 1);\n}\n
    preorder_traversal_iii_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode *root) {\n// \u526a\u679d\nif (root == nullptr || root->val == 3) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push_back(root);\nif (root->val == 7) {\n// \u8bb0\u5f55\u89e3\nres.push_back(path);\n}\npreOrder(root->left);\npreOrder(root->right);\n// \u56de\u9000\npath.pop_back();\n}\n
    preorder_traversal_iii_compact.py
    def pre_order(root: TreeNode) -> None:\n\"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09\"\"\"\n# \u526a\u679d\nif root is None or root.val == 3:\nreturn\n# \u5c1d\u8bd5\npath.append(root)\nif root.val == 7:\n# \u8bb0\u5f55\u89e3\nres.append(list(path))\npre_order(root.left)\npre_order(root.right)\n# \u56de\u9000\npath.pop()\n
    preorder_traversal_iii_compact.go
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunc preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n// \u526a\u679d\nif root == nil || root.Val == 3 {\nreturn\n}\n// \u5c1d\u8bd5\n*path = append(*path, root)\nif int(root.Val) == 7 {\n// \u8bb0\u5f55\u89e3\n*res = append(*res, *path)\n}\npreOrderIII(root.Left, res, path)\npreOrderIII(root.Right, res, path)\n// \u56de\u9000\n*path = (*path)[:len(*path)-1]\n}\n
    preorder_traversal_iii_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunction preOrder(root, path, res) {\n// \u526a\u679d\nif (root === null || root.val === 3) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push(root);\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push([...path]);\n}\npreOrder(root.left, path, res);\npreOrder(root.right, path, res);\n// \u56de\u9000\npath.pop();\n}\n
    preorder_traversal_iii_compact.ts
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunction preOrder(\nroot: TreeNode | null,\npath: TreeNode[],\nres: TreeNode[][]\n): void {\n// \u526a\u679d\nif (root === null || root.val === 3) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push(root);\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push([...path]);\n}\npreOrder(root.left, path, res);\npreOrder(root.right, path, res);\n// \u56de\u9000\npath.pop();\n}\n
    preorder_traversal_iii_compact.c
    [class]{}-[func]{preOrder}\n
    preorder_traversal_iii_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode root) {\n// \u526a\u679d\nif (root == null || root.val == 3) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.Add(root);\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.Add(new List<TreeNode>(path));\n}\npreOrder(root.left);\npreOrder(root.right);\n// \u56de\u9000\npath.RemoveAt(path.Count - 1);\n}\n
    preorder_traversal_iii_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunc preOrder(root: TreeNode?) {\n// \u526a\u679d\nguard let root = root, root.val != 3 else {\nreturn\n}\n// \u5c1d\u8bd5\npath.append(root)\nif root.val == 7 {\n// \u8bb0\u5f55\u89e3\nres.append(path)\n}\npreOrder(root: root.left)\npreOrder(root: root.right)\n// \u56de\u9000\npath.removeLast()\n}\n
    preorder_traversal_iii_compact.zig
    [class]{}-[func]{preOrder}\n
    preorder_traversal_iii_compact.dart
    [class]{}-[func]{preOrder}\n

    \u526a\u679d\u662f\u4e00\u4e2a\u975e\u5e38\u5f62\u8c61\u7684\u540d\u8bcd\u3002\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u6211\u4eec\u5229\u7528\u7ea6\u675f\u6761\u4ef6\u201c\u526a\u6389\u201d\u4e86\u4e0d\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\u7684\u641c\u7d22\u5206\u652f\uff0c\u907f\u514d\u8bb8\u591a\u65e0\u610f\u4e49\u7684\u5c1d\u8bd5\uff0c\u4ece\u800c\u63d0\u5347\u641c\u7d22\u6548\u7387\u3002

    Fig. \u6839\u636e\u7ea6\u675f\u6761\u4ef6\u526a\u679d

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1213","title":"12.1.3. \u00a0 \u5e38\u7528\u672f\u8bed","text":"

    \u4e3a\u4e86\u66f4\u6e05\u6670\u5730\u5206\u6790\u7b97\u6cd5\u95ee\u9898\uff0c\u6211\u4eec\u603b\u7ed3\u4e00\u4e0b\u56de\u6eaf\u7b97\u6cd5\u4e2d\u5e38\u7528\u672f\u8bed\u7684\u542b\u4e49\uff0c\u5e76\u5bf9\u7167\u4f8b\u9898\u4e09\u7ed9\u51fa\u5bf9\u5e94\u793a\u4f8b\u3002

    \u540d\u8bcd \u5b9a\u4e49 \u4f8b\u9898\u4e09 \u89e3 Solution \u89e3\u662f\u6ee1\u8db3\u95ee\u9898\u7279\u5b9a\u6761\u4ef6\u7684\u7b54\u6848\u3002\u56de\u6eaf\u7b97\u6cd5\u7684\u76ee\u6807\u662f\u627e\u5230\u4e00\u4e2a\u6216\u591a\u4e2a\u6ee1\u8db3\u6761\u4ef6\u7684\u89e3 \u6839\u8282\u70b9\u5230\u8282\u70b9 \\(7\\) \u7684\u6240\u6709\u8def\u5f84\uff0c\u4e14\u8def\u5f84\u4e2d\u4e0d\u5305\u542b\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9 \u72b6\u6001 State \u72b6\u6001\u8868\u793a\u95ee\u9898\u5728\u67d0\u4e00\u65f6\u523b\u7684\u60c5\u51b5\uff0c\u5305\u62ec\u5df2\u7ecf\u505a\u51fa\u7684\u9009\u62e9 \u5f53\u524d\u5df2\u8bbf\u95ee\u7684\u8282\u70b9\u8def\u5f84\uff0c\u5373 path \u8282\u70b9\u5217\u8868 \u7ea6\u675f\u6761\u4ef6 Constraint \u7ea6\u675f\u6761\u4ef6\u662f\u95ee\u9898\u4e2d\u9650\u5236\u89e3\u7684\u53ef\u884c\u6027\u7684\u6761\u4ef6\uff0c\u901a\u5e38\u7528\u4e8e\u526a\u679d \u8981\u6c42\u8def\u5f84\u4e2d\u4e0d\u80fd\u5305\u542b\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9 \u5c1d\u8bd5 Attempt \u5c1d\u8bd5\u662f\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u6839\u636e\u5f53\u524d\u72b6\u6001\u548c\u53ef\u7528\u9009\u62e9\u6765\u63a2\u7d22\u89e3\u7a7a\u95f4\u7684\u8fc7\u7a0b\u3002\u5c1d\u8bd5\u5305\u62ec\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\uff0c\u68c0\u67e5\u662f\u5426\u4e3a\u89e3 \u9012\u5f52\u8bbf\u95ee\u5de6\uff08\u53f3\uff09\u5b50\u8282\u70b9\uff0c\u5c06\u8282\u70b9\u6dfb\u52a0\u8fdb path \uff0c\u5224\u65ad\u8282\u70b9\u7684\u503c\u662f\u5426\u4e3a \\(7\\) \u56de\u9000 Backtracking \u56de\u9000\u6307\u5728\u641c\u7d22\u4e2d\u9047\u5230\u5230\u4e0d\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\u6216\u65e0\u6cd5\u7ee7\u7eed\u641c\u7d22\u7684\u72b6\u6001\u65f6\uff0c\u64a4\u9500\u524d\u9762\u505a\u51fa\u7684\u9009\u62e9\uff0c\u56de\u5230\u4e0a\u4e00\u4e2a\u72b6\u6001 \u5f53\u8d8a\u8fc7\u53f6\u7ed3\u70b9\u3001\u7ed3\u675f\u7ed3\u70b9\u8bbf\u95ee\u3001\u9047\u5230\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u65f6\u7ec8\u6b62\u641c\u7d22\uff0c\u51fd\u6570\u8fd4\u56de \u526a\u679d Pruning \u526a\u679d\u662f\u6839\u636e\u95ee\u9898\u7279\u6027\u548c\u7ea6\u675f\u6761\u4ef6\u907f\u514d\u65e0\u610f\u4e49\u7684\u641c\u7d22\u8def\u5f84\u7684\u65b9\u6cd5\uff0c\u53ef\u63d0\u9ad8\u641c\u7d22\u6548\u7387 \u5f53\u9047\u5230\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u65f6\uff0c\u5219\u7ec8\u6b62\u7ee7\u7eed\u641c\u7d22

    Tip

    \u89e3\u3001\u72b6\u6001\u3001\u7ea6\u675f\u6761\u4ef6\u7b49\u672f\u8bed\u662f\u901a\u7528\u7684\uff0c\u9002\u7528\u4e8e\u56de\u6eaf\u7b97\u6cd5\u3001\u52a8\u6001\u89c4\u5212\u3001\u8d2a\u5fc3\u7b97\u6cd5\u7b49\u3002

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1214","title":"12.1.4. \u00a0 \u6846\u67b6\u4ee3\u7801","text":"

    \u56de\u6eaf\u7b97\u6cd5\u53ef\u7528\u4e8e\u89e3\u51b3\u8bb8\u591a\u641c\u7d22\u95ee\u9898\u3001\u7ea6\u675f\u6ee1\u8db3\u95ee\u9898\u548c\u7ec4\u5408\u4f18\u5316\u95ee\u9898\u3002\u4e3a\u63d0\u5347\u4ee3\u7801\u901a\u7528\u6027\uff0c\u6211\u4eec\u5e0c\u671b\u5c06\u56de\u6eaf\u7b97\u6cd5\u7684\u201c\u5c1d\u8bd5\u3001\u56de\u9000\u3001\u526a\u679d\u201d\u7684\u4e3b\u4f53\u6846\u67b6\u63d0\u70bc\u51fa\u6765\u3002

    \u8bbe state \u4e3a\u95ee\u9898\u7684\u5f53\u524d\u72b6\u6001\uff0cchoices \u8868\u793a\u5f53\u524d\u72b6\u6001\u4e0b\u53ef\u4ee5\u505a\u51fa\u7684\u9009\u62e9\uff0c\u5219\u53ef\u5f97\u5230\u4ee5\u4e0b\u56de\u6eaf\u7b97\u6cd5\u7684\u6846\u67b6\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State state, List<Choice> choices, List<State> res) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (Choice choice : choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State *state, vector<Choice *> &choices, vector<State *> &res) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (Choice choice : choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    def backtrack(state: State, choices: list[choice], res: list[state]) -> None:\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\u6846\u67b6\"\"\"\n# \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif is_solution(state):\n# \u8bb0\u5f55\u89e3\nrecord_solution(state, res)\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nfor choice in choices:\n# \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif is_valid(state, choice):\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmake_choice(state, choice)\nbacktrack(state, choices, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundo_choice(state, choice)\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif isSolution(state) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor _, choice := range choices {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif isValid(state, choice) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice)\nbacktrack(state, choices, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice)\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunction backtrack(state, choices, res) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (let choice of choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunction backtrack(state: State, choices: Choice[], res: State[]): void {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (let choice of choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res, numRes);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < numChoices; i++) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, &choices[i])) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, &choices[i]);\nbacktrack(state, choices, numChoices, res, numRes);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, &choices[i]);\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State state, List<Choice> choices, List<State> res) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nforeach (Choice choice in choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunc backtrack(state: inout State, choices: [Choice], res: inout [State]) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif isSolution(state: state) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state: state, res: &res)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor choice in choices {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif isValid(state: state, choice: choice) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state: &state, choice: choice)\nbacktrack(state: &state, choices: choices, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state: &state, choice: choice)\n}\n}\n}\n
    \n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State state, List<Choice>, List<State> res) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (Choice choice in choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n

    \u4e0b\u9762\uff0c\u6211\u4eec\u5c1d\u8bd5\u57fa\u4e8e\u6b64\u6846\u67b6\u6765\u89e3\u51b3\u4f8b\u9898\u4e09\u3002\u5728\u4f8b\u9898\u4e09\u4e2d\uff0c\u72b6\u6001 state \u662f\u8282\u70b9\u904d\u5386\u8def\u5f84\uff0c\u9009\u62e9 choices \u662f\u5f53\u524d\u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u548c\u53f3\u5b50\u8282\u70b9\uff0c\u7ed3\u679c res \u662f\u8def\u5f84\u5217\u8868\uff0c\u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart preorder_traversal_iii_template.java
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nboolean isSolution(List<TreeNode> state) {\nreturn !state.isEmpty() && state.get(state.size() - 1).val == 7;\n}\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {\nres.add(new ArrayList<>(state));\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nboolean isValid(List<TreeNode> state, TreeNode choice) {\nreturn choice != null && choice.val != 3;\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(List<TreeNode> state, TreeNode choice) {\nstate.add(choice);\n}\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(List<TreeNode> state, TreeNode choice) {\nstate.remove(state.size() - 1);\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nvoid backtrack(List<TreeNode> state, List<TreeNode> choices, List<List<TreeNode>> res) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (TreeNode choice : choices) {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, Arrays.asList(choice.left, choice.right), res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    preorder_traversal_iii_template.cpp
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool isSolution(vector<TreeNode *> &state) {\nreturn !state.empty() && state.back()->val == 7;\n}\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(vector<TreeNode *> &state, vector<vector<TreeNode *>> &res) {\nres.push_back(state);\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nbool isValid(vector<TreeNode *> &state, TreeNode *choice) {\nreturn choice != nullptr && choice->val != 3;\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(vector<TreeNode *> &state, TreeNode *choice) {\nstate.push_back(choice);\n}\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(vector<TreeNode *> &state, TreeNode *choice) {\nstate.pop_back();\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nvoid backtrack(vector<TreeNode *> &state, vector<TreeNode *> &choices, vector<vector<TreeNode *>> &res) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (TreeNode *choice : choices) {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nvector<TreeNode *> nextChoices{choice->left, choice->right};\nbacktrack(state, nextChoices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    preorder_traversal_iii_template.py
    def is_solution(state: list[TreeNode]) -> bool:\n\"\"\"\u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3\"\"\"\nreturn state and state[-1].val == 7\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n\"\"\"\u8bb0\u5f55\u89e3\"\"\"\nres.append(list(state))\ndef is_valid(state: list[TreeNode], choice: TreeNode) -> bool:\n\"\"\"\u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5\"\"\"\nreturn choice is not None and choice.val != 3\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n\"\"\"\u66f4\u65b0\u72b6\u6001\"\"\"\nstate.append(choice)\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n\"\"\"\u6062\u590d\u72b6\u6001\"\"\"\nstate.pop()\ndef backtrack(\nstate: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09\"\"\"\n# \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif is_solution(state):\n# \u8bb0\u5f55\u89e3\nrecord_solution(state, res)\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nfor choice in choices:\n# \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif is_valid(state, choice):\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmake_choice(state, choice)\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, [choice.left, choice.right], res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundo_choice(state, choice)\n
    preorder_traversal_iii_template.go
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunc isSolution(state *[]*TreeNode) bool {\nreturn len(*state) != 0 && (*state)[len(*state)-1].Val == 7\n}\n/* \u8bb0\u5f55\u89e3 */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n*res = append(*res, *state)\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfunc isValid(state *[]*TreeNode, choice *TreeNode) bool {\nreturn choice != nil && choice.Val != 3\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n*state = append(*state, choice)\n}\n/* \u6062\u590d\u72b6\u6001 */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n*state = (*state)[:len(*state)-1]\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunc backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif isSolution(state) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor _, choice := range *choices {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif isValid(state, choice) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\ntemp := make([]*TreeNode, 0)\ntemp = append(temp, choice.Left, choice.Right)\nbacktrackIII(state, &temp, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice)\n}\n}\n}\n
    preorder_traversal_iii_template.js
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunction isSolution(state) {\nreturn state && state[state.length - 1]?.val === 7;\n}\n/* \u8bb0\u5f55\u89e3 */\nfunction recordSolution(state, res) {\nres.push([...state]);\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfunction isValid(state, choice) {\nreturn choice !== null && choice.val !== 3;\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nfunction makeChoice(state, choice) {\nstate.push(choice);\n}\n/* \u6062\u590d\u72b6\u6001 */\nfunction undoChoice(state) {\nstate.pop();\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunction backtrack(state, choices, res) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (const choice of choices) {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, [choice.left, choice.right], res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state);\n}\n}\n}\n
    preorder_traversal_iii_template.ts
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunction isSolution(state: TreeNode[]): boolean {\nreturn state && state[state.length - 1]?.val === 7;\n}\n/* \u8bb0\u5f55\u89e3 */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\nres.push([...state]);\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfunction isValid(state: TreeNode[], choice: TreeNode): boolean {\nreturn choice !== null && choice.val !== 3;\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\nstate.push(choice);\n}\n/* \u6062\u590d\u72b6\u6001 */\nfunction undoChoice(state: TreeNode[]): void {\nstate.pop();\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunction backtrack(\nstate: TreeNode[],\nchoices: TreeNode[],\nres: TreeNode[][]\n): void {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (const choice of choices) {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, [choice.left, choice.right], res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state);\n}\n}\n}\n
    preorder_traversal_iii_template.c
    [class]{}-[func]{isSolution}\n[class]{}-[func]{recordSolution}\n[class]{}-[func]{isValid}\n[class]{}-[func]{makeChoice}\n[class]{}-[func]{undoChoice}\n[class]{}-[func]{backtrack}\n
    preorder_traversal_iii_template.cs
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool isSolution(List<TreeNode> state) {\nreturn state.Count != 0 && state[^1].val == 7;\n}\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {\nres.Add(new List<TreeNode>(state));\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nbool isValid(List<TreeNode> state, TreeNode choice) {\nreturn choice != null && choice.val != 3;\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(List<TreeNode> state, TreeNode choice) {\nstate.Add(choice);\n}\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(List<TreeNode> state, TreeNode choice) {\nstate.RemoveAt(state.Count - 1);\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nvoid backtrack(List<TreeNode> state, List<TreeNode> choices, List<List<TreeNode>> res) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nforeach (TreeNode choice in choices) {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, new List<TreeNode> { choice.left, choice.right }, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    preorder_traversal_iii_template.swift
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunc isSolution(state: [TreeNode]) -> Bool {\n!state.isEmpty && state.last!.val == 7\n}\n/* \u8bb0\u5f55\u89e3 */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\nres.append(state)\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfunc isValid(state: [TreeNode], choice: TreeNode?) -> Bool {\nchoice != nil && choice!.val != 3\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\nstate.append(choice)\n}\n/* \u6062\u590d\u72b6\u6001 */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\nstate.removeLast()\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunc backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif isSolution(state: state) {\nrecordSolution(state: state, res: &res)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor choice in choices {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif isValid(state: state, choice: choice) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state: &state, choice: choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, choices: [choice.left, choice.right].compactMap { $0 }, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state: &state, choice: choice)\n}\n}\n}\n
    preorder_traversal_iii_template.zig
    [class]{}-[func]{isSolution}\n[class]{}-[func]{recordSolution}\n[class]{}-[func]{isValid}\n[class]{}-[func]{makeChoice}\n[class]{}-[func]{undoChoice}\n[class]{}-[func]{backtrack}\n
    preorder_traversal_iii_template.dart
    [class]{}-[func]{isSolution}\n[class]{}-[func]{recordSolution}\n[class]{}-[func]{isValid}\n[class]{}-[func]{makeChoice}\n[class]{}-[func]{undoChoice}\n[class]{}-[func]{backtrack}\n

    \u76f8\u8f83\u4e8e\u57fa\u4e8e\u524d\u5e8f\u904d\u5386\u7684\u5b9e\u73b0\u4ee3\u7801\uff0c\u57fa\u4e8e\u56de\u6eaf\u7b97\u6cd5\u6846\u67b6\u7684\u5b9e\u73b0\u4ee3\u7801\u867d\u7136\u663e\u5f97\u5570\u55e6\uff0c\u4f46\u901a\u7528\u6027\u66f4\u597d\u3002\u5b9e\u9645\u4e0a\uff0c\u6240\u6709\u56de\u6eaf\u95ee\u9898\u90fd\u53ef\u4ee5\u5728\u8be5\u6846\u67b6\u4e0b\u89e3\u51b3\u3002\u6211\u4eec\u9700\u8981\u6839\u636e\u5177\u4f53\u95ee\u9898\u6765\u5b9a\u4e49 state \u548c choices \uff0c\u5e76\u5b9e\u73b0\u6846\u67b6\u4e2d\u7684\u5404\u4e2a\u65b9\u6cd5\u3002

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1215","title":"12.1.5. \u00a0 \u5178\u578b\u4f8b\u9898","text":"

    \u641c\u7d22\u95ee\u9898\uff1a\u8fd9\u7c7b\u95ee\u9898\u7684\u76ee\u6807\u662f\u627e\u5230\u6ee1\u8db3\u7279\u5b9a\u6761\u4ef6\u7684\u89e3\u51b3\u65b9\u6848\u3002

    • \u5168\u6392\u5217\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u4e2a\u96c6\u5408\uff0c\u6c42\u51fa\u5176\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u7ec4\u5408\u3002
    • \u5b50\u96c6\u548c\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u4e2a\u96c6\u5408\u548c\u4e00\u4e2a\u76ee\u6807\u548c\uff0c\u627e\u5230\u96c6\u5408\u4e2d\u6240\u6709\u548c\u4e3a\u76ee\u6807\u548c\u7684\u5b50\u96c6\u3002
    • \u6c49\u8bfa\u5854\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e09\u4e2a\u67f1\u5b50\u548c\u4e00\u7cfb\u5217\u5927\u5c0f\u4e0d\u540c\u7684\u5706\u76d8\uff0c\u8981\u6c42\u5c06\u6240\u6709\u5706\u76d8\u4ece\u4e00\u4e2a\u67f1\u5b50\u79fb\u52a8\u5230\u53e6\u4e00\u4e2a\u67f1\u5b50\uff0c\u6bcf\u6b21\u53ea\u80fd\u79fb\u52a8\u4e00\u4e2a\u5706\u76d8\uff0c\u4e14\u4e0d\u80fd\u5c06\u5927\u5706\u76d8\u653e\u5728\u5c0f\u5706\u76d8\u4e0a\u3002

    \u7ea6\u675f\u6ee1\u8db3\u95ee\u9898\uff1a\u8fd9\u7c7b\u95ee\u9898\u7684\u76ee\u6807\u662f\u627e\u5230\u6ee1\u8db3\u6240\u6709\u7ea6\u675f\u6761\u4ef6\u7684\u89e3\u3002

    • \\(n\\) \u7687\u540e\uff1a\u5728 \\(n \\times n\\) \u7684\u68cb\u76d8\u4e0a\u653e\u7f6e \\(n\\) \u4e2a\u7687\u540e\uff0c\u4f7f\u5f97\u5b83\u4eec\u4e92\u4e0d\u653b\u51fb\u3002
    • \u6570\u72ec\uff1a\u5728 \\(9 \\times 9\\) \u7684\u7f51\u683c\u4e2d\u586b\u5165\u6570\u5b57 \\(1\\) ~ \\(9\\) \uff0c\u4f7f\u5f97\u6bcf\u884c\u3001\u6bcf\u5217\u548c\u6bcf\u4e2a \\(3 \\times 3\\) \u5b50\u7f51\u683c\u4e2d\u7684\u6570\u5b57\u4e0d\u91cd\u590d\u3002
    • \u56fe\u7740\u8272\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u4e2a\u65e0\u5411\u56fe\uff0c\u7528\u6700\u5c11\u7684\u989c\u8272\u7ed9\u56fe\u7684\u6bcf\u4e2a\u9876\u70b9\u7740\u8272\uff0c\u4f7f\u5f97\u76f8\u90bb\u9876\u70b9\u989c\u8272\u4e0d\u540c\u3002

    \u7ec4\u5408\u4f18\u5316\u95ee\u9898\uff1a\u8fd9\u7c7b\u95ee\u9898\u7684\u76ee\u6807\u662f\u5728\u4e00\u4e2a\u7ec4\u5408\u7a7a\u95f4\u4e2d\u627e\u5230\u6ee1\u8db3\u67d0\u4e9b\u6761\u4ef6\u7684\u6700\u4f18\u89e3\u3002

    • 0-1 \u80cc\u5305\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u7ec4\u7269\u54c1\u548c\u4e00\u4e2a\u80cc\u5305\uff0c\u6bcf\u4e2a\u7269\u54c1\u6709\u4e00\u5b9a\u7684\u4ef7\u503c\u548c\u91cd\u91cf\uff0c\u8981\u6c42\u5728\u80cc\u5305\u5bb9\u91cf\u9650\u5236\u5185\uff0c\u9009\u62e9\u7269\u54c1\u4f7f\u5f97\u603b\u4ef7\u503c\u6700\u5927\u3002
    • \u65c5\u884c\u5546\u95ee\u9898\uff1a\u5728\u4e00\u4e2a\u56fe\u4e2d\uff0c\u4ece\u4e00\u4e2a\u70b9\u51fa\u53d1\uff0c\u8bbf\u95ee\u6240\u6709\u5176\u4ed6\u70b9\u6070\u597d\u4e00\u6b21\u540e\u8fd4\u56de\u8d77\u70b9\uff0c\u6c42\u6700\u77ed\u8def\u5f84\u3002
    • \u6700\u5927\u56e2\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u4e2a\u65e0\u5411\u56fe\uff0c\u627e\u5230\u6700\u5927\u7684\u5b8c\u5168\u5b50\u56fe\uff0c\u5373\u5b50\u56fe\u4e2d\u7684\u4efb\u610f\u4e24\u4e2a\u9876\u70b9\u4e4b\u95f4\u90fd\u6709\u8fb9\u76f8\u8fde\u3002

    \u8bf7\u6ce8\u610f\uff0c\u56de\u6eaf\u7b97\u6cd5\u901a\u5e38\u4e0d\u662f\u89e3\u51b3\u7ec4\u5408\u4f18\u5316\u95ee\u9898\u7684\u6700\u4f18\u65b9\u6cd5\u30020-1 \u80cc\u5305\u95ee\u9898\u901a\u5e38\u4f7f\u7528\u52a8\u6001\u89c4\u5212\u89e3\u51b3\uff1b\u65c5\u884c\u5546\u662f\u4e00\u4e2a NP-Hard \u95ee\u9898\uff0c\u5e38\u7528\u89e3\u51b3\u65b9\u6cd5\u6709\u9057\u4f20\u7b97\u6cd5\u548c\u8681\u7fa4\u7b97\u6cd5\u7b49\uff1b\u6700\u5927\u56e2\u95ee\u9898\u662f\u56fe\u8f6e\u4e2d\u7684\u4e00\u4e2a\u7ecf\u5178 NP-Hard \u95ee\u9898\uff0c\u901a\u5e38\u7528\u8d2a\u5fc3\u7b97\u6cd5\u7b49\u542f\u53d1\u5f0f\u7b97\u6cd5\u6765\u89e3\u51b3\u3002

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1216","title":"12.1.6. \u00a0 \u4f18\u52bf\u4e0e\u5c40\u9650\u6027","text":"

    \u56de\u6eaf\u7b97\u6cd5\u672c\u8d28\u4e0a\u662f\u4e00\u79cd\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u7b97\u6cd5\uff0c\u5b83\u5c1d\u8bd5\u6240\u6709\u53ef\u80fd\u7684\u89e3\u51b3\u65b9\u6848\u76f4\u5230\u627e\u5230\u6ee1\u8db3\u6761\u4ef6\u7684\u89e3\u3002\u8fd9\u79cd\u65b9\u6cd5\u7684\u4f18\u52bf\u5728\u4e8e\u5b83\u80fd\u591f\u627e\u5230\u6240\u6709\u53ef\u80fd\u7684\u89e3\u51b3\u65b9\u6848\uff0c\u800c\u4e14\u5728\u5408\u7406\u7684\u526a\u679d\u64cd\u4f5c\u4e0b\uff0c\u5177\u6709\u5f88\u9ad8\u7684\u6548\u7387\u3002

    \u7136\u800c\uff0c\u5728\u5904\u7406\u5927\u89c4\u6a21\u6216\u8005\u590d\u6742\u95ee\u9898\u65f6\uff0c\u56de\u6eaf\u7b97\u6cd5\u7684\u8fd0\u884c\u6548\u7387\u53ef\u80fd\u96be\u4ee5\u63a5\u53d7\u3002\u8fd9\u662f\u56e0\u4e3a\u5728\u6700\u574f\u7684\u60c5\u51b5\u4e0b\uff0c\u56de\u6eaf\u7b97\u6cd5\u9700\u8981\u904d\u5386\u89e3\u7a7a\u95f4\u7684\u6240\u6709\u53ef\u80fd\u89e3\u3002\u4f8b\u5982\uff0c\u6c42\u89e3 \\(n\\) \u7687\u540e\u95ee\u9898\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u8fbe\u5230 \\(O(n!)\\) \u3002\u56de\u6eaf\u7b97\u6cd5\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4e5f\u53ef\u80fd\u8f83\u9ad8\u3002\u56e0\u4e3a\u5728\u6bcf\u4e00\u6b21\u9012\u5f52\u8c03\u7528\u65f6\uff0c\u90fd\u9700\u8981\u4fdd\u5b58\u5f53\u524d\u7684\u72b6\u6001\uff08\u4f8b\u5982\u9009\u62e9\u8def\u5f84\u3001\u7528\u4e8e\u526a\u679d\u7684\u8f85\u52a9\u53d8\u91cf\u7b49\uff09\uff0c\u5bf9\u4e8e\u6df1\u5ea6\u5f88\u5927\u7684\u9012\u5f52\uff0c\u7a7a\u95f4\u9700\u6c42\u53ef\u80fd\u4f1a\u53d8\u5f97\u975e\u5e38\u5927\u3002

    \u5373\u4fbf\u5982\u6b64\uff0c\u56de\u6eaf\u7b97\u6cd5\u4ecd\u7136\u662f\u67d0\u4e9b\u641c\u7d22\u95ee\u9898\u548c\u7ea6\u675f\u6ee1\u8db3\u95ee\u9898\u7684\u6700\u4f73\u89e3\u51b3\u65b9\u6848\u3002\u5bf9\u4e8e\u8fd9\u4e9b\u95ee\u9898\uff0c\u7531\u4e8e\u6211\u4eec\u65e0\u6cd5\u9884\u6d4b\u54ea\u4e9b\u9009\u62e9\u53ef\u751f\u6210\u6709\u6548\u7684\u89e3\uff0c\u56e0\u6b64\u6211\u4eec\u5fc5\u987b\u5bf9\u6240\u6709\u53ef\u80fd\u7684\u9009\u62e9\u8fdb\u884c\u904d\u5386\u3002\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u5173\u952e\u662f\u5982\u4f55\u8fdb\u884c\u6548\u7387\u4f18\u5316\uff1a

    • \u4e0a\u6587\u4ecb\u7ecd\u8fc7\u7684\u526a\u679d\u662f\u4e00\u79cd\u5e38\u7528\u7684\u4f18\u5316\u65b9\u6cd5\u3002\u5b83\u53ef\u4ee5\u907f\u514d\u641c\u7d22\u90a3\u4e9b\u80af\u5b9a\u4e0d\u4f1a\u4ea7\u751f\u6709\u6548\u89e3\u7684\u8def\u5f84\uff0c\u4ece\u800c\u8282\u7701\u65f6\u95f4\u548c\u7a7a\u95f4\u3002
    • \u53e6\u4e00\u4e2a\u5e38\u7528\u7684\u4f18\u5316\u65b9\u6cd5\u662f\u52a0\u5165\u300c\u542f\u53d1\u5f0f\u641c\u7d22 Heuristic Search\u300d\u7b56\u7565\uff0c\u5b83\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u5f15\u5165\u4e00\u4e9b\u7b56\u7565\u6216\u8005\u4f30\u8ba1\u503c\uff0c\u4ece\u800c\u4f18\u5148\u641c\u7d22\u6700\u6709\u53ef\u80fd\u4ea7\u751f\u6709\u6548\u89e3\u7684\u8def\u5f84\u3002
    "},{"location":"chapter_backtracking/n_queens_problem/","title":"12.4. \u00a0 N \u7687\u540e\u95ee\u9898","text":"

    Question

    \u6839\u636e\u56fd\u9645\u8c61\u68cb\u7684\u89c4\u5219\uff0c\u7687\u540e\u53ef\u4ee5\u653b\u51fb\u4e0e\u4e4b\u5904\u5728\u540c\u4e00\u884c\u6216\u540c\u4e00\u5217\u6216\u540c\u4e00\u659c\u7ebf\u4e0a\u7684\u68cb\u5b50\u3002\u7ed9\u5b9a \\(n\\) \u4e2a\u7687\u540e\u548c\u4e00\u4e2a \\(n \\times n\\) \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5bfb\u627e\u4f7f\u5f97\u6240\u6709\u7687\u540e\u4e4b\u95f4\u65e0\u6cd5\u76f8\u4e92\u653b\u51fb\u7684\u6446\u653e\u65b9\u6848\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5f53 \\(n = 4\\) \u65f6\uff0c\u5171\u53ef\u4ee5\u627e\u5230\u4e24\u4e2a\u89e3\u3002\u4ece\u56de\u6eaf\u7b97\u6cd5\u7684\u89d2\u5ea6\u770b\uff0c\\(n \\times n\\) \u5927\u5c0f\u7684\u68cb\u76d8\u5171\u6709 \\(n^2\\) \u4e2a\u683c\u5b50\uff0c\u7ed9\u51fa\u4e86\u6240\u6709\u7684\u9009\u62e9 choices \u3002\u5728\u9010\u4e2a\u653e\u7f6e\u7687\u540e\u7684\u8fc7\u7a0b\u4e2d\uff0c\u68cb\u76d8\u72b6\u6001\u5728\u4e0d\u65ad\u5730\u53d8\u5316\uff0c\u6bcf\u4e2a\u65f6\u523b\u7684\u68cb\u76d8\u5c31\u662f\u72b6\u6001 state \u3002

    Fig. 4 \u7687\u540e\u95ee\u9898\u7684\u89e3

    \u672c\u9898\u5171\u6709\u4e09\u4e2a\u7ea6\u675f\u6761\u4ef6\uff1a\u591a\u4e2a\u7687\u540e\u4e0d\u80fd\u5728\u540c\u4e00\u884c\u3001\u540c\u4e00\u5217\u548c\u540c\u4e00\u5bf9\u89d2\u7ebf\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u5bf9\u89d2\u7ebf\u5206\u4e3a\u4e3b\u5bf9\u89d2\u7ebf \\ \u548c\u526f\u5bf9\u89d2\u7ebf / \u4e24\u79cd\u3002

    Fig. n \u7687\u540e\u95ee\u9898\u7684\u7ea6\u675f\u6761\u4ef6

    \u7687\u540e\u7684\u6570\u91cf\u548c\u68cb\u76d8\u7684\u884c\u6570\u90fd\u4e3a \\(n\\) \uff0c\u56e0\u6b64\u6211\u4eec\u5bb9\u6613\u5f97\u5230\u7b2c\u4e00\u4e2a\u63a8\u8bba\uff1a\u68cb\u76d8\u6bcf\u884c\u90fd\u5141\u8bb8\u4e14\u53ea\u5141\u8bb8\u653e\u7f6e\u4e00\u4e2a\u7687\u540e\u3002\u8fd9\u610f\u5473\u7740\uff0c\u6211\u4eec\u53ef\u4ee5\u91c7\u53d6\u9010\u884c\u653e\u7f6e\u7b56\u7565\uff1a\u4ece\u7b2c\u4e00\u884c\u5f00\u59cb\uff0c\u5728\u6bcf\u884c\u653e\u7f6e\u4e00\u4e2a\u7687\u540e\uff0c\u76f4\u81f3\u6700\u540e\u4e00\u884c\u7ed3\u675f\u3002\u6b64\u7b56\u7565\u8d77\u5230\u4e86\u526a\u679d\u7684\u4f5c\u7528\uff0c\u5b83\u907f\u514d\u4e86\u540c\u4e00\u884c\u51fa\u73b0\u591a\u4e2a\u7687\u540e\u7684\u6240\u6709\u641c\u7d22\u5206\u652f\u3002

    \u4e0b\u56fe\u5c55\u793a\u4e86 \\(4\\) \u7687\u540e\u95ee\u9898\u7684\u9010\u884c\u653e\u7f6e\u8fc7\u7a0b\u3002\u53d7\u7bc7\u5e45\u9650\u5236\uff0c\u4e0b\u56fe\u4ec5\u5c55\u5f00\u4e86\u7b2c\u4e00\u884c\u7684\u4e00\u4e2a\u641c\u7d22\u5206\u652f\u3002\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u6211\u4eec\u5c06\u4e0d\u6ee1\u8db3\u5217\u7ea6\u675f\u548c\u5bf9\u89d2\u7ebf\u7ea6\u675f\u7684\u65b9\u6848\u90fd\u526a\u679d\u4e86\u3002

    Fig. \u9010\u884c\u653e\u7f6e\u7b56\u7565

    \u4e3a\u4e86\u5b9e\u73b0\u6839\u636e\u5217\u7ea6\u675f\u526a\u679d\uff0c\u6211\u4eec\u53ef\u4ee5\u5229\u7528\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u5e03\u5c14\u578b\u6570\u7ec4 cols \u8bb0\u5f55\u6bcf\u4e00\u5217\u662f\u5426\u6709\u7687\u540e\u3002\u5728\u6bcf\u6b21\u51b3\u5b9a\u653e\u7f6e\u524d\uff0c\u6211\u4eec\u901a\u8fc7 cols \u5c06\u5df2\u6709\u7687\u540e\u7684\u5217\u526a\u679d\uff0c\u5e76\u5728\u56de\u6eaf\u4e2d\u52a8\u6001\u66f4\u65b0 cols \u7684\u72b6\u6001\u3002

    \u90a3\u4e48\uff0c\u5982\u4f55\u5904\u7406\u5bf9\u89d2\u7ebf\u7ea6\u675f\u5462\uff1f\u8bbe\u68cb\u76d8\u4e2d\u67d0\u4e2a\u683c\u5b50\u7684\u884c\u5217\u7d22\u5f15\u4e3a (row, col) \uff0c\u89c2\u5bdf\u77e9\u9635\u7684\u67d0\u6761\u4e3b\u5bf9\u89d2\u7ebf\uff0c\u6211\u4eec\u53d1\u73b0\u8be5\u5bf9\u89d2\u7ebf\u4e0a\u6240\u6709\u683c\u5b50\u7684\u884c\u7d22\u5f15\u51cf\u5217\u7d22\u5f15\u76f8\u7b49\uff0c\u5373 row - col \u4e3a\u6052\u5b9a\u503c\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u82e5\u4e24\u4e2a\u683c\u5b50\u6ee1\u8db3 row1 - col1 == row2 - col2 \uff0c\u5219\u8fd9\u4e24\u4e2a\u683c\u5b50\u4e00\u5b9a\u5904\u5728\u4e00\u6761\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u3002

    \u5229\u7528\u8be5\u6027\u8d28\uff0c\u6211\u4eec\u53ef\u4ee5\u501f\u52a9\u4e00\u4e2a\u6570\u7ec4 diag1 \u6765\u8bb0\u5f55\u6bcf\u6761\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\u3002\u6ce8\u610f\uff0c\\(n\\) \u7ef4\u65b9\u9635 row - col \u7684\u8303\u56f4\u662f \\([-n + 1, n - 1]\\) \uff0c\u56e0\u6b64\u5171\u6709 \\(2n - 1\\) \u6761\u4e3b\u5bf9\u89d2\u7ebf\u3002

    Fig. \u5904\u7406\u5217\u7ea6\u675f\u548c\u5bf9\u89d2\u7ebf\u7ea6\u675f

    \u540c\u7406\uff0c\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u7684\u6240\u6709\u683c\u5b50\u7684 row + col \u662f\u6052\u5b9a\u503c\u3002\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u540c\u6837\u7684\u65b9\u6cd5\uff0c\u501f\u52a9\u6570\u7ec4 diag2 \u6765\u5904\u7406\u6b21\u5bf9\u89d2\u7ebf\u7ea6\u675f\u3002

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u6211\u4eec\u4fbf\u53ef\u4ee5\u5199\u51fa \\(n\\) \u7687\u540e\u7684\u89e3\u9898\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart n_queens.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nvoid backtrack(int row, int n, List<List<String>> state, List<List<List<String>>> res,\nboolean[] cols, boolean[] diags1, boolean[] diags2) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (row == n) {\nList<List<String>> copyState = new ArrayList<>();\nfor (List<String> sRow : state) {\ncopyState.add(new ArrayList<>(sRow));\n}\nres.add(copyState);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor (int col = 0; col < n; col++) {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nint diag1 = row - col + n - 1;\nint diag2 = row + col;\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate.get(row).set(col, \"Q\");\ncols[col] = diags1[diag1] = diags2[diag2] = true;\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2);\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate.get(row).set(col, \"#\");\ncols[col] = diags1[diag1] = diags2[diag2] = false;\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nList<List<List<String>>> nQueens(int n) {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nList<List<String>> state = new ArrayList<>();\nfor (int i = 0; i < n; i++) {\nList<String> row = new ArrayList<>();\nfor (int j = 0; j < n; j++) {\nrow.add(\"#\");\n}\nstate.add(row);\n}\nboolean[] cols = new boolean[n]; // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nboolean[] diags1 = new boolean[2 * n - 1]; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nboolean[] diags2 = new boolean[2 * n - 1]; // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nList<List<List<String>>> res = new ArrayList<>();\nbacktrack(0, n, state, res, cols, diags1, diags2);\nreturn res;\n}\n
    n_queens.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nvoid backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,\nvector<bool> &diags1, vector<bool> &diags2) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (row == n) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor (int col = 0; col < n; col++) {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nint diag1 = row - col + n - 1;\nint diag2 = row + col;\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = \"Q\";\ncols[col] = diags1[diag1] = diags2[diag2] = true;\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2);\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = \"#\";\ncols[col] = diags1[diag1] = diags2[diag2] = false;\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nvector<vector<vector<string>>> nQueens(int n) {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nvector<vector<string>> state(n, vector<string>(n, \"#\"));\nvector<bool> cols(n, false);           // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nvector<bool> diags1(2 * n - 1, false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nvector<bool> diags2(2 * n - 1, false); // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nvector<vector<vector<string>>> res;\nbacktrack(0, n, state, res, cols, diags1, diags2);\nreturn res;\n}\n
    n_queens.py
    def backtrack(\nrow: int,\nn: int,\nstate: list[list[str]],\nres: list[list[list[str]]],\ncols: list[bool],\ndiags1: list[bool],\ndiags2: list[bool],\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e\"\"\"\n# \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif row == n:\nres.append([list(row) for row in state])\nreturn\n# \u904d\u5386\u6240\u6709\u5217\nfor col in range(n):\n# \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\ndiag1 = row - col + n - 1\ndiag2 = row + col\n# \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif not cols[col] and not diags1[diag1] and not diags2[diag2]:\n# \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = \"Q\"\ncols[col] = diags1[diag1] = diags2[diag2] = True\n# \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2)\n# \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = \"#\"\ncols[col] = diags1[diag1] = diags2[diag2] = False\ndef n_queens(n: int) -> list[list[list[str]]]:\n\"\"\"\u6c42\u89e3 N \u7687\u540e\"\"\"\n# \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nstate = [[\"#\" for _ in range(n)] for _ in range(n)]\ncols = [False] * n  # \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\ndiags1 = [False] * (2 * n - 1)  # \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\ndiags2 = [False] * (2 * n - 1)  # \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nres = []\nbacktrack(0, n, state, res, cols, diags1, diags2)\nreturn res\n
    n_queens.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif row == n {\nnewState := make([][]string, len(*state))\nfor i, _ := range newState {\nnewState[i] = make([]string, len((*state)[0]))\ncopy(newState[i], (*state)[i])\n}\n*res = append(*res, newState)\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor col := 0; col < n; col++ {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\ndiag1 := row - col + n - 1\ndiag2 := row + col\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\n(*state)[row][col] = \"Q\"\n(*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row+1, n, state, res, cols, diags1, diags2)\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\n(*state)[row][col] = \"#\"\n(*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n}\n}\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif row == n {\nnewState := make([][]string, len(*state))\nfor i, _ := range newState {\nnewState[i] = make([]string, len((*state)[0]))\ncopy(newState[i], (*state)[i])\n}\n*res = append(*res, newState)\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor col := 0; col < n; col++ {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\ndiag1 := row - col + n - 1\ndiag2 := row + col\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\n(*state)[row][col] = \"Q\"\n(*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row+1, n, state, res, cols, diags1, diags2)\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\n(*state)[row][col] = \"#\"\n(*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n}\n}\n}\nfunc nQueens(n int) [][][]string {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nstate := make([][]string, n)\nfor i := 0; i < n; i++ {\nrow := make([]string, n)\nfor i := 0; i < n; i++ {\nrow[i] = \"#\"\n}\nstate[i] = row\n}\n// \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\ncols := make([]bool, n)\ndiags1 := make([]bool, 2*n-1)\ndiags2 := make([]bool, 2*n-1)\nres := make([][][]string, 0)\nbacktrack(0, n, &state, &res, &cols, &diags1, &diags2)\nreturn res\n}\n
    n_queens.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nfunction backtrack(row, n, state, res, cols, diags1, diags2) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (row === n) {\nres.push(state.map((row) => row.slice()));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor (let col = 0; col < n; col++) {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nconst diag1 = row - col + n - 1;\nconst diag2 = row + col;\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = 'Q';\ncols[col] = diags1[diag1] = diags2[diag2] = true;\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2);\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = '#';\ncols[col] = diags1[diag1] = diags2[diag2] = false;\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nfunction nQueens(n) {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nconst state = Array.from({ length: n }, () => Array(n).fill('#'));\nconst cols = Array(n).fill(false); // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nconst diags1 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nconst diags2 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nconst res = [];\nbacktrack(0, n, state, res, cols, diags1, diags2);\nreturn res;\n}\n
    n_queens.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nfunction backtrack(\nrow: number,\nn: number,\nstate: string[][],\nres: string[][][],\ncols: boolean[],\ndiags1: boolean[],\ndiags2: boolean[]\n): void {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (row === n) {\nres.push(state.map((row) => row.slice()));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor (let col = 0; col < n; col++) {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nconst diag1 = row - col + n - 1;\nconst diag2 = row + col;\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = 'Q';\ncols[col] = diags1[diag1] = diags2[diag2] = true;\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2);\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = '#';\ncols[col] = diags1[diag1] = diags2[diag2] = false;\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nfunction nQueens(n: number): string[][][] {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nconst state = Array.from({ length: n }, () => Array(n).fill('#'));\nconst cols = Array(n).fill(false); // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nconst diags1 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nconst diags2 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nconst res: string[][][] = [];\nbacktrack(0, n, state, res, cols, diags1, diags2);\nreturn res;\n}\n
    n_queens.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{nQueens}\n
    n_queens.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nvoid backtrack(int row, int n, List<List<string>> state, List<List<List<string>>> res,\nbool[] cols, bool[] diags1, bool[] diags2) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (row == n) {\nList<List<string>> copyState = new List<List<string>>();\nforeach (List<string> sRow in state) {\ncopyState.Add(new List<string>(sRow));\n}\nres.Add(copyState);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor (int col = 0; col < n; col++) {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nint diag1 = row - col + n - 1;\nint diag2 = row + col;\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = \"Q\";\ncols[col] = diags1[diag1] = diags2[diag2] = true;\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2);\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = \"#\";\ncols[col] = diags1[diag1] = diags2[diag2] = false;\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nList<List<List<string>>> nQueens(int n) {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nList<List<string>> state = new List<List<string>>();\nfor (int i = 0; i < n; i++) {\nList<string> row = new List<string>();\nfor (int j = 0; j < n; j++) {\nrow.Add(\"#\");\n}\nstate.Add(row);\n}\nbool[] cols = new bool[n]; // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nbool[] diags1 = new bool[2 * n - 1]; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nbool[] diags2 = new bool[2 * n - 1]; // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nList<List<List<string>>> res = new List<List<List<string>>>();\nbacktrack(0, n, state, res, cols, diags1, diags2);\nreturn res;\n}\n
    n_queens.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nfunc backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif row == n {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor col in 0 ..< n {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nlet diag1 = row - col + n - 1\nlet diag2 = row + col\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif !cols[col] && !diags1[diag1] && !diags2[diag2] {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = \"Q\"\ncols[col] = true\ndiags1[diag1] = true\ndiags2[diag2] = true\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row: row + 1, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = \"#\"\ncols[col] = false\ndiags1[diag1] = false\ndiags2[diag2] = false\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nfunc nQueens(n: Int) -> [[[String]]] {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nvar state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\nvar cols = Array(repeating: false, count: n) // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nvar diags1 = Array(repeating: false, count: 2 * n - 1) // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nvar diags2 = Array(repeating: false, count: 2 * n - 1) // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nvar res: [[[String]]] = []\nbacktrack(row: 0, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)\nreturn res\n}\n
    n_queens.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{nQueens}\n
    n_queens.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{nQueens}\n
    "},{"location":"chapter_backtracking/n_queens_problem/#1241","title":"12.4.1. \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"

    \u9010\u884c\u653e\u7f6e \\(n\\) \u6b21\uff0c\u8003\u8651\u5217\u7ea6\u675f\uff0c\u5219\u4ece\u7b2c\u4e00\u884c\u5230\u6700\u540e\u4e00\u884c\u5206\u522b\u6709 \\(n, n-1, \\cdots, 2, 1\\) \u4e2a\u9009\u62e9\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n!)\\) \u3002\u5b9e\u9645\u4e0a\uff0c\u6839\u636e\u5bf9\u89d2\u7ebf\u7ea6\u675f\u7684\u526a\u679d\u4e5f\u80fd\u591f\u5927\u5e45\u5730\u7f29\u5c0f\u641c\u7d22\u7a7a\u95f4\uff0c\u56e0\u800c\u641c\u7d22\u6548\u7387\u5f80\u5f80\u4f18\u4e8e\u4ee5\u4e0a\u65f6\u95f4\u590d\u6742\u5ea6\u3002

    state \u4f7f\u7528 \\(O(n^2)\\) \u7a7a\u95f4\uff0ccols , diags1 , diags2 \u7686\u4f7f\u7528 \\(O(n)\\) \u7a7a\u95f4\u3002\u6700\u5927\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \uff0c\u4f7f\u7528 \\(O(n)\\) \u6808\u5e27\u7a7a\u95f4\u3002\u56e0\u6b64\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    "},{"location":"chapter_backtracking/permutations_problem/","title":"12.2. \u00a0 \u5168\u6392\u5217\u95ee\u9898","text":"

    \u5168\u6392\u5217\u95ee\u9898\u662f\u56de\u6eaf\u7b97\u6cd5\u7684\u4e00\u4e2a\u5178\u578b\u5e94\u7528\u3002\u5b83\u7684\u5b9a\u4e49\u662f\u5728\u7ed9\u5b9a\u4e00\u4e2a\u96c6\u5408\uff08\u5982\u4e00\u4e2a\u6570\u7ec4\u6216\u5b57\u7b26\u4e32\uff09\u7684\u60c5\u51b5\u4e0b\uff0c\u627e\u51fa\u8fd9\u4e2a\u96c6\u5408\u4e2d\u5143\u7d20\u7684\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u3002

    \u5982\u4e0b\u8868\u6240\u793a\uff0c\u5217\u4e3e\u4e86\u51e0\u4e2a\u793a\u4f8b\u6570\u7ec4\u548c\u5176\u5bf9\u5e94\u7684\u6240\u6709\u6392\u5217\u3002

    \u8f93\u5165\u6570\u7ec4 \u6240\u6709\u6392\u5217 \\([1]\\) \\([1]\\) \\([1, 2]\\) \\([1, 2], [2, 1]\\) \\([1, 2, 3]\\) \\([1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]\\)"},{"location":"chapter_backtracking/permutations_problem/#1221","title":"12.2.1. \u00a0 \u65e0\u91cd\u590d\u7684\u60c5\u51b5","text":"

    Question

    \u8f93\u5165\u4e00\u4e2a\u6574\u6570\u6570\u7ec4\uff0c\u6570\u7ec4\u4e2d\u4e0d\u5305\u542b\u91cd\u590d\u5143\u7d20\uff0c\u8fd4\u56de\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u3002

    \u4ece\u56de\u6eaf\u7b97\u6cd5\u7684\u89d2\u5ea6\u770b\uff0c\u6211\u4eec\u53ef\u4ee5\u628a\u751f\u6210\u6392\u5217\u7684\u8fc7\u7a0b\u60f3\u8c61\u6210\u4e00\u7cfb\u5217\u9009\u62e9\u7684\u7ed3\u679c\u3002\u5047\u8bbe\u8f93\u5165\u6570\u7ec4\u4e3a \\([1, 2, 3]\\) \uff0c\u5982\u679c\u6211\u4eec\u5148\u9009\u62e9 \\(1\\) \u3001\u518d\u9009\u62e9 \\(3\\) \u3001\u6700\u540e\u9009\u62e9 \\(2\\) \uff0c\u5219\u83b7\u5f97\u6392\u5217 \\([1, 3, 2]\\) \u3002\u56de\u9000\u8868\u793a\u64a4\u9500\u4e00\u4e2a\u9009\u62e9\uff0c\u4e4b\u540e\u7ee7\u7eed\u5c1d\u8bd5\u5176\u4ed6\u9009\u62e9\u3002

    \u4ece\u56de\u6eaf\u7b97\u6cd5\u4ee3\u7801\u7684\u89d2\u5ea6\u770b\uff0c\u5019\u9009\u96c6\u5408 choices \u662f\u8f93\u5165\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\uff0c\u72b6\u6001 state \u662f\u76f4\u81f3\u76ee\u524d\u5df2\u88ab\u9009\u62e9\u7684\u5143\u7d20\u3002\u6ce8\u610f\uff0c\u6bcf\u4e2a\u5143\u7d20\u53ea\u5141\u8bb8\u88ab\u9009\u62e9\u4e00\u6b21\uff0c\u56e0\u6b64\u5728\u904d\u5386\u9009\u62e9\u65f6\uff0c\u5e94\u5f53\u6392\u9664\u5df2\u7ecf\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u641c\u7d22\u8fc7\u7a0b\u5c55\u5f00\u6210\u4e00\u4e2a\u9012\u5f52\u6811\uff0c\u6811\u4e2d\u7684\u6bcf\u4e2a\u8282\u70b9\u4ee3\u8868\u5f53\u524d\u72b6\u6001 state \u3002\u4ece\u6839\u8282\u70b9\u5f00\u59cb\uff0c\u7ecf\u8fc7\u4e09\u8f6e\u9009\u62e9\u540e\u5230\u8fbe\u53f6\u8282\u70b9\uff0c\u6bcf\u4e2a\u53f6\u8282\u70b9\u90fd\u5bf9\u5e94\u4e00\u4e2a\u6392\u5217\u3002

    Fig. \u5168\u6392\u5217\u7684\u9012\u5f52\u6811

    \u60f3\u6e05\u695a\u4ee5\u4e0a\u4fe1\u606f\u4e4b\u540e\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5728\u6846\u67b6\u4ee3\u7801\u4e2d\u505a\u201c\u5b8c\u5f62\u586b\u7a7a\u201d\u4e86\u3002\u4e3a\u4e86\u7f29\u77ed\u4ee3\u7801\u884c\u6570\uff0c\u6211\u4eec\u4e0d\u5355\u72ec\u5b9e\u73b0\u6846\u67b6\u4ee3\u7801\u4e2d\u7684\u5404\u4e2a\u51fd\u6570\uff0c\u800c\u662f\u5c06\u4ed6\u4eec\u5c55\u5f00\u5728 backtrack() \u51fd\u6570\u4e2d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart permutations_i.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nvoid backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.size() == choices.length) {\nres.add(new ArrayList<Integer>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < choices.length; i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i]) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true;\nstate.add(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.remove(state.size() - 1);\n}\n}\n}\n/* \u5168\u6392\u5217 I */\nList<List<Integer>> permutationsI(int[] nums) {\nList<List<Integer>> res = new ArrayList<List<Integer>>();\nbacktrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);\nreturn res;\n}\n
    permutations_i.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nvoid backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.size() == choices.size()) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < choices.size(); i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i]) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true;\nstate.push_back(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop_back();\n}\n}\n}\n/* \u5168\u6392\u5217 I */\nvector<vector<int>> permutationsI(vector<int> nums) {\nvector<int> state;\nvector<bool> selected(nums.size(), false);\nvector<vector<int>> res;\nbacktrack(state, nums, selected, res);\nreturn res;\n}\n
    permutations_i.py
    def backtrack(\nstate: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I\"\"\"\n# \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif len(state) == len(choices):\nres.append(list(state))\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nfor i, choice in enumerate(choices):\n# \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\nif not selected[i]:\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = True\nstate.append(choice)\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = False\nstate.pop()\ndef permutations_i(nums: list[int]) -> list[list[int]]:\n\"\"\"\u5168\u6392\u5217 I\"\"\"\nres = []\nbacktrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\nreturn res\n
    permutations_i.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfunc backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif len(*state) == len(*choices) {\nnewState := append([]int{}, *state...)\n*res = append(*res, newState)\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor i := 0; i < len(*choices); i++ {\nchoice := (*choices)[i]\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif !(*selected)[i] {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n(*selected)[i] = true\n*state = append(*state, choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrackI(state, choices, selected, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n(*selected)[i] = false\n*state = (*state)[:len(*state)-1]\n}\n}\n}\n/* \u5168\u6392\u5217 I */\nfunc permutationsI(nums []int) [][]int {\nres := make([][]int, 0)\nstate := make([]int, 0)\nselected := make([]bool, len(nums))\nbacktrackI(&state, &nums, &selected, &res)\nreturn res\n}\n
    permutations_i.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfunction backtrack(state, choices, selected, res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.length === choices.length) {\nres.push([...state]);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nchoices.forEach((choice, i) => {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i]) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true;\nstate.push(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop();\n}\n});\n}\n/* \u5168\u6392\u5217 I */\nfunction permutationsI(nums) {\nconst res = [];\nbacktrack([], nums, Array(nums.length).fill(false), res);\nreturn res;\n}\n
    permutations_i.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfunction backtrack(\nstate: number[],\nchoices: number[],\nselected: boolean[],\nres: number[][]\n): void {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.length === choices.length) {\nres.push([...state]);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nchoices.forEach((choice, i) => {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i]) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true;\nstate.push(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop();\n}\n});\n}\n/* \u5168\u6392\u5217 I */\nfunction permutationsI(nums: number[]): number[][] {\nconst res: number[][] = [];\nbacktrack([], nums, Array(nums.length).fill(false), res);\nreturn res;\n}\n
    permutations_i.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsI}\n
    permutations_i.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nvoid backtrack(List<int> state, int[] choices, bool[] selected, List<List<int>> res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.Count == choices.Length) {\nres.Add(new List<int>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < choices.Length; i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i]) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true;\nstate.Add(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.RemoveAt(state.Count - 1);\n}\n}\n}\n/* \u5168\u6392\u5217 I */\nList<List<int>> permutationsI(int[] nums) {\nList<List<int>> res = new List<List<int>>();\nbacktrack(new List<int>(), nums, new bool[nums.Length], res);\nreturn res;\n}\n
    permutations_i.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif state.count == choices.count {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (i, choice) in choices.enumerated() {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif !selected[i] {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true\nstate.append(choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, choices: choices, selected: &selected, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false\nstate.removeLast()\n}\n}\n}\n/* \u5168\u6392\u5217 I */\nfunc permutationsI(nums: [Int]) -> [[Int]] {\nvar state: [Int] = []\nvar selected = Array(repeating: false, count: nums.count)\nvar res: [[Int]] = []\nbacktrack(state: &state, choices: nums, selected: &selected, res: &res)\nreturn res\n}\n
    permutations_i.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsI}\n
    permutations_i.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsI}\n

    \u9700\u8981\u91cd\u70b9\u5173\u6ce8\u7684\u662f\uff0c\u6211\u4eec\u5f15\u5165\u4e86\u4e00\u4e2a\u5e03\u5c14\u578b\u6570\u7ec4 selected \uff0c\u5b83\u7684\u957f\u5ea6\u4e0e\u8f93\u5165\u6570\u7ec4\u957f\u5ea6\u76f8\u7b49\uff0c\u5176\u4e2d selected[i] \u8868\u793a choices[i] \u662f\u5426\u5df2\u88ab\u9009\u62e9\u3002\u6211\u4eec\u5229\u7528 selected \u907f\u514d\u67d0\u4e2a\u5143\u7d20\u88ab\u91cd\u590d\u9009\u62e9\uff0c\u4ece\u800c\u5b9e\u73b0\u526a\u679d\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5047\u8bbe\u6211\u4eec\u7b2c\u4e00\u8f6e\u9009\u62e9 1 \uff0c\u7b2c\u4e8c\u8f6e\u9009\u62e9 3 \uff0c\u7b2c\u4e09\u8f6e\u9009\u62e9 2 \uff0c\u5219\u9700\u8981\u5728\u7b2c\u4e8c\u8f6e\u526a\u6389\u5143\u7d20 1 \u7684\u5206\u652f\uff0c\u5728\u7b2c\u4e09\u8f6e\u526a\u6389\u5143\u7d20 1, 3 \u7684\u5206\u652f\u3002\u4ece\u672c\u8d28\u4e0a\u7406\u89e3\uff0c\u6b64\u526a\u679d\u64cd\u4f5c\u53ef\u5c06\u641c\u7d22\u7a7a\u95f4\u5927\u5c0f\u4ece \\(O(n^n)\\) \u964d\u4f4e\u81f3 \\(O(n!)\\) \u3002

    Fig. \u5168\u6392\u5217\u526a\u679d\u793a\u4f8b

    "},{"location":"chapter_backtracking/permutations_problem/#1222","title":"12.2.2. \u00a0 \u8003\u8651\u91cd\u590d\u7684\u60c5\u51b5","text":"

    Question

    \u8f93\u5165\u4e00\u4e2a\u6574\u6570\u6570\u7ec4\uff0c\u6570\u7ec4\u4e2d\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\uff0c\u8fd4\u56de\u6240\u6709\u4e0d\u91cd\u590d\u7684\u6392\u5217\u3002

    \u5047\u8bbe\u8f93\u5165\u6570\u7ec4\u4e3a \\([1, 1, 2]\\) \u3002\u4e3a\u4e86\u65b9\u4fbf\u533a\u5206\u4e24\u4e2a\u91cd\u590d\u7684\u5143\u7d20 \\(1\\) \uff0c\u63a5\u4e0b\u6765\u6211\u4eec\u5c06\u7b2c\u4e8c\u4e2a\u5143\u7d20\u8bb0\u4e3a \\(\\hat{1}\\) \u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u4e0a\u8ff0\u65b9\u6cd5\u751f\u6210\u7684\u6392\u5217\u6709\u4e00\u534a\u90fd\u662f\u91cd\u590d\u7684\u3002

    Fig. \u91cd\u590d\u6392\u5217

    \u90a3\u4e48\uff0c\u5982\u4f55\u53bb\u9664\u91cd\u590d\u7684\u6392\u5217\u5462\uff1f\u6700\u76f4\u63a5\u5730\uff0c\u6211\u4eec\u53ef\u4ee5\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868\uff0c\u76f4\u63a5\u5bf9\u6392\u5217\u7ed3\u679c\u8fdb\u884c\u53bb\u91cd\u3002\u7136\u800c\uff0c\u8fd9\u6837\u505a\u4e0d\u591f\u4f18\u96c5\uff0c\u56e0\u4e3a\u751f\u6210\u91cd\u590d\u6392\u5217\u7684\u641c\u7d22\u5206\u652f\u662f\u6ca1\u6709\u5fc5\u8981\u7684\uff0c\u5e94\u5f53\u88ab\u63d0\u524d\u8bc6\u522b\u5e76\u526a\u679d\uff0c\u8fd9\u6837\u53ef\u4ee5\u63d0\u5347\u7b97\u6cd5\u6548\u7387\u3002

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u5728\u7b2c\u4e00\u8f6e\u4e2d\uff0c\u9009\u62e9 \\(1\\) \u6216\u9009\u62e9 \\(\\hat{1}\\) \u662f\u7b49\u4ef7\u7684\uff0c\u56e0\u4e3a\u5728\u8fd9\u4e24\u4e2a\u9009\u62e9\u4e4b\u4e0b\u751f\u6210\u7684\u6240\u6709\u6392\u5217\u90fd\u662f\u91cd\u590d\u7684\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u5e94\u8be5\u628a \\(\\hat{1}\\) \u526a\u679d\u6389\u3002\u540c\u7406\uff0c\u5728\u7b2c\u4e00\u8f6e\u9009\u62e9 \\(2\\) \u540e\uff0c\u7b2c\u4e8c\u8f6e\u9009\u62e9\u4e2d\u7684 \\(1\\) \u548c \\(\\hat{1}\\) \u4e5f\u4f1a\u4ea7\u751f\u91cd\u590d\u5206\u652f\uff0c\u56e0\u6b64\u4e5f\u9700\u8981\u5c06\u7b2c\u4e8c\u8f6e\u7684 \\(\\hat{1}\\) \u526a\u679d\u3002

    Fig. \u91cd\u590d\u6392\u5217\u526a\u679d

    \u672c\u8d28\u4e0a\u770b\uff0c\u6211\u4eec\u7684\u76ee\u6807\u662f\u5b9e\u73b0\u5728\u67d0\u4e00\u8f6e\u9009\u62e9\u4e2d\uff0c\u591a\u4e2a\u76f8\u7b49\u7684\u5143\u7d20\u4ec5\u88ab\u9009\u62e9\u4e00\u6b21\u3002\u56e0\u6b64\uff0c\u5728\u4e0a\u4e00\u9898\u7684\u4ee3\u7801\u7684\u57fa\u7840\u4e0a\uff0c\u6211\u4eec\u8003\u8651\u5728\u6bcf\u4e00\u8f6e\u9009\u62e9\u4e2d\u5f00\u542f\u4e00\u4e2a\u54c8\u5e0c\u8868 duplicated \uff0c\u7528\u4e8e\u8bb0\u5f55\u8be5\u8f6e\u4e2d\u5df2\u7ecf\u5c1d\u8bd5\u8fc7\u7684\u5143\u7d20\uff0c\u5e76\u5c06\u91cd\u590d\u5143\u7d20\u526a\u679d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart permutations_ii.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nvoid backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.size() == choices.length) {\nres.add(new ArrayList<Integer>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nSet<Integer> duplicated = new HashSet<Integer>();\nfor (int i = 0; i < choices.length; i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i] && !duplicated.contains(choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true;\nstate.add(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.remove(state.size() - 1);\n}\n}\n}\n/* \u5168\u6392\u5217 II */\nList<List<Integer>> permutationsII(int[] nums) {\nList<List<Integer>> res = new ArrayList<List<Integer>>();\nbacktrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);\nreturn res;\n}\n
    permutations_ii.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nvoid backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.size() == choices.size()) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nunordered_set<int> duplicated;\nfor (int i = 0; i < choices.size(); i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i] && duplicated.find(choice) == duplicated.end()) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.emplace(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true;\nstate.push_back(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop_back();\n}\n}\n}\n/* \u5168\u6392\u5217 II */\nvector<vector<int>> permutationsII(vector<int> nums) {\nvector<int> state;\nvector<bool> selected(nums.size(), false);\nvector<vector<int>> res;\nbacktrack(state, nums, selected, res);\nreturn res;\n}\n
    permutations_ii.py
    def backtrack(\nstate: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II\"\"\"\n# \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif len(state) == len(choices):\nres.append(list(state))\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nduplicated = set[int]()\nfor i, choice in enumerate(choices):\n# \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif not selected[i] and choice not in duplicated:\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.add(choice)  # \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = True\nstate.append(choice)\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = False\nstate.pop()\ndef permutations_ii(nums: list[int]) -> list[list[int]]:\n\"\"\"\u5168\u6392\u5217 II\"\"\"\nres = []\nbacktrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\nreturn res\n
    permutations_ii.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfunc backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif len(*state) == len(*choices) {\nnewState := append([]int{}, *state...)\n*res = append(*res, newState)\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nduplicated := make(map[int]struct{}, 0)\nfor i := 0; i < len(*choices); i++ {\nchoice := (*choices)[i]\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif _, ok := duplicated[choice]; !ok && !(*selected)[i] {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n// \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nduplicated[choice] = struct{}{}\n(*selected)[i] = true\n*state = append(*state, choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrackI(state, choices, selected, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n(*selected)[i] = false\n*state = (*state)[:len(*state)-1]\n}\n}\n}\n/* \u5168\u6392\u5217 II */\nfunc permutationsII(nums []int) [][]int {\nres := make([][]int, 0)\nstate := make([]int, 0)\nselected := make([]bool, len(nums))\nbacktrackII(&state, &nums, &selected, &res)\nreturn res\n}\n
    permutations_ii.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfunction backtrack(state, choices, selected, res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.length === choices.length) {\nres.push([...state]);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nconst duplicated = new Set();\nchoices.forEach((choice, i) => {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i] && !duplicated.has(choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true;\nstate.push(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop();\n}\n});\n}\n/* \u5168\u6392\u5217 II */\nfunction permutationsII(nums) {\nconst res = [];\nbacktrack([], nums, Array(nums.length).fill(false), res);\nreturn res;\n}\n
    permutations_ii.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfunction backtrack(\nstate: number[],\nchoices: number[],\nselected: boolean[],\nres: number[][]\n): void {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.length === choices.length) {\nres.push([...state]);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nconst duplicated = new Set();\nchoices.forEach((choice, i) => {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i] && !duplicated.has(choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true;\nstate.push(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop();\n}\n});\n}\n/* \u5168\u6392\u5217 II */\nfunction permutationsII(nums: number[]): number[][] {\nconst res: number[][] = [];\nbacktrack([], nums, Array(nums.length).fill(false), res);\nreturn res;\n}\n
    permutations_ii.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsII}\n
    permutations_ii.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nvoid backtrack(List<int> state, int[] choices, bool[] selected, List<List<int>> res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.Count == choices.Length) {\nres.Add(new List<int>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nISet<int> duplicated = new HashSet<int>();\nfor (int i = 0; i < choices.Length; i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i] && !duplicated.Contains(choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.Add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true;\nstate.Add(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.RemoveAt(state.Count - 1);\n}\n}\n}\n/* \u5168\u6392\u5217 II */\nList<List<int>> permutationsII(int[] nums) {\nList<List<int>> res = new List<List<int>>();\nbacktrack(new List<int>(), nums, new bool[nums.Length], res);\nreturn res;\n}\n
    permutations_ii.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif state.count == choices.count {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nvar duplicated: Set<Int> = []\nfor (i, choice) in choices.enumerated() {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif !selected[i], !duplicated.contains(choice) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.insert(choice) // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true\nstate.append(choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, choices: choices, selected: &selected, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false\nstate.removeLast()\n}\n}\n}\n/* \u5168\u6392\u5217 II */\nfunc permutationsII(nums: [Int]) -> [[Int]] {\nvar state: [Int] = []\nvar selected = Array(repeating: false, count: nums.count)\nvar res: [[Int]] = []\nbacktrack(state: &state, choices: nums, selected: &selected, res: &res)\nreturn res\n}\n
    permutations_ii.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsII}\n
    permutations_ii.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsII}\n

    \u6ce8\u610f\uff0c\u867d\u7136 selected \u548c duplicated \u90fd\u8d77\u5230\u526a\u679d\u7684\u4f5c\u7528\uff0c\u4f46\u4ed6\u4eec\u526a\u6389\u7684\u662f\u4e0d\u540c\u7684\u5206\u652f\uff1a

    • \u526a\u679d\u6761\u4ef6\u4e00\uff1a\u6574\u4e2a\u641c\u7d22\u8fc7\u7a0b\u4e2d\u53ea\u6709\u4e00\u4e2a selected \u3002\u5b83\u8bb0\u5f55\u7684\u662f\u5f53\u524d\u72b6\u6001\u4e2d\u5305\u542b\u54ea\u4e9b\u5143\u7d20\uff0c\u4f5c\u7528\u662f\u907f\u514d\u67d0\u4e2a\u5143\u7d20\u5728 state \u4e2d\u91cd\u590d\u51fa\u73b0\u3002
    • \u526a\u679d\u6761\u4ef6\u4e8c\uff1a\u6bcf\u8f6e\u9009\u62e9\uff08\u5373\u6bcf\u4e2a\u5f00\u542f\u7684 backtrack \u51fd\u6570\uff09\u90fd\u5305\u542b\u4e00\u4e2a duplicated \u3002\u5b83\u8bb0\u5f55\u7684\u662f\u5728\u904d\u5386\u4e2d\u54ea\u4e9b\u5143\u7d20\u5df2\u88ab\u9009\u62e9\u8fc7\uff0c\u4f5c\u7528\u662f\u4fdd\u8bc1\u76f8\u7b49\u5143\u7d20\u53ea\u88ab\u9009\u62e9\u4e00\u6b21\uff0c\u4ee5\u907f\u514d\u4ea7\u751f\u91cd\u590d\u7684\u641c\u7d22\u5206\u652f\u3002

    \u4e0b\u56fe\u5c55\u793a\u4e86\u4e24\u4e2a\u526a\u679d\u6761\u4ef6\u7684\u751f\u6548\u8303\u56f4\u3002\u6ce8\u610f\uff0c\u6811\u4e2d\u7684\u6bcf\u4e2a\u8282\u70b9\u4ee3\u8868\u4e00\u4e2a\u9009\u62e9\uff0c\u4ece\u6839\u8282\u70b9\u5230\u53f6\u8282\u70b9\u7684\u8def\u5f84\u4e0a\u7684\u5404\u4e2a\u8282\u70b9\u6784\u6210\u4e00\u4e2a\u6392\u5217\u3002

    Fig. \u4e24\u79cd\u526a\u679d\u6761\u4ef6\u7684\u4f5c\u7528\u8303\u56f4

    "},{"location":"chapter_backtracking/permutations_problem/#1223","title":"12.2.3. \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"

    \u5047\u8bbe\u5143\u7d20\u4e24\u4e24\u4e4b\u95f4\u4e92\u4e0d\u76f8\u540c\uff0c\u5219 \\(n\\) \u4e2a\u5143\u7d20\u5171\u6709 \\(n!\\) \u79cd\u6392\u5217\uff08\u9636\u4e58\uff09\uff1b\u5728\u8bb0\u5f55\u7ed3\u679c\u65f6\uff0c\u9700\u8981\u590d\u5236\u957f\u5ea6\u4e3a \\(n\\) \u7684\u5217\u8868\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002\u56e0\u6b64\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n!n)\\) \u3002

    \u6700\u5927\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \uff0c\u4f7f\u7528 \\(O(n)\\) \u6808\u5e27\u7a7a\u95f4\u3002selected \u4f7f\u7528 \\(O(n)\\) \u7a7a\u95f4\u3002\u540c\u4e00\u65f6\u523b\u6700\u591a\u5171\u6709 \\(n\\) \u4e2a duplicated \uff0c\u4f7f\u7528 \\(O(n^2)\\) \u7a7a\u95f4\u3002\u56e0\u6b64\uff0c\u5168\u6392\u5217 I \u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u5168\u6392\u5217 II \u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    "},{"location":"chapter_backtracking/subset_sum_problem/","title":"12.3. \u00a0 \u5b50\u96c6\u548c\u95ee\u9898","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u6b63\u6574\u6570\u6570\u7ec4 nums \u548c\u4e00\u4e2a\u76ee\u6807\u6b63\u6574\u6570 target \uff0c\u8bf7\u627e\u51fa\u6240\u6709\u53ef\u80fd\u7684\u7ec4\u5408\uff0c\u4f7f\u5f97\u7ec4\u5408\u4e2d\u7684\u5143\u7d20\u548c\u7b49\u4e8e target \u3002\u7ed9\u5b9a\u6570\u7ec4\u65e0\u91cd\u590d\u5143\u7d20\uff0c\u6bcf\u4e2a\u5143\u7d20\u53ef\u4ee5\u88ab\u9009\u53d6\u591a\u6b21\u3002\u8bf7\u4ee5\u5217\u8868\u5f62\u5f0f\u8fd4\u56de\u8fd9\u4e9b\u7ec4\u5408\uff0c\u5217\u8868\u4e2d\u4e0d\u5e94\u5305\u542b\u91cd\u590d\u7ec4\u5408\u3002

    \u4f8b\u5982\uff0c\u8f93\u5165\u96c6\u5408 \\(\\{3, 4, 5\\}\\) \u548c\u76ee\u6807\u6574\u6570 \\(9\\) \uff0c\u7531\u4e8e\u96c6\u5408\u4e2d\u7684\u6570\u5b57\u53ef\u4ee5\u88ab\u91cd\u590d\u9009\u53d6\uff0c\u56e0\u6b64\u89e3\u4e3a \\(\\{3, 3, 3\\}, \\{4, 5\\}\\) \u3002\u8bf7\u6ce8\u610f\uff0c\u5b50\u96c6\u662f\u4e0d\u533a\u5206\u5143\u7d20\u987a\u5e8f\u7684\uff0c\u4f8b\u5982 \\(\\{4, 5\\}\\) \u548c \\(\\{5, 4\\}\\) \u662f\u540c\u4e00\u4e2a\u5b50\u96c6\u3002

    "},{"location":"chapter_backtracking/subset_sum_problem/#1231","title":"12.3.1. \u00a0 \u4ece\u5168\u6392\u5217\u5f15\u51fa\u89e3\u6cd5","text":"

    \u7c7b\u4f3c\u4e8e\u4e0a\u8282\u5168\u6392\u5217\u95ee\u9898\u7684\u89e3\u6cd5\uff0c\u6211\u4eec\u53ef\u4ee5\u628a\u5b50\u96c6\u7684\u751f\u6210\u8fc7\u7a0b\u60f3\u8c61\u6210\u4e00\u7cfb\u5217\u9009\u62e9\u7684\u7ed3\u679c\uff0c\u5e76\u5728\u9009\u62e9\u8fc7\u7a0b\u4e2d\u5b9e\u65f6\u66f4\u65b0\u201c\u5143\u7d20\u548c\u201d\uff0c\u5f53\u5143\u7d20\u548c\u7b49\u4e8e target \u65f6\uff0c\u5c31\u5c06\u5b50\u96c6\u8bb0\u5f55\u81f3\u7ed3\u679c\u5217\u8868\u3002

    \u800c\u4e0e\u5168\u6392\u5217\u95ee\u9898\u4e0d\u540c\u7684\u662f\uff0c\u672c\u9898\u5141\u8bb8\u91cd\u590d\u9009\u53d6\u540c\u4e00\u5143\u7d20\uff0c\u56e0\u6b64\u65e0\u9700\u501f\u52a9 selected \u5e03\u5c14\u5217\u8868\u6765\u8bb0\u5f55\u5143\u7d20\u662f\u5426\u5df2\u88ab\u9009\u62e9\u3002\u6211\u4eec\u53ef\u4ee5\u5bf9\u5168\u6392\u5217\u4ee3\u7801\u8fdb\u884c\u5c0f\u5e45\u4fee\u6539\uff0c\u521d\u6b65\u5f97\u5230\u89e3\u9898\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart subset_sum_i_naive.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(List<Integer> state, int target, int total, int[] choices, List<List<Integer>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (total == target) {\nres.add(new ArrayList<>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < choices.length; i++) {\n// \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif (total + choices[i] > target) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\nstate.add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target, total + choices[i], choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.remove(state.size() - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nList<List<Integer>> subsetSumINaive(int[] nums, int target) {\nList<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nint total = 0; // \u5b50\u96c6\u548c\nList<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, total, nums, res);\nreturn res;\n}\n
    subset_sum_i_naive.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(vector<int> &state, int target, int total, vector<int> &choices, vector<vector<int>> &res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (total == target) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (size_t i = 0; i < choices.size(); i++) {\n// \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif (total + choices[i] > target) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\nstate.push_back(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target, total + choices[i], choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop_back();\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nvector<vector<int>> subsetSumINaive(vector<int> &nums, int target) {\nvector<int> state;       // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nint total = 0;           // \u5b50\u96c6\u548c\nvector<vector<int>> res; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, total, nums, res);\nreturn res;\n}\n
    subset_sum_i_naive.py
    def backtrack(\nstate: list[int],\ntarget: int,\ntotal: int,\nchoices: list[int],\nres: list[list[int]],\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I\"\"\"\n# \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif total == target:\nres.append(list(state))\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nfor i in range(len(choices)):\n# \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif total + choices[i] > target:\ncontinue\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\nstate.append(choices[i])\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target, total + choices[i], choices, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop()\ndef subset_sum_i_naive(nums: list[int], target: int) -> list[list[int]]:\n\"\"\"\u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09\"\"\"\nstate = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\ntotal = 0  # \u5b50\u96c6\u548c\nres = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, total, nums, res)\nreturn res\n
    subset_sum_i_naive.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunc backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == total {\nnewState := append([]int{}, *state...)\n*res = append(*res, newState)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor i := 0; i < len(*choices); i++ {\n// \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif total+(*choices)[i] > target {\ncontinue\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n*state = append(*state, (*choices)[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n*state = (*state)[:len(*state)-1]\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunc subsetSumINaive(nums []int, target int) [][]int {\nstate := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\ntotal := 0              // \u5b50\u96c6\u548c\nres := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrackSubsetSumINaive(total, target, &state, &nums, &res)\nreturn res\n}\n
    subset_sum_i_naive.js
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumINaive}\n
    subset_sum_i_naive.ts
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumINaive}\n
    subset_sum_i_naive.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumINaive}\n
    subset_sum_i_naive.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(List<int> state, int target, int total, int[] choices, List<List<int>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (total == target) {\nres.Add(new List<int>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < choices.Length; i++) {\n// \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif (total + choices[i] > target) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\nstate.Add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target, total + choices[i], choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.RemoveAt(state.Count - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nList<List<int>> subsetSumINaive(int[] nums, int target) {\nList<int> state = new List<int>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nint total = 0; // \u5b50\u96c6\u548c\nList<List<int>> res = new List<List<int>>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, total, nums, res);\nreturn res;\n}\n
    subset_sum_i_naive.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunc backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif total == target {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor i in stride(from: 0, to: choices.count, by: 1) {\n// \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif total + choices[i] > target {\ncontinue\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\nstate.append(choices[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, target: target, total: total + choices[i], choices: choices, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.removeLast()\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunc subsetSumINaive(nums: [Int], target: Int) -> [[Int]] {\nvar state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nlet total = 0 // \u5b50\u96c6\u548c\nvar res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state: &state, target: target, total: total, choices: nums, res: &res)\nreturn res\n}\n
    subset_sum_i_naive.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumINaive}\n
    subset_sum_i_naive.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumINaive}\n

    \u5411\u4ee5\u4e0a\u4ee3\u7801\u8f93\u5165\u6570\u7ec4 \\([3, 4, 5]\\) \u548c\u76ee\u6807\u5143\u7d20 \\(9\\) \uff0c\u8f93\u51fa\u7ed3\u679c\u4e3a \\([3, 3, 3], [4, 5], [5, 4]\\) \u3002\u867d\u7136\u6210\u529f\u627e\u51fa\u4e86\u6240\u6709\u548c\u4e3a \\(9\\) \u7684\u5b50\u96c6\uff0c\u4f46\u5176\u4e2d\u5b58\u5728\u91cd\u590d\u7684\u5b50\u96c6 \\([4, 5]\\) \u548c \\([5, 4]\\) \u3002\u8fd9\u662f\u56e0\u4e3a\u641c\u7d22\u8fc7\u7a0b\u662f\u533a\u5206\u9009\u62e9\u987a\u5e8f\u7684\uff0c\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5148\u9009 \\(4\\) \u540e\u9009 \\(5\\) \u4e0e\u5148\u9009 \\(5\\) \u540e\u9009 \\(4\\) \u662f\u4e24\u79cd\u4e0d\u540c\u7684\u60c5\u51b5\u3002

    Fig. \u5b50\u96c6\u641c\u7d22\u4e0e\u8d8a\u754c\u526a\u679d

    "},{"location":"chapter_backtracking/subset_sum_problem/#1232","title":"12.3.2. \u00a0 \u91cd\u590d\u5b50\u96c6\u526a\u679d","text":"

    \u4e3a\u4e86\u53bb\u9664\u91cd\u590d\u5b50\u96c6\uff0c\u4e00\u79cd\u76f4\u63a5\u7684\u601d\u8def\u662f\u5bf9\u7ed3\u679c\u5217\u8868\u8fdb\u884c\u53bb\u91cd\u3002\u4f46\u8fd9\u4e2a\u65b9\u6cd5\u6548\u7387\u5f88\u4f4e\uff0c\u56e0\u4e3a\uff1a

    • \u5f53\u6570\u7ec4\u5143\u7d20\u8f83\u591a\uff0c\u5c24\u5176\u662f\u5f53 target \u8f83\u5927\u65f6\uff0c\u641c\u7d22\u8fc7\u7a0b\u4f1a\u4ea7\u751f\u5927\u91cf\u7684\u91cd\u590d\u5b50\u96c6\u3002
    • \u6bd4\u8f83\u5b50\u96c6\uff08\u6570\u7ec4\uff09\u7684\u5f02\u540c\u662f\u5f88\u8017\u65f6\u7684\uff0c\u9700\u8981\u5148\u6392\u5e8f\u6570\u7ec4\uff0c\u518d\u6bd4\u8f83\u6570\u7ec4\u4e2d\u6bcf\u4e2a\u5143\u7d20\u7684\u5f02\u540c\u3002

    \u4e3a\u4e86\u8fbe\u5230\u6700\u4f73\u6548\u7387\uff0c\u6211\u4eec\u5e0c\u671b\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u901a\u8fc7\u526a\u679d\u8fdb\u884c\u53bb\u91cd\u3002\u89c2\u5bdf\u4e0b\u56fe\uff0c\u91cd\u590d\u5b50\u96c6\u662f\u5728\u4ee5\u4e0d\u540c\u987a\u5e8f\u9009\u62e9\u6570\u7ec4\u5143\u7d20\u65f6\u4ea7\u751f\u7684\uff0c\u5177\u4f53\u6765\u770b\uff1a

    1. \u7b2c\u4e00\u8f6e\u548c\u7b2c\u4e8c\u8f6e\u5206\u522b\u9009\u62e9 \\(3\\) , \\(4\\) \uff0c\u4f1a\u751f\u6210\u5305\u542b\u8fd9\u4e24\u4e2a\u5143\u7d20\u7684\u6240\u6709\u5b50\u96c6\uff0c\u8bb0\u4e3a \\([3, 4, \\cdots]\\) \u3002
    2. \u82e5\u7b2c\u4e00\u8f6e\u9009\u62e9 \\(4\\) \uff0c\u5219\u7b2c\u4e8c\u8f6e\u5e94\u8be5\u8df3\u8fc7 \\(3\\) \uff0c\u56e0\u4e3a\u8be5\u9009\u62e9\u4ea7\u751f\u7684\u5b50\u96c6 \\([4, 3, \\cdots]\\) \u548c 1. \u4e2d\u63d0\u5230\u7684\u5b50\u96c6\u5b8c\u5168\u91cd\u590d\u3002
    3. \u540c\u7406\uff0c\u82e5\u7b2c\u4e00\u8f6e\u9009\u62e9 \\(5\\) \uff0c\u5219\u7b2c\u4e8c\u8f6e\u5e94\u8be5\u8df3\u8fc7 \\(3\\) \u548c \\(4\\) \uff0c\u56e0\u4e3a\u5b50\u96c6 \\([5, 3, \\cdots]\\) \u548c\u5b50\u96c6 \\([5, 4, \\cdots]\\) \u548c\u4e4b\u524d\u7684\u5b50\u96c6\u91cd\u590d\u3002

    Fig. \u4e0d\u540c\u9009\u62e9\u987a\u5e8f\u5bfc\u81f4\u7684\u91cd\u590d\u5b50\u96c6

    \u603b\u7ed3\u6765\u770b\uff0c\u7ed9\u5b9a\u8f93\u5165\u6570\u7ec4 \\([x_1, x_2, \\cdots, x_n]\\) \uff0c\u8bbe\u641c\u7d22\u8fc7\u7a0b\u4e2d\u7684\u9009\u62e9\u5e8f\u5217\u4e3a \\([x_{i_1}, x_{i_2}, \\cdots , x_{i_m}]\\) \uff0c\u5219\u8be5\u9009\u62e9\u5e8f\u5217\u9700\u8981\u6ee1\u8db3 \\(i_1 \\leq i_2 \\leq \\cdots \\leq i_m\\) \u3002\u4e0d\u6ee1\u8db3\u8be5\u6761\u4ef6\u7684\u9009\u62e9\u5e8f\u5217\u90fd\u662f\u91cd\u590d\u5b50\u96c6\u3002

    \u4e3a\u5b9e\u73b0\u8be5\u526a\u679d\uff0c\u6211\u4eec\u521d\u59cb\u5316\u53d8\u91cf start \uff0c\u7528\u4e8e\u6307\u793a\u904d\u5386\u8d77\u70b9\u3002\u5f53\u505a\u51fa\u9009\u62e9 \\(x_{i}\\) \u540e\uff0c\u8bbe\u5b9a\u4e0b\u4e00\u8f6e\u4ece\u7d22\u5f15 \\(i\\) \u5f00\u59cb\u904d\u5386\uff0c\u4ece\u800c\u5b8c\u6210\u5b50\u96c6\u53bb\u91cd\u3002

    \u9664\u6b64\u4e4b\u5916\uff0c\u6211\u4eec\u8fd8\u5bf9\u4ee3\u7801\u8fdb\u884c\u4e86\u4e24\u9879\u4f18\u5316\u3002\u9996\u5148\uff0c\u6211\u4eec\u5728\u5f00\u542f\u641c\u7d22\u524d\u5c06\u6570\u7ec4 nums \u6392\u5e8f\uff0c\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u5f53\u5b50\u96c6\u548c\u8d85\u8fc7 target \u65f6\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\uff0c\u56e0\u4e3a\u540e\u8fb9\u7684\u5143\u7d20\u66f4\u5927\uff0c\u5176\u5b50\u96c6\u548c\u90fd\u4e00\u5b9a\u4f1a\u8d85\u8fc7 target \u3002\u5176\u6b21\uff0c\u6211\u4eec\u901a\u8fc7\u5728 target \u4e0a\u6267\u884c\u51cf\u6cd5\u6765\u7edf\u8ba1\u5143\u7d20\u548c\uff0c\u5f53 target \u7b49\u4e8e \\(0\\) \u65f6\u8bb0\u5f55\u89e3\uff0c\u7701\u53bb\u4e86\u5143\u7d20\u548c\u53d8\u91cf total \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart subset_sum_i.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.add(new ArrayList<>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor (int i = start; i < choices.length; i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.remove(state.size() - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nList<List<Integer>> subsetSumI(int[] nums, int target) {\nList<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nArrays.sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\nList<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_i.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor (int i = start; i < choices.size(); i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.push_back(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop_back();\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nvector<vector<int>> subsetSumI(vector<int> &nums, int target) {\nvector<int> state;              // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nsort(nums.begin(), nums.end()); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0;                  // \u904d\u5386\u8d77\u59cb\u70b9\nvector<vector<int>> res;        // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_i.py
    def backtrack(\nstate: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I\"\"\"\n# \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0:\nres.append(list(state))\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\n# \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor i in range(start, len(choices)):\n# \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n# \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target - choices[i] < 0:\nbreak\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.append(choices[i])\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop()\ndef subset_sum_i(nums: list[int], target: int) -> list[list[int]]:\n\"\"\"\u6c42\u89e3\u5b50\u96c6\u548c I\"\"\"\nstate = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\nnums.sort()  # \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nstart = 0  # \u904d\u5386\u8d77\u59cb\u70b9\nres = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res)\nreturn res\n
    subset_sum_i.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunc backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0 {\nnewState := append([]int{}, *state...)\n*res = append(*res, newState)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor i := start; i < len(*choices); i++ {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target-(*choices)[i] < 0 {\nbreak\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n*state = append(*state, (*choices)[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrackSubsetSumI(i, target-(*choices)[i], state, choices, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n*state = (*state)[:len(*state)-1]\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunc subsetSumI(nums []int, target int) [][]int {\nstate := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nsort.Ints(nums)         // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nstart := 0              // \u904d\u5386\u8d77\u59cb\u70b9\nres := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrackSubsetSumI(start, target, &state, &nums, &res)\nreturn res\n}\n
    subset_sum_i.js
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumI}\n
    subset_sum_i.ts
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumI}\n
    subset_sum_i.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumI}\n
    subset_sum_i.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(List<int> state, int target, int[] choices, int start, List<List<int>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.Add(new List<int>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor (int i = start; i < choices.Length; i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.Add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.RemoveAt(state.Count - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nList<List<int>> subsetSumI(int[] nums, int target) {\nList<int> state = new List<int>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nArray.Sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\nList<List<int>> res = new List<List<int>>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_i.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0 {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor i in stride(from: start, to: choices.count, by: 1) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target - choices[i] < 0 {\nbreak\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.append(choices[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, target: target - choices[i], choices: choices, start: i, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.removeLast()\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunc subsetSumI(nums: [Int], target: Int) -> [[Int]] {\nvar state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nlet nums = nums.sorted() // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nlet start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\nvar res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state: &state, target: target, choices: nums, start: start, res: &res)\nreturn res\n}\n
    subset_sum_i.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumI}\n
    subset_sum_i.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumI}\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u4e3a\u5c06\u6570\u7ec4 \\([3, 4, 5]\\) \u548c\u76ee\u6807\u5143\u7d20 \\(9\\) \u8f93\u5165\u5230\u4ee5\u4e0a\u4ee3\u7801\u540e\u7684\u6574\u4f53\u56de\u6eaf\u8fc7\u7a0b\u3002

    Fig. \u5b50\u96c6\u548c I \u56de\u6eaf\u8fc7\u7a0b

    "},{"location":"chapter_backtracking/subset_sum_problem/#1233","title":"12.3.3. \u00a0 \u76f8\u7b49\u5143\u7d20\u526a\u679d","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u6b63\u6574\u6570\u6570\u7ec4 nums \u548c\u4e00\u4e2a\u76ee\u6807\u6b63\u6574\u6570 target \uff0c\u8bf7\u627e\u51fa\u6240\u6709\u53ef\u80fd\u7684\u7ec4\u5408\uff0c\u4f7f\u5f97\u7ec4\u5408\u4e2d\u7684\u5143\u7d20\u548c\u7b49\u4e8e target \u3002\u7ed9\u5b9a\u6570\u7ec4\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\uff0c\u6bcf\u4e2a\u5143\u7d20\u53ea\u53ef\u88ab\u9009\u62e9\u4e00\u6b21\u3002\u8bf7\u4ee5\u5217\u8868\u5f62\u5f0f\u8fd4\u56de\u8fd9\u4e9b\u7ec4\u5408\uff0c\u5217\u8868\u4e2d\u4e0d\u5e94\u5305\u542b\u91cd\u590d\u7ec4\u5408\u3002

    \u76f8\u6bd4\u4e8e\u4e0a\u9898\uff0c\u672c\u9898\u7684\u8f93\u5165\u6570\u7ec4\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\uff0c\u8fd9\u5f15\u5165\u4e86\u65b0\u7684\u95ee\u9898\u3002\u4f8b\u5982\uff0c\u7ed9\u5b9a\u6570\u7ec4 \\([4, \\hat{4}, 5]\\) \u548c\u76ee\u6807\u5143\u7d20 \\(9\\) \uff0c\u5219\u73b0\u6709\u4ee3\u7801\u7684\u8f93\u51fa\u7ed3\u679c\u4e3a \\([4, 5], [\\hat{4}, 5]\\) \uff0c\u4e5f\u51fa\u73b0\u4e86\u91cd\u590d\u5b50\u96c6\u3002\u9020\u6210\u8fd9\u79cd\u91cd\u590d\u7684\u539f\u56e0\u662f\u76f8\u7b49\u5143\u7d20\u5728\u67d0\u8f6e\u4e2d\u88ab\u591a\u6b21\u9009\u62e9\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u7b2c\u4e00\u8f6e\u5171\u6709\u4e09\u4e2a\u9009\u62e9\uff0c\u5176\u4e2d\u4e24\u4e2a\u90fd\u4e3a \\(4\\) \uff0c\u4f1a\u4ea7\u751f\u4e24\u4e2a\u91cd\u590d\u7684\u641c\u7d22\u5206\u652f\uff0c\u4ece\u800c\u8f93\u51fa\u91cd\u590d\u5b50\u96c6\uff1b\u540c\u7406\uff0c\u7b2c\u4e8c\u8f6e\u7684\u4e24\u4e2a \\(4\\) \u4e5f\u4f1a\u4ea7\u751f\u91cd\u590d\u5b50\u96c6\u3002

    Fig. \u76f8\u7b49\u5143\u7d20\u5bfc\u81f4\u7684\u91cd\u590d\u5b50\u96c6

    \u4e3a\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u9700\u8981\u9650\u5236\u76f8\u7b49\u5143\u7d20\u5728\u6bcf\u4e00\u8f6e\u4e2d\u53ea\u88ab\u9009\u62e9\u4e00\u6b21\u3002\u5b9e\u73b0\u65b9\u5f0f\u6bd4\u8f83\u5de7\u5999\uff1a\u7531\u4e8e\u6570\u7ec4\u662f\u5df2\u6392\u5e8f\u7684\uff0c\u56e0\u6b64\u76f8\u7b49\u5143\u7d20\u90fd\u662f\u76f8\u90bb\u7684\u3002\u5229\u7528\u8be5\u7279\u6027\uff0c\u5728\u67d0\u8f6e\u9009\u62e9\u4e2d\uff0c\u82e5\u5f53\u524d\u5143\u7d20\u4e0e\u5176\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u5219\u8bf4\u660e\u5b83\u5df2\u7ecf\u88ab\u9009\u62e9\u8fc7\uff0c\u56e0\u6b64\u76f4\u63a5\u8df3\u8fc7\u5f53\u524d\u5143\u7d20\u3002

    \u4e0e\u6b64\u540c\u65f6\uff0c\u672c\u9898\u89c4\u5b9a\u6570\u7ec4\u5143\u7d20\u53ea\u80fd\u88ab\u9009\u62e9\u4e00\u6b21\u3002\u5e78\u8fd0\u7684\u662f\uff0c\u6211\u4eec\u4e5f\u53ef\u4ee5\u5229\u7528\u53d8\u91cf start \u6765\u6ee1\u8db3\u8be5\u7ea6\u675f\uff1a\u5f53\u505a\u51fa\u9009\u62e9 \\(x_{i}\\) \u540e\uff0c\u8bbe\u5b9a\u4e0b\u4e00\u8f6e\u4ece\u7d22\u5f15 \\(i + 1\\) \u5f00\u59cb\u5411\u540e\u904d\u5386\u3002\u8fd9\u6837\u5373\u80fd\u53bb\u9664\u91cd\u590d\u5b50\u96c6\uff0c\u4e5f\u80fd\u907f\u514d\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart subset_sum_ii.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nvoid backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.add(new ArrayList<>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n// \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor (int i = start; i < choices.length; i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif (i > start && choices[i] == choices[i - 1]) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i + 1, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.remove(state.size() - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nList<List<Integer>> subsetSumII(int[] nums, int target) {\nList<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nArrays.sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\nList<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_ii.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nvoid backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n// \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor (int i = start; i < choices.size(); i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif (i > start && choices[i] == choices[i - 1]) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.push_back(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i + 1, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop_back();\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nvector<vector<int>> subsetSumII(vector<int> &nums, int target) {\nvector<int> state;              // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nsort(nums.begin(), nums.end()); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0;                  // \u904d\u5386\u8d77\u59cb\u70b9\nvector<vector<int>> res;        // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_ii.py
    def backtrack(\nstate: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II\"\"\"\n# \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0:\nres.append(list(state))\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\n# \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n# \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor i in range(start, len(choices)):\n# \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n# \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target - choices[i] < 0:\nbreak\n# \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif i > start and choices[i] == choices[i - 1]:\ncontinue\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.append(choices[i])\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i + 1, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop()\ndef subset_sum_ii(nums: list[int], target: int) -> list[list[int]]:\n\"\"\"\u6c42\u89e3\u5b50\u96c6\u548c II\"\"\"\nstate = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\nnums.sort()  # \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nstart = 0  # \u904d\u5386\u8d77\u59cb\u70b9\nres = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res)\nreturn res\n
    subset_sum_ii.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfunc backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0 {\nnewState := append([]int{}, *state...)\n*res = append(*res, newState)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n// \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor i := start; i < len(*choices); i++ {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target-(*choices)[i] < 0 {\nbreak\n}\n// \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif i > start && (*choices)[i] == (*choices)[i-1] {\ncontinue\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n*state = append(*state, (*choices)[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n*state = (*state)[:len(*state)-1]\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunc subsetSumII(nums []int, target int) [][]int {\nstate := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nsort.Ints(nums)         // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nstart := 0              // \u904d\u5386\u8d77\u59cb\u70b9\nres := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrackSubsetSumII(start, target, &state, &nums, &res)\nreturn res\n}\n
    subset_sum_ii.js
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumII}\n
    subset_sum_ii.ts
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumII}\n
    subset_sum_ii.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumII}\n
    subset_sum_ii.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nvoid backtrack(List<int> state, int target, int[] choices, int start, List<List<int>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.Add(new List<int>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n// \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor (int i = start; i < choices.Length; i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif (i > start && choices[i] == choices[i - 1]) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.Add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i + 1, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.RemoveAt(state.Count - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nList<List<int>> subsetSumII(int[] nums, int target) {\nList<int> state = new List<int>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nArray.Sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\nList<List<int>> res = new List<List<int>>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_ii.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0 {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n// \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor i in stride(from: start, to: choices.count, by: 1) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target - choices[i] < 0 {\nbreak\n}\n// \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif i > start, choices[i] == choices[i - 1] {\ncontinue\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.append(choices[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, target: target - choices[i], choices: choices, start: i + 1, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.removeLast()\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunc subsetSumII(nums: [Int], target: Int) -> [[Int]] {\nvar state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nlet nums = nums.sorted() // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nlet start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\nvar res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state: &state, target: target, choices: nums, start: start, res: &res)\nreturn res\n}\n
    subset_sum_ii.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumII}\n
    subset_sum_ii.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumII}\n

    \u4e0b\u56fe\u5c55\u793a\u4e86\u6570\u7ec4 \\([4, 4, 5]\\) \u548c\u76ee\u6807\u5143\u7d20 \\(9\\) \u7684\u56de\u6eaf\u8fc7\u7a0b\uff0c\u5171\u5305\u542b\u56db\u79cd\u526a\u679d\u64cd\u4f5c\u3002\u5efa\u8bae\u4f60\u5c06\u56fe\u793a\u4e0e\u4ee3\u7801\u6ce8\u91ca\u76f8\u7ed3\u5408\uff0c\u7406\u89e3\u6574\u4e2a\u641c\u7d22\u8fc7\u7a0b\uff0c\u4ee5\u53ca\u6bcf\u79cd\u526a\u679d\u64cd\u4f5c\u662f\u5982\u4f55\u5de5\u4f5c\u7684\u3002

    Fig. \u5b50\u96c6\u548c II \u56de\u6eaf\u8fc7\u7a0b

    "},{"location":"chapter_backtracking/summary/","title":"12.5. \u00a0 \u5c0f\u7ed3","text":"
    • \u56de\u6eaf\u7b97\u6cd5\u672c\u8d28\u662f\u7a77\u4e3e\u6cd5\uff0c\u901a\u8fc7\u5bf9\u89e3\u7a7a\u95f4\u8fdb\u884c\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u6765\u5bfb\u627e\u7b26\u5408\u6761\u4ef6\u7684\u89e3\u3002\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u9047\u5230\u6ee1\u8db3\u6761\u4ef6\u7684\u89e3\u5219\u8bb0\u5f55\uff0c\u76f4\u81f3\u627e\u5230\u6240\u6709\u89e3\u6216\u904d\u5386\u5b8c\u6210\u540e\u7ed3\u675f\u3002
    • \u56de\u6eaf\u7b97\u6cd5\u7684\u641c\u7d22\u8fc7\u7a0b\u5305\u62ec\u5c1d\u8bd5\u4e0e\u56de\u9000\u4e24\u4e2a\u90e8\u5206\u3002\u5b83\u901a\u8fc7\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u6765\u5c1d\u8bd5\u5404\u79cd\u9009\u62e9\uff0c\u5f53\u9047\u5230\u4e0d\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\u7684\u60c5\u51b5\u65f6\uff0c\u5219\u64a4\u9500\u4e0a\u4e00\u6b65\u7684\u9009\u62e9\uff0c\u9000\u56de\u5230\u4e4b\u524d\u7684\u72b6\u6001\uff0c\u5e76\u7ee7\u7eed\u5c1d\u8bd5\u5176\u4ed6\u9009\u62e9\u3002\u5c1d\u8bd5\u4e0e\u56de\u9000\u662f\u4e24\u4e2a\u65b9\u5411\u76f8\u53cd\u7684\u64cd\u4f5c\u3002
    • \u56de\u6eaf\u95ee\u9898\u901a\u5e38\u5305\u542b\u591a\u4e2a\u7ea6\u675f\u6761\u4ef6\uff0c\u5b83\u4eec\u53ef\u7528\u4e8e\u5b9e\u73b0\u526a\u679d\u64cd\u4f5c\u3002\u526a\u679d\u53ef\u4ee5\u63d0\u524d\u7ed3\u675f\u4e0d\u5fc5\u8981\u7684\u641c\u7d22\u5206\u652f\uff0c\u5927\u5e45\u63d0\u5347\u641c\u7d22\u6548\u7387\u3002
    • \u56de\u6eaf\u7b97\u6cd5\u4e3b\u8981\u53ef\u7528\u4e8e\u89e3\u51b3\u641c\u7d22\u95ee\u9898\u548c\u7ea6\u675f\u6ee1\u8db3\u95ee\u9898\u3002\u7ec4\u5408\u4f18\u5316\u95ee\u9898\u867d\u7136\u53ef\u4ee5\u7528\u56de\u6eaf\u7b97\u6cd5\u89e3\u51b3\uff0c\u4f46\u5f80\u5f80\u5b58\u5728\u66f4\u9ad8\u6548\u7387\u6216\u66f4\u597d\u6548\u679c\u7684\u89e3\u6cd5\u3002
    • \u5168\u6392\u5217\u95ee\u9898\u65e8\u5728\u641c\u7d22\u7ed9\u5b9a\u96c6\u5408\u7684\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u3002\u6211\u4eec\u501f\u52a9\u4e00\u4e2a\u6570\u7ec4\u6765\u8bb0\u5f55\u6bcf\u4e2a\u5143\u7d20\u662f\u5426\u88ab\u9009\u62e9\uff0c\u526a\u679d\u6389\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\u7684\u641c\u7d22\u5206\u652f\uff0c\u786e\u4fdd\u6bcf\u4e2a\u5143\u7d20\u53ea\u88ab\u9009\u62e9\u4e00\u6b21\u3002
    • \u5728\u5168\u6392\u5217\u95ee\u9898\u4e2d\uff0c\u5982\u679c\u96c6\u5408\u4e2d\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff0c\u5219\u6700\u7ec8\u7ed3\u679c\u4f1a\u51fa\u73b0\u91cd\u590d\u6392\u5217\u3002\u6211\u4eec\u9700\u8981\u7ea6\u675f\u76f8\u7b49\u5143\u7d20\u5728\u6bcf\u8f6e\u4e2d\u53ea\u80fd\u88ab\u9009\u62e9\u4e00\u6b21\uff0c\u8fd9\u901a\u5e38\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868\u6765\u5b9e\u73b0\u3002
    • \u5b50\u96c6\u548c\u95ee\u9898\u7684\u76ee\u6807\u662f\u5728\u7ed9\u5b9a\u96c6\u5408\u4e2d\u627e\u5230\u548c\u4e3a\u76ee\u6807\u503c\u7684\u6240\u6709\u5b50\u96c6\u3002\u96c6\u5408\u4e0d\u533a\u5206\u5143\u7d20\u987a\u5e8f\uff0c\u800c\u641c\u7d22\u8fc7\u7a0b\u4f1a\u8f93\u51fa\u6240\u6709\u987a\u5e8f\u7684\u7ed3\u679c\uff0c\u4ea7\u751f\u91cd\u590d\u5b50\u96c6\u3002\u6211\u4eec\u5728\u56de\u6eaf\u524d\u5c06\u6570\u636e\u8fdb\u884c\u6392\u5e8f\uff0c\u5e76\u8bbe\u7f6e\u4e00\u4e2a\u53d8\u91cf\u6765\u6307\u793a\u6bcf\u4e00\u8f6e\u7684\u904d\u5386\u8d77\u70b9\uff0c\u4ece\u800c\u5c06\u751f\u6210\u91cd\u590d\u5b50\u96c6\u7684\u641c\u7d22\u5206\u652f\u8fdb\u884c\u526a\u679d\u3002
    • \u5bf9\u4e8e\u5b50\u96c6\u548c\u95ee\u9898\uff0c\u6570\u7ec4\u4e2d\u7684\u76f8\u7b49\u5143\u7d20\u4f1a\u4ea7\u751f\u91cd\u590d\u96c6\u5408\u3002\u6211\u4eec\u5229\u7528\u6570\u7ec4\u5df2\u6392\u5e8f\u7684\u524d\u7f6e\u6761\u4ef6\uff0c\u901a\u8fc7\u5224\u65ad\u76f8\u90bb\u5143\u7d20\u662f\u5426\u76f8\u7b49\u5b9e\u73b0\u526a\u679d\uff0c\u4ece\u800c\u786e\u4fdd\u76f8\u7b49\u5143\u7d20\u5728\u6bcf\u8f6e\u4e2d\u53ea\u80fd\u88ab\u9009\u4e2d\u4e00\u6b21\u3002
    • \\(n\\) \u7687\u540e\u65e8\u5728\u5bfb\u627e\u5c06 \\(n\\) \u4e2a\u7687\u540e\u653e\u7f6e\u5230 \\(n \\times n\\) \u5c3a\u5bf8\u68cb\u76d8\u4e0a\u7684\u65b9\u6848\uff0c\u8981\u6c42\u6240\u6709\u7687\u540e\u4e24\u4e24\u4e4b\u95f4\u65e0\u6cd5\u653b\u51fb\u5bf9\u65b9\u3002\u8be5\u95ee\u9898\u7684\u7ea6\u675f\u6761\u4ef6\u6709\u884c\u7ea6\u675f\u3001\u5217\u7ea6\u675f\u3001\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\u7ea6\u675f\u3002\u4e3a\u6ee1\u8db3\u884c\u7ea6\u675f\uff0c\u6211\u4eec\u91c7\u7528\u6309\u884c\u653e\u7f6e\u7684\u7b56\u7565\uff0c\u4fdd\u8bc1\u6bcf\u4e00\u884c\u653e\u7f6e\u4e00\u4e2a\u7687\u540e\u3002
    • \u5217\u7ea6\u675f\u548c\u5bf9\u89d2\u7ebf\u7ea6\u675f\u7684\u5904\u7406\u65b9\u5f0f\u7c7b\u4f3c\u3002\u5bf9\u4e8e\u5217\u7ea6\u675f\uff0c\u6211\u4eec\u5229\u7528\u4e00\u4e2a\u6570\u7ec4\u6765\u8bb0\u5f55\u6bcf\u4e00\u5217\u662f\u5426\u6709\u7687\u540e\uff0c\u4ece\u800c\u6307\u793a\u9009\u4e2d\u7684\u683c\u5b50\u662f\u5426\u5408\u6cd5\u3002\u5bf9\u4e8e\u5bf9\u89d2\u7ebf\u7ea6\u675f\uff0c\u6211\u4eec\u501f\u52a9\u4e24\u4e2a\u6570\u7ec4\u6765\u5206\u522b\u8bb0\u5f55\u8be5\u4e3b\u3001\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u5b58\u5728\u7687\u540e\uff1b\u96be\u70b9\u5728\u4e8e\u627e\u5904\u5728\u5230\u540c\u4e00\u4e3b\uff08\u526f\uff09\u5bf9\u89d2\u7ebf\u4e0a\u683c\u5b50\u6ee1\u8db3\u7684\u884c\u5217\u7d22\u5f15\u89c4\u5f8b\u3002
    "},{"location":"chapter_computational_complexity/","title":"2. \u00a0 \u590d\u6742\u5ea6","text":""},{"location":"chapter_computational_complexity/performance_evaluation/","title":"2.1. \u00a0 \u7b97\u6cd5\u6548\u7387\u8bc4\u4f30","text":""},{"location":"chapter_computational_complexity/performance_evaluation/#211","title":"2.1.1. \u00a0 \u7b97\u6cd5\u8bc4\u4ef7\u7ef4\u5ea6","text":"

    \u4ece\u603b\u4f53\u4e0a\u770b\uff0c\u7b97\u6cd5\u8bbe\u8ba1\u8ffd\u6c42\u4ee5\u4e0b\u4e24\u4e2a\u5c42\u9762\u7684\u76ee\u6807\uff1a

    1. \u627e\u5230\u95ee\u9898\u89e3\u6cd5\u3002\u7b97\u6cd5\u9700\u8981\u5728\u89c4\u5b9a\u7684\u8f93\u5165\u8303\u56f4\u5185\uff0c\u53ef\u9760\u5730\u6c42\u5f97\u95ee\u9898\u7684\u6b63\u786e\u89e3\u3002
    2. \u5bfb\u6c42\u6700\u4f18\u89e3\u6cd5\u3002\u540c\u4e00\u4e2a\u95ee\u9898\u53ef\u80fd\u5b58\u5728\u591a\u79cd\u89e3\u6cd5\uff0c\u6211\u4eec\u5e0c\u671b\u627e\u5230\u5c3d\u53ef\u80fd\u9ad8\u6548\u7684\u7b97\u6cd5\u3002

    \u56e0\u6b64\uff0c\u5728\u80fd\u591f\u89e3\u51b3\u95ee\u9898\u7684\u524d\u63d0\u4e0b\uff0c\u7b97\u6cd5\u6548\u7387\u6210\u4e3a\u4e3b\u8981\u7684\u8bc4\u4ef7\u7ef4\u5ea6\uff0c\u4e3b\u8981\u5305\u62ec\uff1a

    • \u65f6\u95f4\u6548\u7387\uff0c\u5373\u7b97\u6cd5\u8fd0\u884c\u901f\u5ea6\u7684\u5feb\u6162\u3002
    • \u7a7a\u95f4\u6548\u7387\uff0c\u5373\u7b97\u6cd5\u5360\u7528\u5185\u5b58\u7a7a\u95f4\u7684\u5927\u5c0f\u3002

    \u7b80\u800c\u8a00\u4e4b\uff0c\u6211\u4eec\u7684\u76ee\u6807\u662f\u8bbe\u8ba1\u201c\u65e2\u5feb\u53c8\u7701\u201d\u7684\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u3002\u638c\u63e1\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\u7684\u65b9\u6cd5\u5219\u81f3\u5173\u91cd\u8981\uff0c\u56e0\u4e3a\u53ea\u6709\u4e86\u89e3\u8bc4\u4ef7\u6807\u51c6\uff0c\u6211\u4eec\u624d\u80fd\u8fdb\u884c\u7b97\u6cd5\u4e4b\u95f4\u7684\u5bf9\u6bd4\u5206\u6790\uff0c\u4ece\u800c\u6307\u5bfc\u7b97\u6cd5\u8bbe\u8ba1\u4e0e\u4f18\u5316\u8fc7\u7a0b\u3002

    "},{"location":"chapter_computational_complexity/performance_evaluation/#212","title":"2.1.2. \u00a0 \u6548\u7387\u8bc4\u4f30\u65b9\u6cd5","text":""},{"location":"chapter_computational_complexity/performance_evaluation/#_1","title":"\u5b9e\u9645\u6d4b\u8bd5","text":"

    \u5047\u8bbe\u6211\u4eec\u73b0\u5728\u6709\u7b97\u6cd5 A \u548c\u7b97\u6cd5 B\uff0c\u5b83\u4eec\u90fd\u80fd\u89e3\u51b3\u540c\u4e00\u95ee\u9898\uff0c\u73b0\u5728\u9700\u8981\u5bf9\u6bd4\u8fd9\u4e24\u4e2a\u7b97\u6cd5\u7684\u6548\u7387\u3002\u6211\u4eec\u6700\u76f4\u63a5\u7684\u65b9\u6cd5\u5c31\u662f\u627e\u4e00\u53f0\u8ba1\u7b97\u673a\uff0c\u8fd0\u884c\u8fd9\u4e24\u4e2a\u7b97\u6cd5\uff0c\u5e76\u76d1\u63a7\u8bb0\u5f55\u5b83\u4eec\u7684\u8fd0\u884c\u65f6\u95f4\u548c\u5185\u5b58\u5360\u7528\u60c5\u51b5\u3002\u8fd9\u79cd\u8bc4\u4f30\u65b9\u5f0f\u80fd\u591f\u53cd\u6620\u771f\u5b9e\u60c5\u51b5\uff0c\u4f46\u4e5f\u5b58\u5728\u8f83\u5927\u5c40\u9650\u6027\u3002

    \u96be\u4ee5\u6392\u9664\u6d4b\u8bd5\u73af\u5883\u7684\u5e72\u6270\u56e0\u7d20\u3002\u786c\u4ef6\u914d\u7f6e\u4f1a\u5f71\u54cd\u7b97\u6cd5\u7684\u6027\u80fd\u8868\u73b0\u3002\u4f8b\u5982\uff0c\u5728\u67d0\u53f0\u8ba1\u7b97\u673a\u4e2d\uff0c\u7b97\u6cd5 A \u7684\u8fd0\u884c\u65f6\u95f4\u6bd4\u7b97\u6cd5 B \u77ed\uff1b\u4f46\u5728\u53e6\u4e00\u53f0\u914d\u7f6e\u4e0d\u540c\u7684\u8ba1\u7b97\u673a\u4e2d\uff0c\u6211\u4eec\u53ef\u80fd\u5f97\u5230\u76f8\u53cd\u7684\u6d4b\u8bd5\u7ed3\u679c\u3002\u8fd9\u610f\u5473\u7740\u6211\u4eec\u9700\u8981\u5728\u5404\u79cd\u673a\u5668\u4e0a\u8fdb\u884c\u6d4b\u8bd5\uff0c\u800c\u8fd9\u662f\u4e0d\u73b0\u5b9e\u7684\u3002

    \u5c55\u5f00\u5b8c\u6574\u6d4b\u8bd5\u975e\u5e38\u8017\u8d39\u8d44\u6e90\u3002\u968f\u7740\u8f93\u5165\u6570\u636e\u91cf\u7684\u53d8\u5316\uff0c\u7b97\u6cd5\u4f1a\u8868\u73b0\u51fa\u4e0d\u540c\u7684\u6548\u7387\u3002\u4f8b\u5982\uff0c\u8f93\u5165\u6570\u636e\u91cf\u8f83\u5c0f\u65f6\uff0c\u7b97\u6cd5 A \u7684\u8fd0\u884c\u65f6\u95f4\u53ef\u80fd\u77ed\u4e8e\u7b97\u6cd5 B\uff1b\u800c\u8f93\u5165\u6570\u636e\u91cf\u8f83\u5927\u65f6\uff0c\u6d4b\u8bd5\u7ed3\u679c\u53ef\u80fd\u76f8\u53cd\u3002\u56e0\u6b64\uff0c\u4e3a\u4e86\u5f97\u5230\u6709\u8bf4\u670d\u529b\u7684\u7ed3\u8bba\uff0c\u6211\u4eec\u9700\u8981\u6d4b\u8bd5\u5404\u79cd\u89c4\u6a21\u7684\u8f93\u5165\u6570\u636e\uff0c\u8fd9\u6837\u9700\u8981\u5360\u7528\u5927\u91cf\u7684\u8ba1\u7b97\u8d44\u6e90\u3002

    "},{"location":"chapter_computational_complexity/performance_evaluation/#_2","title":"\u7406\u8bba\u4f30\u7b97","text":"

    \u7531\u4e8e\u5b9e\u9645\u6d4b\u8bd5\u5177\u6709\u8f83\u5927\u7684\u5c40\u9650\u6027\uff0c\u6211\u4eec\u53ef\u4ee5\u8003\u8651\u4ec5\u901a\u8fc7\u4e00\u4e9b\u8ba1\u7b97\u6765\u8bc4\u4f30\u7b97\u6cd5\u7684\u6548\u7387\u3002\u8fd9\u79cd\u4f30\u7b97\u65b9\u6cd5\u88ab\u79f0\u4e3a\u300c\u590d\u6742\u5ea6\u5206\u6790 Complexity Analysis\u300d\u6216\u300c\u6e10\u8fd1\u590d\u6742\u5ea6\u5206\u6790 Asymptotic Complexity Analysis\u300d\u3002

    \u590d\u6742\u5ea6\u5206\u6790\u8bc4\u4f30\u7684\u662f\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u968f\u7740\u8f93\u5165\u6570\u636e\u91cf\u589e\u591a\u65f6\u7684\u589e\u957f\u8d8b\u52bf\u3002\u8fd9\u4e2a\u5b9a\u4e49\u6709\u4e9b\u62d7\u53e3\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5176\u5206\u4e3a\u4e09\u4e2a\u91cd\u70b9\u6765\u7406\u89e3\uff1a

    • \u201c\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u201d\u53ef\u5206\u4e3a\u201c\u8fd0\u884c\u65f6\u95f4\u201d\u548c\u201c\u5360\u7528\u7a7a\u95f4\u201d\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u5c06\u590d\u6742\u5ea6\u5206\u4e3a\u300c\u65f6\u95f4\u590d\u6742\u5ea6 Time Complexity\u300d\u548c\u300c\u7a7a\u95f4\u590d\u6742\u5ea6 Space Complexity\u300d\uff1b
    • \u201c\u968f\u7740\u8f93\u5165\u6570\u636e\u91cf\u589e\u591a\u65f6\u201d\u8868\u793a\u590d\u6742\u5ea6\u4e0e\u8f93\u5165\u6570\u636e\u91cf\u6709\u5173\uff0c\u53cd\u6620\u4e86\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u4e0e\u8f93\u5165\u6570\u636e\u91cf\u4e4b\u95f4\u7684\u5173\u7cfb\uff1b
    • \u201c\u589e\u957f\u8d8b\u52bf\u201d\u8868\u793a\u590d\u6742\u5ea6\u5206\u6790\u5173\u6ce8\u7684\u662f\u7b97\u6cd5\u65f6\u95f4\u4e0e\u7a7a\u95f4\u7684\u589e\u957f\u8d8b\u52bf\uff0c\u800c\u975e\u5177\u4f53\u7684\u8fd0\u884c\u65f6\u95f4\u6216\u5360\u7528\u7a7a\u95f4\uff1b

    \u590d\u6742\u5ea6\u5206\u6790\u514b\u670d\u4e86\u5b9e\u9645\u6d4b\u8bd5\u65b9\u6cd5\u7684\u5f0a\u7aef\u3002\u9996\u5148\uff0c\u5b83\u72ec\u7acb\u4e8e\u6d4b\u8bd5\u73af\u5883\uff0c\u56e0\u6b64\u5206\u6790\u7ed3\u679c\u9002\u7528\u4e8e\u6240\u6709\u8fd0\u884c\u5e73\u53f0\u3002\u5176\u6b21\uff0c\u5b83\u53ef\u4ee5\u4f53\u73b0\u4e0d\u540c\u6570\u636e\u91cf\u4e0b\u7684\u7b97\u6cd5\u6548\u7387\uff0c\u5c24\u5176\u662f\u5728\u5927\u6570\u636e\u91cf\u4e0b\u7684\u7b97\u6cd5\u6027\u80fd\u3002

    \u5982\u679c\u4f60\u5bf9\u590d\u6742\u5ea6\u5206\u6790\u7684\u6982\u5ff5\u4ecd\u611f\u5230\u56f0\u60d1\uff0c\u65e0\u9700\u62c5\u5fc3\uff0c\u6211\u4eec\u4f1a\u5728\u540e\u7eed\u7ae0\u8282\u8be6\u7ec6\u4ecb\u7ecd\u3002

    "},{"location":"chapter_computational_complexity/performance_evaluation/#213","title":"2.1.3. \u00a0 \u590d\u6742\u5ea6\u5206\u6790\u91cd\u8981\u6027","text":"

    \u590d\u6742\u5ea6\u5206\u6790\u4e3a\u6211\u4eec\u63d0\u4f9b\u4e86\u4e00\u628a\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\u7684\u201c\u6807\u5c3a\u201d\uff0c\u544a\u8bc9\u6211\u4eec\u6267\u884c\u67d0\u4e2a\u7b97\u6cd5\u6240\u9700\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u8d44\u6e90\uff0c\u5e76\u4f7f\u6211\u4eec\u80fd\u591f\u5bf9\u6bd4\u4e0d\u540c\u7b97\u6cd5\u4e4b\u95f4\u7684\u6548\u7387\u3002

    \u590d\u6742\u5ea6\u662f\u4e2a\u6570\u5b66\u6982\u5ff5\uff0c\u5bf9\u4e8e\u521d\u5b66\u8005\u53ef\u80fd\u6bd4\u8f83\u62bd\u8c61\uff0c\u5b66\u4e60\u96be\u5ea6\u76f8\u5bf9\u8f83\u9ad8\u3002\u4ece\u8fd9\u4e2a\u89d2\u5ea6\u770b\uff0c\u590d\u6742\u5ea6\u5206\u6790\u53ef\u80fd\u4e0d\u592a\u9002\u5408\u4f5c\u4e3a\u7b2c\u4e00\u7ae0\u7684\u5185\u5bb9\u3002\u7136\u800c\uff0c\u5f53\u6211\u4eec\u8ba8\u8bba\u67d0\u4e2a\u6570\u636e\u7ed3\u6784\u6216\u7b97\u6cd5\u7684\u7279\u70b9\u65f6\uff0c\u6211\u4eec\u96be\u4ee5\u907f\u514d\u8981\u5206\u6790\u5176\u8fd0\u884c\u901f\u5ea6\u548c\u7a7a\u95f4\u4f7f\u7528\u60c5\u51b5\u3002\u56e0\u6b64\uff0c\u5728\u6df1\u5165\u5b66\u4e60\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u4e4b\u524d\uff0c\u5efa\u8bae\u8bfb\u8005\u5148\u5bf9\u590d\u6742\u5ea6\u5efa\u7acb\u521d\u6b65\u7684\u4e86\u89e3\uff0c\u5e76\u80fd\u591f\u5b8c\u6210\u7b80\u5355\u6848\u4f8b\u7684\u590d\u6742\u5ea6\u5206\u6790\u3002

    "},{"location":"chapter_computational_complexity/space_complexity/","title":"2.3. \u00a0 \u7a7a\u95f4\u590d\u6742\u5ea6","text":"

    \u300c\u7a7a\u95f4\u590d\u6742\u5ea6 Space Complexity\u300d\u7528\u4e8e\u8861\u91cf\u7b97\u6cd5\u4f7f\u7528\u5185\u5b58\u7a7a\u95f4\u968f\u7740\u6570\u636e\u91cf\u53d8\u5927\u65f6\u7684\u589e\u957f\u8d8b\u52bf\u3002\u8fd9\u4e2a\u6982\u5ff5\u4e0e\u65f6\u95f4\u590d\u6742\u5ea6\u975e\u5e38\u7c7b\u4f3c\u3002

    "},{"location":"chapter_computational_complexity/space_complexity/#231","title":"2.3.1. \u00a0 \u7b97\u6cd5\u76f8\u5173\u7a7a\u95f4","text":"

    \u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u4f7f\u7528\u7684\u5185\u5b58\u7a7a\u95f4\u4e3b\u8981\u5305\u62ec\u4ee5\u4e0b\u51e0\u79cd\uff1a

    • \u300c\u8f93\u5165\u7a7a\u95f4\u300d\u7528\u4e8e\u5b58\u50a8\u7b97\u6cd5\u7684\u8f93\u5165\u6570\u636e\uff1b
    • \u300c\u6682\u5b58\u7a7a\u95f4\u300d\u7528\u4e8e\u5b58\u50a8\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u53d8\u91cf\u3001\u5bf9\u8c61\u3001\u51fd\u6570\u4e0a\u4e0b\u6587\u7b49\u6570\u636e\uff1b
    • \u300c\u8f93\u51fa\u7a7a\u95f4\u300d\u7528\u4e8e\u5b58\u50a8\u7b97\u6cd5\u7684\u8f93\u51fa\u6570\u636e\uff1b

    \u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u7edf\u8ba1\u8303\u56f4\u662f\u300c\u6682\u5b58\u7a7a\u95f4\u300d+\u300c\u8f93\u51fa\u7a7a\u95f4\u300d\u3002

    \u6682\u5b58\u7a7a\u95f4\u53ef\u4ee5\u8fdb\u4e00\u6b65\u5212\u5206\u4e3a\u4e09\u4e2a\u90e8\u5206\uff1a

    • \u300c\u6682\u5b58\u6570\u636e\u300d\u7528\u4e8e\u4fdd\u5b58\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u5404\u79cd\u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u7b49\u3002
    • \u300c\u6808\u5e27\u7a7a\u95f4\u300d\u7528\u4e8e\u4fdd\u5b58\u8c03\u7528\u51fd\u6570\u7684\u4e0a\u4e0b\u6587\u6570\u636e\u3002\u7cfb\u7edf\u5728\u6bcf\u6b21\u8c03\u7528\u51fd\u6570\u65f6\u90fd\u4f1a\u5728\u6808\u9876\u90e8\u521b\u5efa\u4e00\u4e2a\u6808\u5e27\uff0c\u51fd\u6570\u8fd4\u56de\u540e\uff0c\u6808\u5e27\u7a7a\u95f4\u4f1a\u88ab\u91ca\u653e\u3002
    • \u300c\u6307\u4ee4\u7a7a\u95f4\u300d\u7528\u4e8e\u4fdd\u5b58\u7f16\u8bd1\u540e\u7684\u7a0b\u5e8f\u6307\u4ee4\uff0c\u5728\u5b9e\u9645\u7edf\u8ba1\u4e2d\u901a\u5e38\u5ffd\u7565\u4e0d\u8ba1\u3002

    \u56e0\u6b64\uff0c\u5728\u5206\u6790\u4e00\u6bb5\u7a0b\u5e8f\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u65f6\uff0c\u6211\u4eec\u4e00\u822c\u7edf\u8ba1 \u6682\u5b58\u6570\u636e\u3001\u8f93\u51fa\u6570\u636e\u3001\u6808\u5e27\u7a7a\u95f4 \u4e09\u90e8\u5206\u3002

    Fig. \u7b97\u6cd5\u4f7f\u7528\u7684\u76f8\u5173\u7a7a\u95f4

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u7c7b */\nclass Node {\nint val;\nNode next;\nNode(int x) { val = x; }\n}\n/* \u51fd\u6570 */\nint function() {\n// do something...\nreturn 0;\n}\nint algorithm(int n) {        // \u8f93\u5165\u6570\u636e\nfinal int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nint b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nNode node = new Node(0);  // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nint c = function();       // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7ed3\u6784\u4f53 */\nstruct Node {\nint val;\nNode *next;\nNode(int x) : val(x), next(nullptr) {}\n};\n/* \u51fd\u6570 */\nint func() {\n// do something...\nreturn 0;\n}\nint algorithm(int n) {        // \u8f93\u5165\u6570\u636e\nconst int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nint b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nNode* node = new Node(0); // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nint c = func();           // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    class Node:\n\"\"\"\u7c7b\"\"\"\ndef __init__(self, x: int):\nself.val: int = x                 # \u8282\u70b9\u503c\nself.next: Optional[Node] = None  # \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\ndef function() -> int:\n\"\"\"\u51fd\u6570\"\"\"\n# do something...\nreturn 0\ndef algorithm(n) -> int:  # \u8f93\u5165\u6570\u636e\nA = 0                 # \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff0c\u4e00\u822c\u7528\u5927\u5199\u5b57\u6bcd\u8868\u793a\uff09\nb = 0                 # \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nnode = Node(0)        # \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nc = function()        # \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn A + b + c      # \u8f93\u51fa\u6570\u636e\n
    /* \u7ed3\u6784\u4f53 */\ntype node struct {\nval  int\nnext *node\n}\n/* \u521b\u5efa node \u7ed3\u6784\u4f53  */\nfunc newNode(val int) *node {\nreturn &node{val: val}\n}\n/* \u51fd\u6570 */\nfunc function() int {\n// do something...\nreturn 0\n}\nfunc algorithm(n int) int { // \u8f93\u5165\u6570\u636e\nconst a = 0             // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nb := 0                  // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nnewNode(0)              // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nc := function()         // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c        // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\nval;\nnext;\nconstructor(val) {\nthis.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\nthis.next = null;                       // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n}\n}\n/* \u51fd\u6570 */\nfunction constFunc() {\n// do something\nreturn 0;\n}\nfunction algorithm(n) {       // \u8f93\u5165\u6570\u636e\nconst a = 0;              // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nlet b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nconst node = new Node(0); // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nconst c = constFunc();    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\nval: number;\nnext: Node | null;\nconstructor(val?: number) {\nthis.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\nthis.next = null;                       // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n}\n}\n/* \u51fd\u6570 */\nfunction constFunc(): number {\n// do something\nreturn 0;\n}\nfunction algorithm(n: number): number { // \u8f93\u5165\u6570\u636e\nconst a = 0;                        // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nlet b = 0;                          // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nconst node = new Node(0);           // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nconst c = constFunc();              // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;                   // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u51fd\u6570 */\nint func() {\n// do something...\nreturn 0;\n}\nint algorithm(int n) { // \u8f93\u5165\u6570\u636e\nconst int a = 0;   // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nint b = 0;         // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nint c = func();    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;  // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node\n{\nint val;\nNode next;\nNode(int x) { val = x; }\n}\n/* \u51fd\u6570 */\nint function()\n{\n// do something...\nreturn 0;\n}\nint algorithm(int n)          // \u8f93\u5165\u6570\u636e\n{\nconst int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nint b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nNode node = new Node(0);  // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nint c = function();       // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\nvar val: Int\nvar next: Node?\ninit(x: Int) {\nval = x\n}\n}\n/* \u51fd\u6570 */\nfunc function() -> Int {\n// do something...\nreturn 0\n}\nfunc algorithm(n: Int) -> Int { // \u8f93\u5165\u6570\u636e\nlet a = 0             // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nvar b = 0             // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nlet node = Node(x: 0) // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nlet c = function()    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c      // \u8f93\u51fa\u6570\u636e\n}\n
    \n
    /* \u7c7b */\nclass Node {\nint val;\nNode next;\nNode(this.val, [this.next]);\n}\n/* \u51fd\u6570 */\nint function() {\n// do something...\nreturn 0;\n}\nint algorithm(int n) {  // \u8f93\u5165\u6570\u636e\nconst int a = 0;      // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nint b = 0;            // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nNode node = Node(0);  // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nint c = function();   // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;     // \u8f93\u51fa\u6570\u636e\n}\n
    "},{"location":"chapter_computational_complexity/space_complexity/#232","title":"2.3.2. \u00a0 \u63a8\u7b97\u65b9\u6cd5","text":"

    \u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u63a8\u7b97\u65b9\u6cd5\u4e0e\u65f6\u95f4\u590d\u6742\u5ea6\u5927\u81f4\u76f8\u540c\uff0c\u53ea\u662f\u5c06\u7edf\u8ba1\u5bf9\u8c61\u4ece\u201c\u8ba1\u7b97\u64cd\u4f5c\u6570\u91cf\u201d\u8f6c\u4e3a\u201c\u4f7f\u7528\u7a7a\u95f4\u5927\u5c0f\u201d\u3002\u4e0e\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u540c\u7684\u662f\uff0c\u6211\u4eec\u901a\u5e38\u53ea\u5173\u6ce8\u300c\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u300d\uff0c\u8fd9\u662f\u56e0\u4e3a\u5185\u5b58\u7a7a\u95f4\u662f\u4e00\u9879\u786c\u6027\u8981\u6c42\uff0c\u6211\u4eec\u5fc5\u987b\u786e\u4fdd\u5728\u6240\u6709\u8f93\u5165\u6570\u636e\u4e0b\u90fd\u6709\u8db3\u591f\u7684\u5185\u5b58\u7a7a\u95f4\u9884\u7559\u3002

    \u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e2d\u7684\u201c\u6700\u5dee\u201d\u6709\u4e24\u5c42\u542b\u4e49\uff0c\u5206\u522b\u662f\u8f93\u5165\u6570\u636e\u7684\u6700\u5dee\u5206\u5e03\u548c\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u6700\u5dee\u65f6\u95f4\u70b9\u3002

    • \u4ee5\u6700\u5dee\u8f93\u5165\u6570\u636e\u4e3a\u51c6\u3002\u5f53 \\(n < 10\\) \u65f6\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \uff1b\u4f46\u5f53 \\(n > 10\\) \u65f6\uff0c\u521d\u59cb\u5316\u7684\u6570\u7ec4 nums \u5360\u7528 \\(O(n)\\) \u7a7a\u95f4\uff1b\u56e0\u6b64\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff1b
    • \u4ee5\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u5cf0\u503c\u5185\u5b58\u4e3a\u51c6\u3002\u4f8b\u5982\uff0c\u7a0b\u5e8f\u5728\u6267\u884c\u6700\u540e\u4e00\u884c\u4e4b\u524d\uff0c\u5360\u7528 \\(O(1)\\) \u7a7a\u95f4\uff1b\u5f53\u521d\u59cb\u5316\u6570\u7ec4 nums \u65f6\uff0c\u7a0b\u5e8f\u5360\u7528 \\(O(n)\\) \u7a7a\u95f4\uff1b\u56e0\u6b64\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff1b
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    void algorithm(int n) {\nint a = 0;                   // O(1)\nint[] b = new int[10000];    // O(1)\nif (n > 10)\nint[] nums = new int[n]; // O(n)\n}\n
    void algorithm(int n) {\nint a = 0;               // O(1)\nvector<int> b(10000);    // O(1)\nif (n > 10)\nvector<int> nums(n); // O(n)\n}\n
    def algorithm(n: int) -> None:\na = 0               # O(1)\nb = [0] * 10000     # O(1)\nif n > 10:\nnums = [0] * n  # O(n)\n
    func algorithm(n int) {\na := 0                      // O(1)\nb := make([]int, 10000)     // O(1)\nvar nums []int\nif n > 10 {\nnums := make([]int, n)  // O(n)\n}\nfmt.Println(a, b, nums)\n}\n
    function algorithm(n) {\nconst a = 0;                   // O(1)\nconst b = new Array(10000);    // O(1)\nif (n > 10) {\nconst nums = new Array(n); // O(n)\n}\n}\n
    function algorithm(n: number): void {\nconst a = 0;                   // O(1)\nconst b = new Array(10000);    // O(1)\nif (n > 10) {\nconst nums = new Array(n); // O(n)\n}\n}\n
    void algorithm(int n) {\nint a = 0;               // O(1)\nint b[10000];            // O(1)\nif (n > 10)\nvector<int> nums(n); // O(n)\n}\n
    void algorithm(int n)\n{\nint a = 0;                   // O(1)\nint[] b = new int[10000];    // O(1)\nif (n > 10)\n{\nint[] nums = new int[n]; // O(n)\n}\n}\n
    func algorithm(n: Int) {\nlet a = 0 // O(1)\nlet b = Array(repeating: 0, count: 10000) // O(1)\nif n > 10 {\nlet nums = Array(repeating: 0, count: n) // O(n)\n}\n}\n
    \n
    void algorithm(int n) {\nint a = 0;                            // O(1)\nList<int> b = List.filled(10000, 0);  // O(1)\nif (n > 10) {\nList<int> nums = List.filled(n, 0); // O(n)\n}\n}\n

    \u5728\u9012\u5f52\u51fd\u6570\u4e2d\uff0c\u9700\u8981\u6ce8\u610f\u7edf\u8ba1\u6808\u5e27\u7a7a\u95f4\u3002\u4f8b\u5982\uff0c\u51fd\u6570 loop() \u5728\u5faa\u73af\u4e2d\u8c03\u7528\u4e86 \\(n\\) \u6b21 function() \uff0c\u6bcf\u8f6e\u4e2d\u7684 function() \u90fd\u8fd4\u56de\u5e76\u91ca\u653e\u4e86\u6808\u5e27\u7a7a\u95f4\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(1)\\) \u3002\u800c\u9012\u5f52\u51fd\u6570 recur() \u5728\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u4f1a\u540c\u65f6\u5b58\u5728 \\(n\\) \u4e2a\u672a\u8fd4\u56de\u7684 recur() \uff0c\u4ece\u800c\u5360\u7528 \\(O(n)\\) \u7684\u6808\u5e27\u7a7a\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    int function() {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\nfor (int i = 0; i < n; i++) {\nfunction();\n}\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\nif (n == 1) return;\nreturn recur(n - 1);\n}\n
    int func() {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\nfor (int i = 0; i < n; i++) {\nfunc();\n}\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\nif (n == 1) return;\nreturn recur(n - 1);\n}\n
    def function() -> int:\n# do something\nreturn 0\ndef loop(n: int) -> None:\n\"\"\"\u5faa\u73af O(1)\"\"\"\nfor _ in range(n):\nfunction()\ndef recur(n: int) -> int:\n\"\"\"\u9012\u5f52 O(n)\"\"\"\nif n == 1: return\nreturn recur(n - 1)\n
    func function() int {\n// do something\nreturn 0\n}\n/* \u5faa\u73af O(1) */\nfunc loop(n int) {\nfor i := 0; i < n; i++ {\nfunction()\n}\n}\n/* \u9012\u5f52 O(n) */\nfunc recur(n int) {\nif n == 1 {\nreturn\n}\nrecur(n - 1)\n}\n
    function constFunc() {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nfunction loop(n) {\nfor (let i = 0; i < n; i++) {\nconstFunc();\n}\n}\n/* \u9012\u5f52 O(n) */\nfunction recur(n) {\nif (n === 1) return;\nreturn recur(n - 1);\n}\n
    function constFunc(): number {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nfunction loop(n: number): void {\nfor (let i = 0; i < n; i++) {\nconstFunc();\n}\n}\n/* \u9012\u5f52 O(n) */\nfunction recur(n: number): void {\nif (n === 1) return;\nreturn recur(n - 1);\n}\n
    int func() {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\nfor (int i = 0; i < n; i++) {\nfunc();\n}\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\nif (n == 1) return;\nreturn recur(n - 1);\n}\n
    int function()\n{\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n)\n{\nfor (int i = 0; i < n; i++)\n{\nfunction();\n}\n}\n/* \u9012\u5f52 O(n) */\nint recur(int n)\n{\nif (n == 1) return 1;\nreturn recur(n - 1);\n}\n
    @discardableResult\nfunc function() -> Int {\n// do something\nreturn 0\n}\n/* \u5faa\u73af O(1) */\nfunc loop(n: Int) {\nfor _ in 0 ..< n {\nfunction()\n}\n}\n/* \u9012\u5f52 O(n) */\nfunc recur(n: Int) {\nif n == 1 {\nreturn\n}\nrecur(n: n - 1)\n}\n
    \n
    int function() {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\nfor (int i = 0; i < n; i++) {\nfunction();\n}\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\nif (n == 1) return;\nreturn recur(n - 1);\n}\n
    "},{"location":"chapter_computational_complexity/space_complexity/#233","title":"2.3.3. \u00a0 \u5e38\u89c1\u7c7b\u578b","text":"

    \u8bbe\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u5e38\u89c1\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u7c7b\u578b\u6709\uff08\u4ece\u4f4e\u5230\u9ad8\u6392\u5217\uff09

    \\[ \\begin{aligned} O(1) < O(\\log n) < O(n) < O(n^2) < O(2^n) \\newline \\text{\u5e38\u6570\u9636} < \\text{\u5bf9\u6570\u9636} < \\text{\u7ebf\u6027\u9636} < \\text{\u5e73\u65b9\u9636} < \\text{\u6307\u6570\u9636} \\end{aligned} \\]

    Fig. \u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u5e38\u89c1\u7c7b\u578b

    Tip

    \u90e8\u5206\u793a\u4f8b\u4ee3\u7801\u9700\u8981\u4e00\u4e9b\u524d\u7f6e\u77e5\u8bc6\uff0c\u5305\u62ec\u6570\u7ec4\u3001\u94fe\u8868\u3001\u4e8c\u53c9\u6811\u3001\u9012\u5f52\u7b97\u6cd5\u7b49\u3002\u5982\u679c\u9047\u5230\u770b\u4e0d\u61c2\u7684\u5730\u65b9\u65e0\u9700\u62c5\u5fc3\uff0c\u53ef\u4ee5\u5728\u5b66\u4e60\u5b8c\u540e\u9762\u7ae0\u8282\u540e\u518d\u6765\u590d\u4e60\uff0c\u73b0\u9636\u6bb5\u6211\u4eec\u5148\u4e13\u6ce8\u4e8e\u7406\u89e3\u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u542b\u4e49\u548c\u63a8\u7b97\u65b9\u6cd5\u3002

    "},{"location":"chapter_computational_complexity/space_complexity/#o1","title":"\u5e38\u6570\u9636 \\(O(1)\\)","text":"

    \u5e38\u6570\u9636\u5e38\u89c1\u4e8e\u6570\u91cf\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u65e0\u5173\u7684\u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u3002

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u5728\u5faa\u73af\u4e2d\u521d\u59cb\u5316\u53d8\u91cf\u6216\u8c03\u7528\u51fd\u6570\u800c\u5360\u7528\u7684\u5185\u5b58\uff0c\u5728\u8fdb\u5165\u4e0b\u4e00\u5faa\u73af\u540e\u5c31\u4f1a\u88ab\u91ca\u653e\uff0c\u5373\u4e0d\u4f1a\u7d2f\u79ef\u5360\u7528\u7a7a\u95f4\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(1)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nfinal int a = 0;\nint b = 0;\nint[] nums = new int[10000];\nListNode node = new ListNode(0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nint c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nfunction();\n}\n}\n
    space_complexity.cpp
    /* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst int a = 0;\nint b = 0;\nvector<int> nums(10000);\nListNode node(0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nint c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nfunc();\n}\n}\n
    space_complexity.py
    def constant(n: int) -> None:\n\"\"\"\u5e38\u6570\u9636\"\"\"\n# \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\na = 0\nnums = [0] * 10000\nnode = ListNode(0)\n# \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor _ in range(n):\nc = 0\n# \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor _ in range(n):\nfunction()\n
    space_complexity.go
    /* \u5e38\u6570\u9636 */\nfunc spaceConstant(n int) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst a = 0\nb := 0\nnums := make([]int, 10000)\nListNode := newNode(0)\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nvar c int\nfor i := 0; i < n; i++ {\nc = 0\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor i := 0; i < n; i++ {\nfunction()\n}\nfmt.Println(a, b, nums, c, ListNode)\n}\n
    space_complexity.js
    /* \u5e38\u6570\u9636 */\nfunction constant(n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst a = 0;\nconst b = 0;\nconst nums = new Array(10000);\nconst node = new ListNode(0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (let i = 0; i < n; i++) {\nconst c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (let i = 0; i < n; i++) {\nconstFunc();\n}\n}\n
    space_complexity.ts
    /* \u5e38\u6570\u9636 */\nfunction constant(n: number): void {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst a = 0;\nconst b = 0;\nconst nums = new Array(10000);\nconst node = new ListNode(0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (let i = 0; i < n; i++) {\nconst c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (let i = 0; i < n; i++) {\nconstFunc();\n}\n}\n
    space_complexity.c
    /* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst int a = 0;\nint b = 0;\nint nums[1000];\nListNode *node = newListNode(0);\nfree(node);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nint c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nfunc();\n}\n}\n
    space_complexity.cs
    /* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nint a = 0;\nint b = 0;\nint[] nums = new int[10000];\nListNode node = new ListNode(0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nint c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nfunction();\n}\n}\n
    space_complexity.swift
    /* \u5e38\u6570\u9636 */\nfunc constant(n: Int) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nlet a = 0\nvar b = 0\nlet nums = Array(repeating: 0, count: 10000)\nlet node = ListNode(x: 0)\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor _ in 0 ..< n {\nlet c = 0\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor _ in 0 ..< n {\nfunction()\n}\n}\n
    space_complexity.zig
    // \u5e38\u6570\u9636\nfn constant(n: i32) void {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst a: i32 = 0;\nvar b: i32 = 0;\nvar nums = [_]i32{0}**10000;\nvar node = inc.ListNode(i32){.val = 0};\nvar i: i32 = 0;\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nwhile (i < n) : (i += 1) {\nvar c: i32 = 0;\n_ = c;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\ni = 0;\nwhile (i < n) : (i += 1) {\n_ = function();\n}\n_ = a;\n_ = b;\n_ = nums;\n_ = node;\n}\n
    space_complexity.dart
    /* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nfinal int a = 0;\nint b = 0;\nList<int> nums = List.filled(10000, 0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (var i = 0; i < n; i++) {\nint c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (var i = 0; i < n; i++) {\nfunction();\n}\n}\n
    "},{"location":"chapter_computational_complexity/space_complexity/#on","title":"\u7ebf\u6027\u9636 \\(O(n)\\)","text":"

    \u7ebf\u6027\u9636\u5e38\u89c1\u4e8e\u5143\u7d20\u6570\u91cf\u4e0e \\(n\\) \u6210\u6b63\u6bd4\u7684\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\u7b49\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nint[] nums = new int[n];\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nList<ListNode> nodes = new ArrayList<>();\nfor (int i = 0; i < n; i++) {\nnodes.add(new ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nMap<Integer, String> map = new HashMap<>();\nfor (int i = 0; i < n; i++) {\nmap.put(i, String.valueOf(i));\n}\n}\n
    space_complexity.cpp
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nvector<int> nums(n);\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nvector<ListNode> nodes;\nfor (int i = 0; i < n; i++) {\nnodes.push_back(ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nunordered_map<int, string> map;\nfor (int i = 0; i < n; i++) {\nmap[i] = to_string(i);\n}\n}\n
    space_complexity.py
    def linear(n: int) -> None:\n\"\"\"\u7ebf\u6027\u9636\"\"\"\n# \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nnums = [0] * n\n# \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nmapp = dict[int, str]()\nfor i in range(n):\nmapp[i] = str(i)\n
    space_complexity.go
    /* \u7ebf\u6027\u9636 */\nfunc spaceLinear(n int) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n_ = make([]int, n)\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nvar nodes []*node\nfor i := 0; i < n; i++ {\nnodes = append(nodes, newNode(i))\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nm := make(map[int]string, n)\nfor i := 0; i < n; i++ {\nm[i] = strconv.Itoa(i)\n}\n}\n
    space_complexity.js
    /* \u7ebf\u6027\u9636 */\nfunction linear(n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nconst nums = new Array(n);\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nconst nodes = [];\nfor (let i = 0; i < n; i++) {\nnodes.push(new ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nconst map = new Map();\nfor (let i = 0; i < n; i++) {\nmap.set(i, i.toString());\n}\n}\n
    space_complexity.ts
    /* \u7ebf\u6027\u9636 */\nfunction linear(n: number): void {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nconst nums = new Array(n);\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nconst nodes: ListNode[] = [];\nfor (let i = 0; i < n; i++) {\nnodes.push(new ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nconst map = new Map();\nfor (let i = 0; i < n; i++) {\nmap.set(i, i.toString());\n}\n}\n
    space_complexity.c
    /* \u54c8\u5e0c\u8868 */\nstruct hashTable {\nint key;\nint val;\nUT_hash_handle hh; // \u57fa\u4e8e uthash.h \u5b9e\u73b0\n};\ntypedef struct hashTable hashTable;\n/* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nint *nums = malloc(sizeof(int) * n);\nfree(nums);\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nListNode **nodes = malloc(sizeof(ListNode *) * n);\nfor (int i = 0; i < n; i++) {\nnodes[i] = newListNode(i);\n}\n// \u5185\u5b58\u91ca\u653e\nfor (int i = 0; i < n; i++) {\nfree(nodes[i]);\n}\nfree(nodes);\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nhashTable *h = NULL;\nfor (int i = 0; i < n; i++) {\nhashTable *tmp = malloc(sizeof(hashTable));\ntmp->key = i;\ntmp->val = i;\nHASH_ADD_INT(h, key, tmp);\n}\n// \u5185\u5b58\u91ca\u653e\nhashTable *curr, *tmp;\nHASH_ITER(hh, h, curr, tmp) {\nHASH_DEL(h, curr);\nfree(curr);\n}\n}\n
    space_complexity.cs
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nint[] nums = new int[n];\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nList<ListNode> nodes = new();\nfor (int i = 0; i < n; i++) {\nnodes.Add(new ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nDictionary<int, string> map = new();\nfor (int i = 0; i < n; i++) {\nmap.Add(i, i.ToString());\n}\n}\n
    space_complexity.swift
    /* \u7ebf\u6027\u9636 */\nfunc linear(n: Int) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nlet nums = Array(repeating: 0, count: n)\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nlet nodes = (0 ..< n).map { ListNode(x: $0) }\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nlet map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, \"\\($0)\") })\n}\n
    space_complexity.zig
    // \u7ebf\u6027\u9636\nfn linear(comptime n: i32) !void {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nvar nums = [_]i32{0}**n;\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nvar nodes = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer nodes.deinit();\nvar i: i32 = 0;\nwhile (i < n) : (i += 1) {\ntry nodes.append(i);\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nvar map = std.AutoArrayHashMap(i32, []const u8).init(std.heap.page_allocator);\ndefer map.deinit();\nvar j: i32 = 0;\nwhile (j < n) : (j += 1) {\nconst string = try std.fmt.allocPrint(std.heap.page_allocator, \"{d}\", .{j});\ndefer std.heap.page_allocator.free(string);\ntry map.put(i, string);\n}\n_ = nums;\n}\n
    space_complexity.dart
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nList<int> nums = List.filled(n, 0);\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nList<ListNode> nodes = [];\nfor (var i = 0; i < n; i++) {\nnodes.add(ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nMap<int, String> map = HashMap();\nfor (var i = 0; i < n; i++) {\nmap.putIfAbsent(i, () => i.toString());\n}\n}\n

    \u4ee5\u4e0b\u9012\u5f52\u51fd\u6570\u4f1a\u540c\u65f6\u5b58\u5728 \\(n\\) \u4e2a\u672a\u8fd4\u56de\u7684 algorithm() \u51fd\u6570\uff0c\u4f7f\u7528 \\(O(n)\\) \u5927\u5c0f\u7684\u6808\u5e27\u7a7a\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\nSystem.out.println(\"\u9012\u5f52 n = \" + n);\nif (n == 1)\nreturn;\nlinearRecur(n - 1);\n}\n
    space_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\ncout << \"\u9012\u5f52 n = \" << n << endl;\nif (n == 1)\nreturn;\nlinearRecur(n - 1);\n}\n
    space_complexity.py
    def linear_recur(n: int) -> None:\n\"\"\"\u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\nprint(\"\u9012\u5f52 n =\", n)\nif n == 1:\nreturn\nlinear_recur(n - 1)\n
    space_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceLinearRecur(n int) {\nfmt.Println(\"\u9012\u5f52 n =\", n)\nif n == 1 {\nreturn\n}\nspaceLinearRecur(n - 1)\n}\n
    space_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n) {\nconsole.log(`\u9012\u5f52 n = ${n}`);\nif (n === 1) return;\nlinearRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n: number): void {\nconsole.log(`\u9012\u5f52 n = ${n}`);\nif (n === 1) return;\nlinearRecur(n - 1);\n}\n
    space_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\nprintf(\"\u9012\u5f52 n = %d\\r\\n\", n);\nif (n == 1)\nreturn;\nlinearRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\nConsole.WriteLine(\"\u9012\u5f52 n = \" + n);\nif (n == 1) return;\nlinearRecur(n - 1);\n}\n
    space_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc linearRecur(n: Int) {\nprint(\"\u9012\u5f52 n = \\(n)\")\nif n == 1 {\nreturn\n}\nlinearRecur(n: n - 1)\n}\n
    space_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn linearRecur(comptime n: i32) void {\nstd.debug.print(\"\u9012\u5f52 n = {}\\n\", .{n});\nif (n == 1) return;\nlinearRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\nprint('\u9012\u5f52 n = $n');\nif (n == 1) return;\nlinearRecur(n - 1);\n}\n

    Fig. \u9012\u5f52\u51fd\u6570\u4ea7\u751f\u7684\u7ebf\u6027\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/space_complexity/#on2","title":"\u5e73\u65b9\u9636 \\(O(n^2)\\)","text":"

    \u5e73\u65b9\u9636\u5e38\u89c1\u4e8e\u77e9\u9635\u548c\u56fe\uff0c\u5143\u7d20\u6570\u91cf\u4e0e \\(n\\) \u6210\u5e73\u65b9\u5173\u7cfb\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nint[][] numMatrix = new int[n][n];\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nList<List<Integer>> numList = new ArrayList<>();\nfor (int i = 0; i < n; i++) {\nList<Integer> tmp = new ArrayList<>();\nfor (int j = 0; j < n; j++) {\ntmp.add(0);\n}\nnumList.add(tmp);\n}\n}\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nvector<vector<int>> numMatrix;\nfor (int i = 0; i < n; i++) {\nvector<int> tmp;\nfor (int j = 0; j < n; j++) {\ntmp.push_back(0);\n}\nnumMatrix.push_back(tmp);\n}\n}\n
    space_complexity.py
    def quadratic(n: int) -> None:\n\"\"\"\u5e73\u65b9\u9636\"\"\"\n# \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nnum_matrix = [[0] * n for _ in range(n)]\n
    space_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc spaceQuadratic(n int) {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nnumMatrix := make([][]int, n)\nfor i := 0; i < n; i++ {\nnumMatrix[i] = make([]int, n)\n}\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nconst numMatrix = Array(n)\n.fill(null)\n.map(() => Array(n).fill(null));\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nconst numList = [];\nfor (let i = 0; i < n; i++) {\nconst tmp = [];\nfor (let j = 0; j < n; j++) {\ntmp.push(0);\n}\nnumList.push(tmp);\n}\n}\n
    space_complexity.ts
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n: number): void {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nconst numMatrix = Array(n)\n.fill(null)\n.map(() => Array(n).fill(null));\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nconst numList = [];\nfor (let i = 0; i < n; i++) {\nconst tmp = [];\nfor (let j = 0; j < n; j++) {\ntmp.push(0);\n}\nnumList.push(tmp);\n}\n}\n
    space_complexity.c
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nint **numMatrix = malloc(sizeof(int *) * n);\nfor (int i = 0; i < n; i++) {\nint *tmp = malloc(sizeof(int) * n);\nfor (int j = 0; j < n; j++) {\ntmp[j] = 0;\n}\nnumMatrix[i] = tmp;\n}\n// \u5185\u5b58\u91ca\u653e\nfor (int i = 0; i < n; i++) {\nfree(numMatrix[i]);\n}\nfree(numMatrix);\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nint[,] numMatrix = new int[n, n];\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nList<List<int>> numList = new();\nfor (int i = 0; i < n; i++) {\nList<int> tmp = new();\nfor (int j = 0; j < n; j++) {\ntmp.Add(0);\n}\nnumList.Add(tmp);\n}\n}\n
    space_complexity.swift
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n: Int) {\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nlet numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) !void {\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nvar nodes = std.ArrayList(std.ArrayList(i32)).init(std.heap.page_allocator);\ndefer nodes.deinit();\nvar i: i32 = 0;\nwhile (i < n) : (i += 1) {\nvar tmp = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer tmp.deinit();\nvar j: i32 = 0;\nwhile (j < n) : (j += 1) {\ntry tmp.append(0);\n}\ntry nodes.append(tmp);\n}\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nList<List<int>> numMatrix = List.generate(n, (_) => List.filled(n, 0));\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nList<List<int>> numList = [];\nfor (var i = 0; i < n; i++) {\nList<int> tmp = [];\nfor (int j = 0; j < n; j++) {\ntmp.add(0);\n}\nnumList.add(tmp);\n}\n}\n

    \u5728\u4ee5\u4e0b\u9012\u5f52\u51fd\u6570\u4e2d\uff0c\u540c\u65f6\u5b58\u5728 \\(n\\) \u4e2a\u672a\u8fd4\u56de\u7684 algorithm() \uff0c\u5e76\u4e14\u6bcf\u4e2a\u51fd\u6570\u4e2d\u90fd\u521d\u59cb\u5316\u4e86\u4e00\u4e2a\u6570\u7ec4\uff0c\u957f\u5ea6\u5206\u522b\u4e3a \\(n, n-1, n-2, ..., 2, 1\\) \uff0c\u5e73\u5747\u957f\u5ea6\u4e3a \\(\\frac{n}{2}\\) \uff0c\u56e0\u6b64\u603b\u4f53\u5360\u7528 \\(O(n^2)\\) \u7a7a\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\nif (n <= 0)\nreturn 0;\n// \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\nint[] nums = new int[n];\nSystem.out.println(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.length);\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\nif (n <= 0)\nreturn 0;\nvector<int> nums(n);\ncout << \"\u9012\u5f52 n = \" << n << \" \u4e2d\u7684 nums \u957f\u5ea6 = \" << nums.size() << endl;\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.py
    def quadratic_recur(n: int) -> int:\n\"\"\"\u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\nif n <= 0:\nreturn 0\n# \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\nnums = [0] * n\nreturn quadratic_recur(n - 1)\n
    space_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceQuadraticRecur(n int) int {\nif n <= 0 {\nreturn 0\n}\nnums := make([]int, n)\nfmt.Printf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d \\n\", n, len(nums))\nreturn spaceQuadraticRecur(n - 1)\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n) {\nif (n <= 0) return 0;\nconst nums = new Array(n);\nconsole.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n: number): number {\nif (n <= 0) return 0;\nconst nums = new Array(n);\nconsole.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\nif (n <= 0)\nreturn 0;\nint *nums = malloc(sizeof(int) * n);\nprintf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d\\r\\n\", n, n);\nfree(nums);\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\nif (n <= 0) return 0;\nint[] nums = new int[n];\nConsole.WriteLine(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.Length);\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\n@discardableResult\nfunc quadraticRecur(n: Int) -> Int {\nif n <= 0 {\nreturn 0\n}\n// \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\nlet nums = Array(repeating: 0, count: n)\nprint(\"\u9012\u5f52 n = \\(n) \u4e2d\u7684 nums \u957f\u5ea6 = \\(nums.count)\")\nreturn quadraticRecur(n: n - 1)\n}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn quadraticRecur(comptime n: i32) i32 {\nif (n <= 0) return 0;\nvar nums = [_]i32{0}**n;\nstd.debug.print(\"\u9012\u5f52 n = {} \u4e2d\u7684 nums \u957f\u5ea6 = {}\\n\", .{n, nums.len});\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\nif (n <= 0) return 0;\nList<int> nums = List.filled(n, 0);\nprint('\u9012\u5f52 n = $n \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}');\nreturn quadraticRecur(n - 1);\n}\n

    Fig. \u9012\u5f52\u51fd\u6570\u4ea7\u751f\u7684\u5e73\u65b9\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/space_complexity/#o2n","title":"\u6307\u6570\u9636 \\(O(2^n)\\)","text":"

    \u6307\u6570\u9636\u5e38\u89c1\u4e8e\u4e8c\u53c9\u6811\u3002\u9ad8\u5ea6\u4e3a \\(n\\) \u7684\u300c\u6ee1\u4e8c\u53c9\u6811\u300d\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\(2^n - 1\\) \uff0c\u5360\u7528 \\(O(2^n)\\) \u7a7a\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode buildTree(int n) {\nif (n == 0)\nreturn null;\nTreeNode root = new TreeNode(0);\nroot.left = buildTree(n - 1);\nroot.right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\nif (n == 0)\nreturn nullptr;\nTreeNode *root = new TreeNode(0);\nroot->left = buildTree(n - 1);\nroot->right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.py
    def build_tree(n: int) -> TreeNode | None:\n\"\"\"\u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09\"\"\"\nif n == 0:\nreturn None\nroot = TreeNode(0)\nroot.left = build_tree(n - 1)\nroot.right = build_tree(n - 1)\nreturn root\n
    space_complexity.go
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n int) *treeNode {\nif n == 0 {\nreturn nil\n}\nroot := newTreeNode(0)\nroot.left = buildTree(n - 1)\nroot.right = buildTree(n - 1)\nreturn root\n}\n
    space_complexity.js
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n) {\nif (n === 0) return null;\nconst root = new TreeNode(0);\nroot.left = buildTree(n - 1);\nroot.right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n: number): TreeNode | null {\nif (n === 0) return null;\nconst root = new TreeNode(0);\nroot.left = buildTree(n - 1);\nroot.right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.c
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\nif (n == 0)\nreturn NULL;\nTreeNode *root = newTreeNode(0);\nroot->left = buildTree(n - 1);\nroot->right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? buildTree(int n) {\nif (n == 0) return null;\nTreeNode root = new TreeNode(0);\nroot.left = buildTree(n - 1);\nroot.right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n: Int) -> TreeNode? {\nif n == 0 {\nreturn nil\n}\nlet root = TreeNode(x: 0)\nroot.left = buildTree(n: n - 1)\nroot.right = buildTree(n: n - 1)\nreturn root\n}\n
    space_complexity.zig
    // \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09\nfn buildTree(mem_allocator: std.mem.Allocator, n: i32) !?*inc.TreeNode(i32) {\nif (n == 0) return null;\nconst root = try mem_allocator.create(inc.TreeNode(i32));\nroot.init(0);\nroot.left = try buildTree(mem_allocator, n - 1);\nroot.right = try buildTree(mem_allocator, n - 1);\nreturn root;\n}\n
    space_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? buildTree(int n) {\nif (n == 0) return null;\nTreeNode root = TreeNode(0);\nroot.left = buildTree(n - 1);\nroot.right = buildTree(n - 1);\nreturn root;\n}\n

    Fig. \u6ee1\u4e8c\u53c9\u6811\u4ea7\u751f\u7684\u6307\u6570\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/space_complexity/#olog-n","title":"\u5bf9\u6570\u9636 \\(O(\\log n)\\)","text":"

    \u5bf9\u6570\u9636\u5e38\u89c1\u4e8e\u5206\u6cbb\u7b97\u6cd5\u548c\u6570\u636e\u7c7b\u578b\u8f6c\u6362\u7b49\u3002

    \u4f8b\u5982\u201c\u5f52\u5e76\u6392\u5e8f\u201d\u7b97\u6cd5\uff0c\u8f93\u5165\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4\uff0c\u6bcf\u8f6e\u9012\u5f52\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5212\u5206\u4e3a\u4e24\u534a\uff0c\u5f62\u6210\u9ad8\u5ea6\u4e3a \\(\\log n\\) \u7684\u9012\u5f52\u6811\uff0c\u4f7f\u7528 \\(O(\\log n)\\) \u6808\u5e27\u7a7a\u95f4\u3002

    \u518d\u4f8b\u5982\u201c\u6570\u5b57\u8f6c\u5316\u4e3a\u5b57\u7b26\u4e32\u201d\uff0c\u8f93\u5165\u4efb\u610f\u6b63\u6574\u6570 \\(n\\) \uff0c\u5b83\u7684\u4f4d\u6570\u4e3a \\(\\log_{10} n\\) \uff0c\u5373\u5bf9\u5e94\u5b57\u7b26\u4e32\u957f\u5ea6\u4e3a \\(\\log_{10} n\\) \uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log_{10} n) = O(\\log n)\\) \u3002

    "},{"location":"chapter_computational_complexity/space_complexity/#234","title":"2.3.4. \u00a0 \u6743\u8861\u65f6\u95f4\u4e0e\u7a7a\u95f4","text":"

    \u7406\u60f3\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u5e0c\u671b\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u90fd\u80fd\u8fbe\u5230\u6700\u4f18\u3002\u7136\u800c\u5728\u5b9e\u9645\u60c5\u51b5\u4e2d\uff0c\u540c\u65f6\u4f18\u5316\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u901a\u5e38\u662f\u975e\u5e38\u56f0\u96be\u7684\u3002

    \u964d\u4f4e\u65f6\u95f4\u590d\u6742\u5ea6\u901a\u5e38\u9700\u8981\u4ee5\u63d0\u5347\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a\u4ee3\u4ef7\uff0c\u53cd\u4e4b\u4ea6\u7136\u3002\u6211\u4eec\u5c06\u727a\u7272\u5185\u5b58\u7a7a\u95f4\u6765\u63d0\u5347\u7b97\u6cd5\u8fd0\u884c\u901f\u5ea6\u7684\u601d\u8def\u79f0\u4e3a\u201c\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u201d\uff1b\u53cd\u4e4b\uff0c\u5219\u79f0\u4e3a\u201c\u4ee5\u65f6\u95f4\u6362\u7a7a\u95f4\u201d\u3002

    \u9009\u62e9\u54ea\u79cd\u601d\u8def\u53d6\u51b3\u4e8e\u6211\u4eec\u66f4\u770b\u91cd\u54ea\u4e2a\u65b9\u9762\u3002\u5728\u5927\u591a\u6570\u60c5\u51b5\u4e0b\uff0c\u65f6\u95f4\u6bd4\u7a7a\u95f4\u66f4\u5b9d\u8d35\uff0c\u56e0\u6b64\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u901a\u5e38\u662f\u66f4\u5e38\u7528\u7684\u7b56\u7565\u3002\u5f53\u7136\uff0c\u5728\u6570\u636e\u91cf\u5f88\u5927\u7684\u60c5\u51b5\u4e0b\uff0c\u63a7\u5236\u7a7a\u95f4\u590d\u6742\u5ea6\u4e5f\u662f\u975e\u5e38\u91cd\u8981\u7684\u3002

    "},{"location":"chapter_computational_complexity/summary/","title":"2.4. \u00a0 \u5c0f\u7ed3","text":"

    \u7b97\u6cd5\u6548\u7387\u8bc4\u4f30

    • \u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u662f\u8bc4\u4ef7\u7b97\u6cd5\u6027\u80fd\u7684\u4e24\u4e2a\u5173\u952e\u7ef4\u5ea6\u3002
    • \u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u5b9e\u9645\u6d4b\u8bd5\u6765\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\uff0c\u4f46\u96be\u4ee5\u6d88\u9664\u6d4b\u8bd5\u73af\u5883\u7684\u5f71\u54cd\uff0c\u4e14\u4f1a\u8017\u8d39\u5927\u91cf\u8ba1\u7b97\u8d44\u6e90\u3002
    • \u590d\u6742\u5ea6\u5206\u6790\u53ef\u4ee5\u514b\u670d\u5b9e\u9645\u6d4b\u8bd5\u7684\u5f0a\u7aef\uff0c\u5206\u6790\u7ed3\u679c\u9002\u7528\u4e8e\u6240\u6709\u8fd0\u884c\u5e73\u53f0\uff0c\u5e76\u4e14\u80fd\u591f\u63ed\u793a\u7b97\u6cd5\u5728\u4e0d\u540c\u6570\u636e\u89c4\u6a21\u4e0b\u7684\u6548\u7387\u3002

    \u65f6\u95f4\u590d\u6742\u5ea6

    • \u65f6\u95f4\u590d\u6742\u5ea6\u7528\u4e8e\u8861\u91cf\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u968f\u6570\u636e\u91cf\u589e\u957f\u7684\u8d8b\u52bf\uff0c\u53ef\u4ee5\u6709\u6548\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\uff0c\u4f46\u5728\u67d0\u4e9b\u60c5\u51b5\u4e0b\u53ef\u80fd\u5931\u6548\uff0c\u5982\u5728\u8f93\u5165\u6570\u636e\u91cf\u8f83\u5c0f\u6216\u65f6\u95f4\u590d\u6742\u5ea6\u76f8\u540c\u65f6\uff0c\u65e0\u6cd5\u7cbe\u786e\u5bf9\u6bd4\u7b97\u6cd5\u6548\u7387\u7684\u4f18\u52a3\u3002
    • \u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4f7f\u7528\u5927 \\(O\\) \u7b26\u53f7\u8868\u793a\uff0c\u5373\u51fd\u6570\u6e10\u8fd1\u4e0a\u754c\uff0c\u53cd\u6620\u5f53 \\(n\\) \u8d8b\u5411\u6b63\u65e0\u7a77\u65f6\uff0c\\(T(n)\\) \u7684\u589e\u957f\u7ea7\u522b\u3002
    • \u63a8\u7b97\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u4e3a\u4e24\u6b65\uff0c\u9996\u5148\u7edf\u8ba1\u8ba1\u7b97\u64cd\u4f5c\u6570\u91cf\uff0c\u7136\u540e\u5224\u65ad\u6e10\u8fd1\u4e0a\u754c\u3002
    • \u5e38\u89c1\u65f6\u95f4\u590d\u6742\u5ea6\u4ece\u5c0f\u5230\u5927\u6392\u5217\u6709 \\(O(1)\\) , \\(O(\\log n)\\) , \\(O(n)\\) , \\(O(n \\log n)\\) , \\(O(n^2)\\) , \\(O(2^n)\\) , \\(O(n!)\\) \u7b49\u3002
    • \u67d0\u4e9b\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u975e\u56fa\u5b9a\uff0c\u800c\u662f\u4e0e\u8f93\u5165\u6570\u636e\u7684\u5206\u5e03\u6709\u5173\u3002\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u4e3a\u6700\u5dee\u3001\u6700\u4f73\u3001\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u51e0\u4e4e\u4e0d\u7528\uff0c\u56e0\u4e3a\u8f93\u5165\u6570\u636e\u4e00\u822c\u9700\u8981\u6ee1\u8db3\u4e25\u683c\u6761\u4ef6\u624d\u80fd\u8fbe\u5230\u6700\u4f73\u60c5\u51b5\u3002
    • \u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u53cd\u6620\u7b97\u6cd5\u5728\u968f\u673a\u6570\u636e\u8f93\u5165\u4e0b\u7684\u8fd0\u884c\u6548\u7387\uff0c\u6700\u63a5\u8fd1\u5b9e\u9645\u5e94\u7528\u4e2d\u7684\u7b97\u6cd5\u6027\u80fd\u3002\u8ba1\u7b97\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u9700\u8981\u7edf\u8ba1\u8f93\u5165\u6570\u636e\u5206\u5e03\u4ee5\u53ca\u7efc\u5408\u540e\u7684\u6570\u5b66\u671f\u671b\u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6

    • \u7c7b\u4f3c\u4e8e\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u7528\u4e8e\u8861\u91cf\u7b97\u6cd5\u5360\u7528\u7a7a\u95f4\u968f\u6570\u636e\u91cf\u589e\u957f\u7684\u8d8b\u52bf\u3002
    • \u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u76f8\u5173\u5185\u5b58\u7a7a\u95f4\u53ef\u5206\u4e3a\u8f93\u5165\u7a7a\u95f4\u3001\u6682\u5b58\u7a7a\u95f4\u3001\u8f93\u51fa\u7a7a\u95f4\u3002\u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\u8f93\u5165\u7a7a\u95f4\u4e0d\u8ba1\u5165\u7a7a\u95f4\u590d\u6742\u5ea6\u8ba1\u7b97\u3002\u6682\u5b58\u7a7a\u95f4\u53ef\u5206\u4e3a\u6307\u4ee4\u7a7a\u95f4\u3001\u6570\u636e\u7a7a\u95f4\u3001\u6808\u5e27\u7a7a\u95f4\uff0c\u5176\u4e2d\u6808\u5e27\u7a7a\u95f4\u901a\u5e38\u4ec5\u5728\u9012\u5f52\u51fd\u6570\u4e2d\u5f71\u54cd\u7a7a\u95f4\u590d\u6742\u5ea6\u3002
    • \u6211\u4eec\u901a\u5e38\u53ea\u5173\u6ce8\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\uff0c\u5373\u7edf\u8ba1\u7b97\u6cd5\u5728\u6700\u5dee\u8f93\u5165\u6570\u636e\u548c\u6700\u5dee\u8fd0\u884c\u65f6\u95f4\u70b9\u4e0b\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u3002
    • \u5e38\u89c1\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece\u5c0f\u5230\u5927\u6392\u5217\u6709 \\(O(1)\\) , \\(O(\\log n)\\) , \\(O(n)\\) , \\(O(n^2)\\) , \\(O(2^n)\\) \u7b49\u3002
    "},{"location":"chapter_computational_complexity/summary/#241-q-a","title":"2.4.1. \u00a0 Q & A","text":"

    \u5c3e\u9012\u5f52\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u662f \\(O(1)\\) \u5417\uff1f

    \u7406\u8bba\u4e0a\uff0c\u5c3e\u9012\u5f52\u51fd\u6570\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u88ab\u4f18\u5316\u81f3 \\(O(1)\\) \u3002\u4e0d\u8fc7\u7edd\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\uff08\u4f8b\u5982 Java, Python, C++, Go, C# \u7b49\uff09 \u90fd\u4e0d\u652f\u6301\u81ea\u52a8\u4f18\u5316\u5c3e\u9012\u5f52\uff0c\u56e0\u6b64\u4e00\u822c\u6765\u8bf4\u7a7a\u95f4\u590d\u6742\u5ea6\u662f \\(O(n)\\) \u3002

    \u51fd\u6570\u548c\u65b9\u6cd5\u8fd9\u4e24\u4e2a\u672f\u8bed\u7684\u533a\u522b\u662f\u4ec0\u4e48\uff1f

    \u51fd\u6570\uff08function\uff09\u53ef\u4ee5\u72ec\u7acb\u88ab\u6267\u884c\uff0c\u6240\u6709\u53c2\u6570\u90fd\u4ee5\u663e\u5f0f\u4f20\u9012\u3002 \u65b9\u6cd5\uff08method\uff09\u4e0e\u4e00\u4e2a\u5bf9\u8c61\u5173\u8054\uff0c\u65b9\u6cd5\u88ab\u9690\u5f0f\u4f20\u9012\u7ed9\u8c03\u7528\u5b83\u7684\u5bf9\u8c61\uff0c\u65b9\u6cd5\u80fd\u591f\u5bf9\u7c7b\u7684\u5b9e\u4f8b\u4e2d\u5305\u542b\u7684\u6570\u636e\u8fdb\u884c\u64cd\u4f5c\u3002

    \u56e0\u6b64\uff0cC \u548c Go \u53ea\u6709\u51fd\u6570\uff0cJava \u548c C# \u53ea\u6709\u65b9\u6cd5\uff0c\u5728 C++, Python \u4e2d\u53d6\u51b3\u4e8e\u5b83\u662f\u5426\u5c5e\u4e8e\u4e00\u4e2a\u7c7b\u3002

    \u56fe\u7247\u201c\u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u5e38\u89c1\u7c7b\u578b\u201d\u53cd\u6620\u7684\u662f\u5426\u662f\u5360\u7528\u7a7a\u95f4\u7684\u7edd\u5bf9\u5927\u5c0f\uff1f

    \u4e0d\u662f\uff0c\u8be5\u56fe\u7247\u5c55\u793a\u7684\u662f\u7a7a\u95f4\u590d\u6742\u5ea6\uff08\u5373\u589e\u957f\u8d8b\u52bf\uff09\uff0c\u800c\u4e0d\u662f\u5360\u7528\u7a7a\u95f4\u7684\u7edd\u5bf9\u5927\u5c0f\u3002\u6bcf\u4e2a\u66f2\u7ebf\u90fd\u5305\u542b\u4e00\u4e2a\u5e38\u6570\u9879\uff0c\u7528\u6765\u628a\u6240\u6709\u66f2\u7ebf\u7684\u53d6\u503c\u8303\u56f4\u538b\u7f29\u5230\u4e00\u4e2a\u89c6\u89c9\u8212\u9002\u7684\u8303\u56f4\u5185\u3002 \u5b9e\u9645\u4e2d\uff0c\u56e0\u4e3a\u6211\u4eec\u901a\u5e38\u4e0d\u77e5\u9053\u6bcf\u4e2a\u65b9\u6cd5\u7684\u201c\u5e38\u6570\u9879\u201d\u590d\u6742\u5ea6\u662f\u591a\u5c11\uff0c\u6240\u4ee5\u4e00\u822c\u65e0\u6cd5\u4ec5\u51ed\u590d\u6742\u5ea6\u6765\u9009\u62e9 \\(n = 8\\) \u4e4b\u4e0b\u7684\u6700\u4f18\u89e3\u6cd5\uff1b\u4f46\u76f8\u5bf9\u5730 \\(n = 8^5\\) \u5c31\u5f88\u597d\u9009\u4e86\uff0c\u8fd9\u662f\u590d\u6742\u5ea6\u5360\u4e3b\u5bfc\u7684\u60c5\u51b5\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/","title":"2.2. \u00a0 \u65f6\u95f4\u590d\u6742\u5ea6","text":""},{"location":"chapter_computational_complexity/time_complexity/#221","title":"2.2.1. \u00a0 \u7edf\u8ba1\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4","text":"

    \u8fd0\u884c\u65f6\u95f4\u53ef\u4ee5\u76f4\u89c2\u4e14\u51c6\u786e\u5730\u53cd\u6620\u7b97\u6cd5\u7684\u6548\u7387\u3002\u7136\u800c\uff0c\u5982\u679c\u6211\u4eec\u60f3\u8981\u51c6\u786e\u9884\u4f30\u4e00\u6bb5\u4ee3\u7801\u7684\u8fd0\u884c\u65f6\u95f4\uff0c\u5e94\u8be5\u5982\u4f55\u64cd\u4f5c\u5462\uff1f

    1. \u786e\u5b9a\u8fd0\u884c\u5e73\u53f0\uff0c\u5305\u62ec\u786c\u4ef6\u914d\u7f6e\u3001\u7f16\u7a0b\u8bed\u8a00\u3001\u7cfb\u7edf\u73af\u5883\u7b49\uff0c\u8fd9\u4e9b\u56e0\u7d20\u90fd\u4f1a\u5f71\u54cd\u4ee3\u7801\u7684\u8fd0\u884c\u6548\u7387\u3002
    2. \u8bc4\u4f30\u5404\u79cd\u8ba1\u7b97\u64cd\u4f5c\u6240\u9700\u7684\u8fd0\u884c\u65f6\u95f4\uff0c\u4f8b\u5982\u52a0\u6cd5\u64cd\u4f5c + \u9700\u8981 1 ns\uff0c\u4e58\u6cd5\u64cd\u4f5c * \u9700\u8981 10 ns\uff0c\u6253\u5370\u64cd\u4f5c\u9700\u8981 5 ns \u7b49\u3002
    3. \u7edf\u8ba1\u4ee3\u7801\u4e2d\u6240\u6709\u7684\u8ba1\u7b97\u64cd\u4f5c\uff0c\u5e76\u5c06\u6240\u6709\u64cd\u4f5c\u7684\u6267\u884c\u65f6\u95f4\u6c42\u548c\uff0c\u4ece\u800c\u5f97\u5230\u8fd0\u884c\u65f6\u95f4\u3002

    \u4f8b\u5982\u4ee5\u4e0b\u4ee3\u7801\uff0c\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u6839\u636e\u4ee5\u4e0a\u65b9\u6cd5\uff0c\u53ef\u4ee5\u5f97\u5230\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u4e3a \\(6n + 12\\) ns \u3002

    \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\] JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\nint a = 2;  // 1 ns\na = a + 1;  // 1 ns\na = a * 2;  // 10 ns\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nSystem.out.println(0);     // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\nint a = 2;  // 1 ns\na = a + 1;  // 1 ns\na = a * 2;  // 10 ns\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\ncout << 0 << endl;         // 5 ns\n}\n}\n
    # \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\ndef algorithm(n: int) -> None:\na = 2      # 1 ns\na = a + 1  # 1 ns\na = a * 2  # 10 ns\n# \u5faa\u73af n \u6b21\nfor _ in range(n):  # 1 ns\nprint(0)        # 5 ns\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunc algorithm(n int) {\na := 2      // 1 ns\na = a + 1   // 1 ns\na = a * 2   // 10 ns\n// \u5faa\u73af n \u6b21\nfor i := 0; i < n; i++ {    // 1 ns\nfmt.Println(a)          // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunction algorithm(n) {\nvar a = 2; // 1 ns\na = a + 1; // 1 ns\na = a * 2; // 10 ns\n// \u5faa\u73af n \u6b21\nfor(let i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nconsole.log(0); // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunction algorithm(n: number): void {\nvar a: number = 2; // 1 ns\na = a + 1; // 1 ns\na = a * 2; // 10 ns\n// \u5faa\u73af n \u6b21\nfor(let i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nconsole.log(0); // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\nint a = 2;  // 1 ns\na = a + 1;  // 1 ns\na = a * 2;  // 10 ns\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) {   // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nprintf(\"%d\", 0);            // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n)\n{\nint a = 2;  // 1 ns\na = a + 1;  // 1 ns\na = a * 2;  // 10 ns\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++)\n{  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nConsole.WriteLine(0);     // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunc algorithm(n: Int) {\nvar a = 2 // 1 ns\na = a + 1 // 1 ns\na = a * 2 // 10 ns\n// \u5faa\u73af n \u6b21\nfor _ in 0 ..< n { // 1 ns\nprint(0) // 5 ns\n}\n}\n
    \n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\nint a = 2; // 1 ns\na = a + 1; // 1 ns\na = a * 2; // 10 ns\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nprint(0); // 5 ns\n}\n}\n

    \u7136\u800c\u5b9e\u9645\u4e0a\uff0c\u7edf\u8ba1\u7b97\u6cd5\u7684\u8fd0\u884c\u65f6\u95f4\u65e2\u4e0d\u5408\u7406\u4e5f\u4e0d\u73b0\u5b9e\u3002\u9996\u5148\uff0c\u6211\u4eec\u4e0d\u5e0c\u671b\u9884\u4f30\u65f6\u95f4\u548c\u8fd0\u884c\u5e73\u53f0\u7ed1\u5b9a\uff0c\u56e0\u4e3a\u7b97\u6cd5\u9700\u8981\u5728\u5404\u79cd\u4e0d\u540c\u7684\u5e73\u53f0\u4e0a\u8fd0\u884c\u3002\u5176\u6b21\uff0c\u6211\u4eec\u5f88\u96be\u83b7\u77e5\u6bcf\u79cd\u64cd\u4f5c\u7684\u8fd0\u884c\u65f6\u95f4\uff0c\u8fd9\u7ed9\u9884\u4f30\u8fc7\u7a0b\u5e26\u6765\u4e86\u6781\u5927\u7684\u96be\u5ea6\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#222","title":"2.2.2. \u00a0 \u7edf\u8ba1\u65f6\u95f4\u589e\u957f\u8d8b\u52bf","text":"

    \u300c\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\u300d\u91c7\u53d6\u4e86\u4e00\u79cd\u4e0d\u540c\u7684\u65b9\u6cd5\uff0c\u5176\u7edf\u8ba1\u7684\u4e0d\u662f\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\uff0c\u800c\u662f\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u968f\u7740\u6570\u636e\u91cf\u53d8\u5927\u65f6\u7684\u589e\u957f\u8d8b\u52bf\u3002

    \u201c\u65f6\u95f4\u589e\u957f\u8d8b\u52bf\u201d\u8fd9\u4e2a\u6982\u5ff5\u8f83\u4e3a\u62bd\u8c61\uff0c\u6211\u4eec\u901a\u8fc7\u4e00\u4e2a\u4f8b\u5b50\u6765\u52a0\u4ee5\u7406\u89e3\u3002\u5047\u8bbe\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u7ed9\u5b9a\u4e09\u4e2a\u7b97\u6cd5 A , B , C \u3002

    • \u7b97\u6cd5 A \u53ea\u6709 \\(1\\) \u4e2a\u6253\u5370\u64cd\u4f5c\uff0c\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u4e0d\u968f\u7740 \\(n\\) \u589e\u5927\u800c\u589e\u957f\u3002\u6211\u4eec\u79f0\u6b64\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a\u300c\u5e38\u6570\u9636\u300d\u3002
    • \u7b97\u6cd5 B \u4e2d\u7684\u6253\u5370\u64cd\u4f5c\u9700\u8981\u5faa\u73af \\(n\\) \u6b21\uff0c\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u968f\u7740 \\(n\\) \u589e\u5927\u5448\u7ebf\u6027\u589e\u957f\u3002\u6b64\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u88ab\u79f0\u4e3a\u300c\u7ebf\u6027\u9636\u300d\u3002
    • \u7b97\u6cd5 C \u4e2d\u7684\u6253\u5370\u64cd\u4f5c\u9700\u8981\u5faa\u73af \\(1000000\\) \u6b21\uff0c\u4f46\u8fd0\u884c\u65f6\u95f4\u4ecd\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u65e0\u5173\u3002\u56e0\u6b64 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u548c A \u76f8\u540c\uff0c\u4ecd\u4e3a\u300c\u5e38\u6570\u9636\u300d\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\nSystem.out.println(0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\nfor (int i = 0; i < n; i++) {\nSystem.out.println(0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\nfor (int i = 0; i < 1000000; i++) {\nSystem.out.println(0);\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\ncout << 0 << endl;\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\nfor (int i = 0; i < n; i++) {\ncout << 0 << endl;\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\nfor (int i = 0; i < 1000000; i++) {\ncout << 0 << endl;\n}\n}\n
    # \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\ndef algorithm_A(n: int) -> None:\nprint(0)\n# \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\ndef algorithm_B(n: int) -> None:\nfor _ in range(n):\nprint(0)\n# \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\ndef algorithm_C(n: int) -> None:\nfor _ in range(1000000):\nprint(0)\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithm_A(n int) {\nfmt.Println(0)\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunc algorithm_B(n int) {\nfor i := 0; i < n; i++ {\nfmt.Println(0)\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithm_C(n int) {\nfor i := 0; i < 1000000; i++ {\nfmt.Println(0)\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_A(n) {\nconsole.log(0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunction algorithm_B(n) {\nfor (let i = 0; i < n; i++) {\nconsole.log(0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_C(n) {\nfor (let i = 0; i < 1000000; i++) {\nconsole.log(0);\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_A(n: number): void {\nconsole.log(0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunction algorithm_B(n: number): void {\nfor (let i = 0; i < n; i++) {\nconsole.log(0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_C(n: number): void {\nfor (let i = 0; i < 1000000; i++) {\nconsole.log(0);\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\nprintf(\"%d\", 0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\nfor (int i = 0; i < n; i++) {\nprintf(\"%d\", 0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\nfor (int i = 0; i < 1000000; i++) {\nprintf(\"%d\", 0);\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n)\n{\nConsole.WriteLine(0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n)\n{\nfor (int i = 0; i < n; i++)\n{\nConsole.WriteLine(0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n)\n{\nfor (int i = 0; i < 1000000; i++)\n{\nConsole.WriteLine(0);\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithmA(n: Int) {\nprint(0)\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunc algorithmB(n: Int) {\nfor _ in 0 ..< n {\nprint(0)\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithmC(n: Int) {\nfor _ in 0 ..< 1000000 {\nprint(0)\n}\n}\n
    \n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithmA(int n) {\nprint(0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithmB(int n) {\nfor (int i = 0; i < n; i++) {\nprint(0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithmC(int n) {\nfor (int i = 0; i < 1000000; i++) {\nprint(0);\n}\n}\n

    Fig. \u7b97\u6cd5 A, B, C \u7684\u65f6\u95f4\u589e\u957f\u8d8b\u52bf

    \u76f8\u8f83\u4e8e\u76f4\u63a5\u7edf\u8ba1\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\u6709\u54ea\u4e9b\u4f18\u52bf\u548c\u5c40\u9650\u6027\u5462\uff1f

    \u65f6\u95f4\u590d\u6742\u5ea6\u80fd\u591f\u6709\u6548\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\u3002\u4f8b\u5982\uff0c\u7b97\u6cd5 B \u7684\u8fd0\u884c\u65f6\u95f4\u5448\u7ebf\u6027\u589e\u957f\uff0c\u5728 \\(n > 1\\) \u65f6\u6bd4\u7b97\u6cd5 A \u6162\uff0c\u5728 \\(n > 1000000\\) \u65f6\u6bd4\u7b97\u6cd5 C \u6162\u3002\u4e8b\u5b9e\u4e0a\uff0c\u53ea\u8981\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u8db3\u591f\u5927\uff0c\u590d\u6742\u5ea6\u4e3a\u300c\u5e38\u6570\u9636\u300d\u7684\u7b97\u6cd5\u4e00\u5b9a\u4f18\u4e8e\u300c\u7ebf\u6027\u9636\u300d\u7684\u7b97\u6cd5\uff0c\u8fd9\u6b63\u662f\u65f6\u95f4\u589e\u957f\u8d8b\u52bf\u6240\u8868\u8fbe\u7684\u542b\u4e49\u3002

    \u65f6\u95f4\u590d\u6742\u5ea6\u7684\u63a8\u7b97\u65b9\u6cd5\u66f4\u7b80\u4fbf\u3002\u663e\u7136\uff0c\u8fd0\u884c\u5e73\u53f0\u548c\u8ba1\u7b97\u64cd\u4f5c\u7c7b\u578b\u90fd\u4e0e\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u7684\u589e\u957f\u8d8b\u52bf\u65e0\u5173\u3002\u56e0\u6b64\u5728\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u7b80\u5355\u5730\u5c06\u6240\u6709\u8ba1\u7b97\u64cd\u4f5c\u7684\u6267\u884c\u65f6\u95f4\u89c6\u4e3a\u76f8\u540c\u7684\u201c\u5355\u4f4d\u65f6\u95f4\u201d\uff0c\u4ece\u800c\u5c06\u201c\u8ba1\u7b97\u64cd\u4f5c\u7684\u8fd0\u884c\u65f6\u95f4\u7684\u7edf\u8ba1\u201d\u7b80\u5316\u4e3a\u201c\u8ba1\u7b97\u64cd\u4f5c\u7684\u6570\u91cf\u7684\u7edf\u8ba1\u201d\uff0c\u8fd9\u6837\u7684\u7b80\u5316\u65b9\u6cd5\u5927\u5927\u964d\u4f4e\u4e86\u4f30\u7b97\u96be\u5ea6\u3002

    \u65f6\u95f4\u590d\u6742\u5ea6\u4e5f\u5b58\u5728\u4e00\u5b9a\u7684\u5c40\u9650\u6027\u3002\u4f8b\u5982\uff0c\u5c3d\u7ba1\u7b97\u6cd5 A \u548c C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u76f8\u540c\uff0c\u4f46\u5b9e\u9645\u8fd0\u884c\u65f6\u95f4\u5dee\u522b\u5f88\u5927\u3002\u540c\u6837\uff0c\u5c3d\u7ba1\u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u6bd4 C \u9ad8\uff0c\u4f46\u5728\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u8f83\u5c0f\u65f6\uff0c\u7b97\u6cd5 B \u660e\u663e\u4f18\u4e8e\u7b97\u6cd5 C \u3002\u5728\u8fd9\u4e9b\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u5f88\u96be\u4ec5\u51ed\u65f6\u95f4\u590d\u6742\u5ea6\u5224\u65ad\u7b97\u6cd5\u6548\u7387\u9ad8\u4f4e\u3002\u5f53\u7136\uff0c\u5c3d\u7ba1\u5b58\u5728\u4e0a\u8ff0\u95ee\u9898\uff0c\u590d\u6742\u5ea6\u5206\u6790\u4ecd\u7136\u662f\u8bc4\u5224\u7b97\u6cd5\u6548\u7387\u6700\u6709\u6548\u4e14\u5e38\u7528\u7684\u65b9\u6cd5\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#223","title":"2.2.3. \u00a0 \u51fd\u6570\u6e10\u8fd1\u4e0a\u754c","text":"

    \u8bbe\u7b97\u6cd5\u7684\u8ba1\u7b97\u64cd\u4f5c\u6570\u91cf\u662f\u4e00\u4e2a\u5173\u4e8e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u7684\u51fd\u6570\uff0c\u8bb0\u4e3a \\(T(n)\\) \uff0c\u5219\u4ee5\u4e0b\u7b97\u6cd5\u7684\u64cd\u4f5c\u6570\u91cf\u4e3a

    \\[ T(n) = 3 + 2n \\] JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    void algorithm(int n) {\nint a = 1;  // +1\na = a + 1;  // +1\na = a * 2;  // +1\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\nSystem.out.println(0);    // +1\n}\n}\n
    void algorithm(int n) {\nint a = 1;  // +1\na = a + 1;  // +1\na = a * 2;  // +1\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\ncout << 0 << endl;    // +1\n}\n}\n
    def algorithm(n: int) -> None:\na = 1      # +1\na = a + 1  # +1\na = a * 2  # +1\n# \u5faa\u73af n \u6b21\nfor i in range(n):  # +1\nprint(0)        # +1\n
    func algorithm(n int) {\na := 1      // +1\na = a + 1   // +1\na = a * 2   // +1\n// \u5faa\u73af n \u6b21\nfor i := 0; i < n; i++ {   // +1\nfmt.Println(a)         // +1\n}\n}\n
    function algorithm(n) {\nvar a = 1; // +1\na += 1; // +1\na *= 2; // +1\n// \u5faa\u73af n \u6b21\nfor(let i = 0; i < n; i++){ // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\nconsole.log(0); // +1\n}\n}\n
    function algorithm(n: number): void{\nvar a: number = 1; // +1\na += 1; // +1\na *= 2; // +1\n// \u5faa\u73af n \u6b21\nfor(let i = 0; i < n; i++){ // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\nconsole.log(0); // +1\n}\n}\n
    void algorithm(int n) {\nint a = 1;  // +1\na = a + 1;  // +1\na = a * 2;  // +1\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) {   // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\nprintf(\"%d\", 0);            // +1\n}\n}  
    void algorithm(int n)\n{\nint a = 1;  // +1\na = a + 1;  // +1\na = a * 2;  // +1\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n{\nConsole.WriteLine(0);   // +1\n}\n}\n
    func algorithm(n: Int) {\nvar a = 1 // +1\na = a + 1 // +1\na = a * 2 // +1\n// \u5faa\u73af n \u6b21\nfor _ in 0 ..< n { // +1\nprint(0) // +1\n}\n}\n
    \n
    void algorithm(int n) {\nint a = 1; // +1\na = a + 1; // +1\na = a * 2; // +1\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\nprint(0); // +1\n}\n}\n

    \\(T(n)\\) \u662f\u4e00\u6b21\u51fd\u6570\uff0c\u8bf4\u660e\u65f6\u95f4\u589e\u957f\u8d8b\u52bf\u662f\u7ebf\u6027\u7684\uff0c\u56e0\u6b64\u53ef\u4ee5\u5f97\u51fa\u65f6\u95f4\u590d\u6742\u5ea6\u662f\u7ebf\u6027\u9636\u3002

    \u6211\u4eec\u5c06\u7ebf\u6027\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u8bb0\u4e3a \\(O(n)\\) \uff0c\u8fd9\u4e2a\u6570\u5b66\u7b26\u53f7\u79f0\u4e3a\u300c\u5927 \\(O\\) \u8bb0\u53f7 Big-\\(O\\) Notation\u300d\uff0c\u8868\u793a\u51fd\u6570 \\(T(n)\\) \u7684\u300c\u6e10\u8fd1\u4e0a\u754c Asymptotic Upper Bound\u300d\u3002

    \u63a8\u7b97\u65f6\u95f4\u590d\u6742\u5ea6\u672c\u8d28\u4e0a\u662f\u8ba1\u7b97\u201c\u64cd\u4f5c\u6570\u91cf\u51fd\u6570 \\(T(n)\\)\u201d\u7684\u6e10\u8fd1\u4e0a\u754c\u3002\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u6765\u770b\u51fd\u6570\u6e10\u8fd1\u4e0a\u754c\u7684\u6570\u5b66\u5b9a\u4e49\u3002

    \u51fd\u6570\u6e10\u8fd1\u4e0a\u754c

    \u82e5\u5b58\u5728\u6b63\u5b9e\u6570 \\(c\\) \u548c\u5b9e\u6570 \\(n_0\\) \uff0c\u4f7f\u5f97\u5bf9\u4e8e\u6240\u6709\u7684 \\(n > n_0\\) \uff0c\u5747\u6709 $$ T(n) \\leq c \\cdot f(n) $$ \u5219\u53ef\u8ba4\u4e3a \\(f(n)\\) \u7ed9\u51fa\u4e86 \\(T(n)\\) \u7684\u4e00\u4e2a\u6e10\u8fd1\u4e0a\u754c\uff0c\u8bb0\u4e3a $$ T(n) = O(f(n)) $$

    Fig. \u51fd\u6570\u7684\u6e10\u8fd1\u4e0a\u754c

    \u4ece\u672c\u8d28\u4e0a\u8bb2\uff0c\u8ba1\u7b97\u6e10\u8fd1\u4e0a\u754c\u5c31\u662f\u5bfb\u627e\u4e00\u4e2a\u51fd\u6570 \\(f(n)\\) \uff0c\u4f7f\u5f97\u5f53 \\(n\\) \u8d8b\u5411\u4e8e\u65e0\u7a77\u5927\u65f6\uff0c\\(T(n)\\) \u548c \\(f(n)\\) \u5904\u4e8e\u76f8\u540c\u7684\u589e\u957f\u7ea7\u522b\uff0c\u4ec5\u76f8\u5dee\u4e00\u4e2a\u5e38\u6570\u9879 \\(c\\) \u7684\u500d\u6570\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#224","title":"2.2.4. \u00a0 \u63a8\u7b97\u65b9\u6cd5","text":"

    \u6e10\u8fd1\u4e0a\u754c\u7684\u6570\u5b66\u5473\u513f\u6709\u70b9\u91cd\uff0c\u5982\u679c\u4f60\u611f\u89c9\u6ca1\u6709\u5b8c\u5168\u7406\u89e3\uff0c\u4e5f\u65e0\u9700\u62c5\u5fc3\u3002\u56e0\u4e3a\u5728\u5b9e\u9645\u4f7f\u7528\u4e2d\uff0c\u6211\u4eec\u53ea\u9700\u8981\u638c\u63e1\u63a8\u7b97\u65b9\u6cd5\uff0c\u6570\u5b66\u610f\u4e49\u53ef\u4ee5\u9010\u6e10\u9886\u609f\u3002

    \u6839\u636e\u5b9a\u4e49\uff0c\u786e\u5b9a \\(f(n)\\) \u4e4b\u540e\uff0c\u6211\u4eec\u4fbf\u53ef\u5f97\u5230\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(f(n))\\) \u3002\u90a3\u4e48\u5982\u4f55\u786e\u5b9a\u6e10\u8fd1\u4e0a\u754c \\(f(n)\\) \u5462\uff1f\u603b\u4f53\u5206\u4e3a\u4e24\u6b65\uff1a\u9996\u5148\u7edf\u8ba1\u64cd\u4f5c\u6570\u91cf\uff0c\u7136\u540e\u5224\u65ad\u6e10\u8fd1\u4e0a\u754c\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#_1","title":"\u7b2c\u4e00\u6b65\uff1a\u7edf\u8ba1\u64cd\u4f5c\u6570\u91cf","text":"

    \u9488\u5bf9\u4ee3\u7801\uff0c\u9010\u884c\u4ece\u4e0a\u5230\u4e0b\u8ba1\u7b97\u5373\u53ef\u3002\u7136\u800c\uff0c\u7531\u4e8e\u4e0a\u8ff0 \\(c \\cdot f(n)\\) \u4e2d\u7684\u5e38\u6570\u9879 \\(c\\) \u53ef\u4ee5\u53d6\u4efb\u610f\u5927\u5c0f\uff0c\u56e0\u6b64\u64cd\u4f5c\u6570\u91cf \\(T(n)\\) \u4e2d\u7684\u5404\u79cd\u7cfb\u6570\u3001\u5e38\u6570\u9879\u90fd\u53ef\u4ee5\u88ab\u5ffd\u7565\u3002\u6839\u636e\u6b64\u539f\u5219\uff0c\u53ef\u4ee5\u603b\u7ed3\u51fa\u4ee5\u4e0b\u8ba1\u6570\u7b80\u5316\u6280\u5de7\uff1a

    1. \u5ffd\u7565\u4e0e \\(n\\) \u65e0\u5173\u7684\u64cd\u4f5c\u3002\u56e0\u4e3a\u5b83\u4eec\u90fd\u662f \\(T(n)\\) \u4e2d\u7684\u5e38\u6570\u9879\uff0c\u5bf9\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u4ea7\u751f\u5f71\u54cd\u3002
    2. \u7701\u7565\u6240\u6709\u7cfb\u6570\u3002\u4f8b\u5982\uff0c\u5faa\u73af \\(2n\\) \u6b21\u3001\\(5n + 1\\) \u6b21\u7b49\uff0c\u90fd\u53ef\u4ee5\u7b80\u5316\u8bb0\u4e3a \\(n\\) \u6b21\uff0c\u56e0\u4e3a \\(n\\) \u524d\u9762\u7684\u7cfb\u6570\u5bf9\u65f6\u95f4\u590d\u6742\u5ea6\u6ca1\u6709\u5f71\u54cd\u3002
    3. \u5faa\u73af\u5d4c\u5957\u65f6\u4f7f\u7528\u4e58\u6cd5\u3002\u603b\u64cd\u4f5c\u6570\u91cf\u7b49\u4e8e\u5916\u5c42\u5faa\u73af\u548c\u5185\u5c42\u5faa\u73af\u64cd\u4f5c\u6570\u91cf\u4e4b\u79ef\uff0c\u6bcf\u4e00\u5c42\u5faa\u73af\u4f9d\u7136\u53ef\u4ee5\u5206\u522b\u5957\u7528\u4e0a\u8ff0 1. \u548c 2. \u6280\u5de7\u3002

    \u4ee5\u4e0b\u793a\u4f8b\u5c55\u793a\u4e86\u4f7f\u7528\u4e0a\u8ff0\u6280\u5de7\u524d\u3001\u540e\u7684\u7edf\u8ba1\u7ed3\u679c\u3002

    \\[ \\begin{aligned} T(n) & = 2n(n + 1) + (5n + 1) + 2 & \\text{\u5b8c\u6574\u7edf\u8ba1 (-.-|||)} \\newline & = 2n^2 + 7n + 3 \\newline T(n) & = n^2 + n & \\text{\u5077\u61d2\u7edf\u8ba1 (o.O)} \\end{aligned} \\]

    \u6700\u7ec8\uff0c\u4e24\u8005\u90fd\u80fd\u63a8\u51fa\u76f8\u540c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u7ed3\u679c\uff0c\u5373 \\(O(n^2)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    void algorithm(int n) {\nint a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (int i = 0; i < 5 * n + 1; i++) {\nSystem.out.println(0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (int i = 0; i < 2 * n; i++) {\nfor (int j = 0; j < n + 1; j++) {\nSystem.out.println(0);\n}\n}\n}\n
    void algorithm(int n) {\nint a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (int i = 0; i < 5 * n + 1; i++) {\ncout << 0 << endl;\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (int i = 0; i < 2 * n; i++) {\nfor (int j = 0; j < n + 1; j++) {\ncout << 0 << endl;\n}\n}\n}\n
    def algorithm(n: int) -> None:\na = 1      # +0\uff08\u6280\u5de7 1\uff09\na = a + n  # +0\uff08\u6280\u5de7 1\uff09\n# +n\uff08\u6280\u5de7 2\uff09\nfor i in range(5 * n + 1):\nprint(0)\n# +n*n\uff08\u6280\u5de7 3\uff09\nfor i in range(2 * n):\nfor j in range(n + 1):\nprint(0)\n
    func algorithm(n int) {\na := 1     // +0\uff08\u6280\u5de7 1\uff09\na = a + n  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor i := 0; i < 5 * n + 1; i++ {\nfmt.Println(0)\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor i := 0; i < 2 * n; i++ {\nfor j := 0; j < n + 1; j++ {\nfmt.Println(0)\n}\n}\n}\n
    function algorithm(n) {\nlet a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (let i = 0; i < 5 * n + 1; i++) {\nconsole.log(0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (let i = 0; i < 2 * n; i++) {\nfor (let j = 0; j < n + 1; j++) {\nconsole.log(0);\n}\n}\n}\n
    function algorithm(n: number): void {\nlet a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (let i = 0; i < 5 * n + 1; i++) {\nconsole.log(0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (let i = 0; i < 2 * n; i++) {\nfor (let j = 0; j < n + 1; j++) {\nconsole.log(0);\n}\n}\n}\n
    void algorithm(int n) {\nint a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (int i = 0; i < 5 * n + 1; i++) {\nprintf(\"%d\", 0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (int i = 0; i < 2 * n; i++) {\nfor (int j = 0; j < n + 1; j++) {\nprintf(\"%d\", 0);\n}\n}\n}\n
    void algorithm(int n)\n{\nint a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (int i = 0; i < 5 * n + 1; i++)\n{\nConsole.WriteLine(0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (int i = 0; i < 2 * n; i++)\n{\nfor (int j = 0; j < n + 1; j++)\n{\nConsole.WriteLine(0);\n}\n}\n}\n
    func algorithm(n: Int) {\nvar a = 1 // +0\uff08\u6280\u5de7 1\uff09\na = a + n // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor _ in 0 ..< (5 * n + 1) {\nprint(0)\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor _ in 0 ..< (2 * n) {\nfor _ in 0 ..< (n + 1) {\nprint(0)\n}\n}\n}\n
    \n
    void algorithm(int n) {\nint a = 1; // +0\uff08\u6280\u5de7 1\uff09\na = a + n; // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (int i = 0; i < 5 * n + 1; i++) {\nprint(0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (int i = 0; i < 2 * n; i++) {\nfor (int j = 0; j < n + 1; j++) {\nprint(0);\n}\n}\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#_2","title":"\u7b2c\u4e8c\u6b65\uff1a\u5224\u65ad\u6e10\u8fd1\u4e0a\u754c","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\u7531\u591a\u9879\u5f0f \\(T(n)\\) \u4e2d\u6700\u9ad8\u9636\u7684\u9879\u6765\u51b3\u5b9a\u3002\u8fd9\u662f\u56e0\u4e3a\u5728 \\(n\\) \u8d8b\u4e8e\u65e0\u7a77\u5927\u65f6\uff0c\u6700\u9ad8\u9636\u7684\u9879\u5c06\u53d1\u6325\u4e3b\u5bfc\u4f5c\u7528\uff0c\u5176\u4ed6\u9879\u7684\u5f71\u54cd\u90fd\u53ef\u4ee5\u88ab\u5ffd\u7565\u3002

    \u4ee5\u4e0b\u8868\u683c\u5c55\u793a\u4e86\u4e00\u4e9b\u4f8b\u5b50\uff0c\u5176\u4e2d\u4e00\u4e9b\u5938\u5f20\u7684\u503c\u662f\u4e3a\u4e86\u5f3a\u8c03\u201c\u7cfb\u6570\u65e0\u6cd5\u64bc\u52a8\u9636\u6570\u201d\u8fd9\u4e00\u7ed3\u8bba\u3002\u5f53 \\(n\\) \u8d8b\u4e8e\u65e0\u7a77\u5927\u65f6\uff0c\u8fd9\u4e9b\u5e38\u6570\u53d8\u5f97\u65e0\u8db3\u8f7b\u91cd\u3002

    \u64cd\u4f5c\u6570\u91cf \\(T(n)\\) \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(f(n))\\) \\(100000\\) \\(O(1)\\) \\(3n + 2\\) \\(O(n)\\) \\(2n^2 + 3n + 2\\) \\(O(n^2)\\) \\(n^3 + 10000n^2\\) \\(O(n^3)\\) \\(2^n + 10000n^{10000}\\) \\(O(2^n)\\)"},{"location":"chapter_computational_complexity/time_complexity/#225","title":"2.2.5. \u00a0 \u5e38\u89c1\u7c7b\u578b","text":"

    \u8bbe\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u5e38\u89c1\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u7c7b\u578b\u5305\u62ec\uff08\u6309\u7167\u4ece\u4f4e\u5230\u9ad8\u7684\u987a\u5e8f\u6392\u5217\uff09\uff1a

    \\[ \\begin{aligned} O(1) < O(\\log n) < O(n) < O(n \\log n) < O(n^2) < O(2^n) < O(n!) \\newline \\text{\u5e38\u6570\u9636} < \\text{\u5bf9\u6570\u9636} < \\text{\u7ebf\u6027\u9636} < \\text{\u7ebf\u6027\u5bf9\u6570\u9636} < \\text{\u5e73\u65b9\u9636} < \\text{\u6307\u6570\u9636} < \\text{\u9636\u4e58\u9636} \\end{aligned} \\]

    Fig. \u65f6\u95f4\u590d\u6742\u5ea6\u7684\u5e38\u89c1\u7c7b\u578b

    Tip

    \u90e8\u5206\u793a\u4f8b\u4ee3\u7801\u9700\u8981\u4e00\u4e9b\u9884\u5907\u77e5\u8bc6\uff0c\u5305\u62ec\u6570\u7ec4\u3001\u9012\u5f52\u7b97\u6cd5\u7b49\u3002\u5982\u679c\u9047\u5230\u4e0d\u7406\u89e3\u7684\u90e8\u5206\uff0c\u8bf7\u4e0d\u8981\u62c5\u5fc3\uff0c\u53ef\u4ee5\u5728\u5b66\u4e60\u5b8c\u540e\u9762\u7ae0\u8282\u540e\u518d\u56de\u987e\u3002\u73b0\u9636\u6bb5\uff0c\u8bf7\u5148\u4e13\u6ce8\u4e8e\u7406\u89e3\u65f6\u95f4\u590d\u6742\u5ea6\u7684\u542b\u4e49\u548c\u63a8\u7b97\u65b9\u6cd5\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#o1","title":"\u5e38\u6570\u9636 \\(O(1)\\)","text":"

    \u5e38\u6570\u9636\u7684\u64cd\u4f5c\u6570\u91cf\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u65e0\u5173\uff0c\u5373\u4e0d\u968f\u7740 \\(n\\) \u7684\u53d8\u5316\u800c\u53d8\u5316\u3002

    \u5bf9\u4e8e\u4ee5\u4e0b\u7b97\u6cd5\uff0c\u5c3d\u7ba1\u64cd\u4f5c\u6570\u91cf size \u53ef\u80fd\u5f88\u5927\uff0c\u4f46\u7531\u4e8e\u5176\u4e0e\u6570\u636e\u5927\u5c0f \\(n\\) \u65e0\u5173\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(1)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\nint count = 0;\nint size = 100000;\nfor (int i = 0; i < size; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.cpp
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\nint count = 0;\nint size = 100000;\nfor (int i = 0; i < size; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.py
    def constant(n: int) -> int:\n\"\"\"\u5e38\u6570\u9636\"\"\"\ncount = 0\nsize = 100000\nfor _ in range(size):\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u5e38\u6570\u9636 */\nfunc constant(n int) int {\ncount := 0\nsize := 100000\nfor i := 0; i < size; i++ {\ncount++\n}\nreturn count\n}\n
    time_complexity.js
    /* \u5e38\u6570\u9636 */\nfunction constant(n) {\nlet count = 0;\nconst size = 100000;\nfor (let i = 0; i < size; i++) count++;\nreturn count;\n}\n
    time_complexity.ts
    /* \u5e38\u6570\u9636 */\nfunction constant(n: number): number {\nlet count = 0;\nconst size = 100000;\nfor (let i = 0; i < size; i++) count++;\nreturn count;\n}\n
    time_complexity.c
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\nint count = 0;\nint size = 100000;\nint i = 0;\nfor (int i = 0; i < size; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\nint count = 0;\nint size = 100000;\nfor (int i = 0; i < size; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.swift
    /* \u5e38\u6570\u9636 */\nfunc constant(n: Int) -> Int {\nvar count = 0\nlet size = 100_000\nfor _ in 0 ..< size {\ncount += 1\n}\nreturn count\n}\n
    time_complexity.zig
    // \u5e38\u6570\u9636\nfn constant(n: i32) i32 {\n_ = n;\nvar count: i32 = 0;\nconst size: i32 = 100_000;\nvar i: i32 = 0;\nwhile(i<size) : (i += 1) {\ncount += 1;\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\nint count = 0;\nint size = 100000;\nfor (var i = 0; i < size; i++) {\ncount++;\n}\nreturn count;\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#on","title":"\u7ebf\u6027\u9636 \\(O(n)\\)","text":"

    \u7ebf\u6027\u9636\u7684\u64cd\u4f5c\u6570\u91cf\u76f8\u5bf9\u4e8e\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4ee5\u7ebf\u6027\u7ea7\u522b\u589e\u957f\u3002\u7ebf\u6027\u9636\u901a\u5e38\u51fa\u73b0\u5728\u5355\u5c42\u5faa\u73af\u4e2d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\nint count = 0;\nfor (int i = 0; i < n; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\nint count = 0;\nfor (int i = 0; i < n; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.py
    def linear(n: int) -> int:\n\"\"\"\u7ebf\u6027\u9636\"\"\"\ncount = 0\nfor _ in range(n):\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u7ebf\u6027\u9636 */\nfunc linear(n int) int {\ncount := 0\nfor i := 0; i < n; i++ {\ncount++\n}\nreturn count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636 */\nfunction linear(n) {\nlet count = 0;\nfor (let i = 0; i < n; i++) count++;\nreturn count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636 */\nfunction linear(n: number): number {\nlet count = 0;\nfor (let i = 0; i < n; i++) count++;\nreturn count;\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\nint count = 0;\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\nint count = 0;\nfor (int i = 0; i < n; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636 */\nfunc linear(n: Int) -> Int {\nvar count = 0\nfor _ in 0 ..< n {\ncount += 1\n}\nreturn count\n}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\nfn linear(n: i32) i32 {\nvar count: i32 = 0;\nvar i: i32 = 0;\nwhile (i < n) : (i += 1) {\ncount += 1;\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\nint count = 0;\nfor (var i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n

    \u904d\u5386\u6570\u7ec4\u548c\u904d\u5386\u94fe\u8868\u7b49\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(n)\\) \uff0c\u5176\u4e2d \\(n\\) \u4e3a\u6570\u7ec4\u6216\u94fe\u8868\u7684\u957f\u5ea6\u3002

    \u5982\u4f55\u786e\u5b9a\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \uff1f

    \u6570\u636e\u5927\u5c0f \\(n\\) \u9700\u6839\u636e\u8f93\u5165\u6570\u636e\u7684\u7c7b\u578b\u6765\u5177\u4f53\u786e\u5b9a\u3002\u4f8b\u5982\uff0c\u5728\u4e0a\u8ff0\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u76f4\u63a5\u5c06 \\(n\\) \u89c6\u4e3a\u8f93\u5165\u6570\u636e\u5927\u5c0f\uff1b\u5728\u4e0b\u9762\u904d\u5386\u6570\u7ec4\u7684\u793a\u4f8b\u4e2d\uff0c\u6570\u636e\u5927\u5c0f \\(n\\) \u4e3a\u6570\u7ec4\u7684\u957f\u5ea6\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int[] nums) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (int num : nums) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(vector<int> &nums) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (int num : nums) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.py
    def array_traversal(nums: list[int]) -> int:\n\"\"\"\u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\"\"\"\ncount = 0\n# \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor num in nums:\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums []int) int {\ncount := 0\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor range nums {\ncount++\n}\nreturn count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums) {\nlet count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (let i = 0; i < nums.length; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums: number[]): number {\nlet count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (let i = 0; i < nums.length; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int *nums, int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int[] nums) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nforeach (int num in nums) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums: [Int]) -> Int {\nvar count = 0\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor _ in nums {\ncount += 1\n}\nreturn count\n}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\nfn arrayTraversal(nums: []i32) i32 {\nvar count: i32 = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (nums) |_| {\ncount += 1;\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(List<int> nums) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (var num in nums) {\ncount++;\n}\nreturn count;\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#on2","title":"\u5e73\u65b9\u9636 \\(O(n^2)\\)","text":"

    \u5e73\u65b9\u9636\u7684\u64cd\u4f5c\u6570\u91cf\u76f8\u5bf9\u4e8e\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4ee5\u5e73\u65b9\u7ea7\u522b\u589e\u957f\u3002\u5e73\u65b9\u9636\u901a\u5e38\u51fa\u73b0\u5728\u5d4c\u5957\u5faa\u73af\u4e2d\uff0c\u5916\u5c42\u5faa\u73af\u548c\u5185\u5c42\u5faa\u73af\u90fd\u4e3a \\(O(n)\\) \uff0c\u56e0\u6b64\u603b\u4f53\u4e3a \\(O(n^2)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.py
    def quadratic(n: int) -> int:\n\"\"\"\u5e73\u65b9\u9636\"\"\"\ncount = 0\n# \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor i in range(n):\nfor j in range(n):\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n int) int {\ncount := 0\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor i := 0; i < n; i++ {\nfor j := 0; j < n; j++ {\ncount++\n}\n}\nreturn count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\nlet count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (let i = 0; i < n; i++) {\nfor (let j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n: number): number {\nlet count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (let i = 0; i < n; i++) {\nfor (let j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n: Int) -> Int {\nvar count = 0\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor _ in 0 ..< n {\nfor _ in 0 ..< n {\ncount += 1\n}\n}\nreturn count\n}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) i32 {\nvar count: i32 = 0;\nvar i: i32 = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nwhile (i < n) : (i += 1) {\nvar j: i32 = 0;\nwhile (j < n) : (j += 1) {\ncount += 1;\n}\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n

    Fig. \u5e38\u6570\u9636\u3001\u7ebf\u6027\u9636\u3001\u5e73\u65b9\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \u4ee5\u300c\u5192\u6ce1\u6392\u5e8f\u300d\u4e3a\u4f8b\uff0c\u5916\u5c42\u5faa\u73af\u6267\u884c \\(n - 1\\) \u6b21\uff0c\u5185\u5c42\u5faa\u73af\u6267\u884c \\(n-1, n-2, \\cdots, 2, 1\\) \u6b21\uff0c\u5e73\u5747\u4e3a \\(\\frac{n}{2}\\) \u6b21\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    \\[ O((n - 1) \\frac{n}{2}) = O(n^2) \\] JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int[] nums) {\nint count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(vector<int> &nums) {\nint count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.size() - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.py
    def bubble_sort(nums: list[int]) -> int:\n\"\"\"\u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\"\"\"\ncount = 0  # \u8ba1\u6570\u5668\n# \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in range(len(nums) - 1, 0, -1):\n# \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor j in range(i):\nif nums[j] > nums[j + 1]:\n# \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\ntmp: int = nums[j]\nnums[j] = nums[j + 1]\nnums[j + 1] = tmp\ncount += 3  # \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\nreturn count\n
    time_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums []int) int {\ncount := 0 // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i := len(nums) - 1; i > 0; i-- {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef\nfor j := 0; j < i; j++ {\nif nums[j] > nums[j+1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\ntmp := nums[j]\nnums[j] = nums[j+1]\nnums[j+1] = tmp\ncount += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums) {\nlet count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums: number[]): number {\nlet count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int *nums, int n) {\nint count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = n - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int[] nums) {\nint count = 0;  // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.Length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums: inout [Int]) -> Int {\nvar count = 0 // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in stride(from: nums.count - 1, to: 0, by: -1) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor j in 0 ..< i {\nif nums[j] > nums[j + 1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j]\nnums[j] = nums[j + 1]\nnums[j + 1] = tmp\ncount += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count\n}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\nfn bubbleSort(nums: []i32) i32 {\nvar count: i32 = 0;  // \u8ba1\u6570\u5668 \n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nvar i: i32 = @as(i32, @intCast(nums.len)) - 1;\nwhile (i > 0) : (i -= 1) {\nvar j: usize = 0;\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nwhile (j < i) : (j += 1) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nvar tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(List<int> nums) {\nint count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (var i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef\nfor (var j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#o2n","title":"\u6307\u6570\u9636 \\(O(2^n)\\)","text":"

    Note

    \u751f\u7269\u5b66\u7684\u201c\u7ec6\u80de\u5206\u88c2\u201d\u662f\u6307\u6570\u9636\u589e\u957f\u7684\u5178\u578b\u4f8b\u5b50\uff1a\u521d\u59cb\u72b6\u6001\u4e3a \\(1\\) \u4e2a\u7ec6\u80de\uff0c\u5206\u88c2\u4e00\u8f6e\u540e\u53d8\u4e3a \\(2\\) \u4e2a\uff0c\u5206\u88c2\u4e24\u8f6e\u540e\u53d8\u4e3a \\(4\\) \u4e2a\uff0c\u4ee5\u6b64\u7c7b\u63a8\uff0c\u5206\u88c2 \\(n\\) \u8f6e\u540e\u6709 \\(2^n\\) \u4e2a\u7ec6\u80de\u3002

    \u6307\u6570\u9636\u589e\u957f\u975e\u5e38\u8fc5\u901f\uff0c\u5728\u5b9e\u9645\u5e94\u7528\u4e2d\u901a\u5e38\u662f\u4e0d\u53ef\u63a5\u53d7\u7684\u3002\u82e5\u4e00\u4e2a\u95ee\u9898\u4f7f\u7528\u300c\u66b4\u529b\u679a\u4e3e\u300d\u6c42\u89e3\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \uff0c\u90a3\u4e48\u901a\u5e38\u9700\u8981\u4f7f\u7528\u300c\u52a8\u6001\u89c4\u5212\u300d\u6216\u300c\u8d2a\u5fc3\u7b97\u6cd5\u300d\u7b49\u65b9\u6cd5\u6765\u89e3\u51b3\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\nint count = 0, base = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < base; j++) {\ncount++;\n}\nbase *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\nint count = 0, base = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < base; j++) {\ncount++;\n}\nbase *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.py
    def exponential(n: int) -> int:\n\"\"\"\u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\ncount = 0\nbase = 1\n# cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor _ in range(n):\nfor _ in range(base):\ncount += 1\nbase *= 2\n# count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc exponential(n int) int {\ncount, base := 0, 1\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor i := 0; i < n; i++ {\nfor j := 0; j < base; j++ {\ncount++\n}\nbase *= 2\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n) {\nlet count = 0,\nbase = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (let i = 0; i < n; i++) {\nfor (let j = 0; j < base; j++) {\ncount++;\n}\nbase *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n: number): number {\nlet count = 0,\nbase = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (let i = 0; i < n; i++) {\nfor (let j = 0; j < base; j++) {\ncount++;\n}\nbase *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\nint count = 0;\nint bas = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < bas; j++) {\ncount++;\n}\nbas *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\nint count = 0, bas = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < bas; j++) {\ncount++;\n}\nbas *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc exponential(n: Int) -> Int {\nvar count = 0\nvar base = 1\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor _ in 0 ..< n {\nfor _ in 0 ..< base {\ncount += 1\n}\nbase *= 2\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count\n}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn exponential(n: i32) i32 {\nvar count: i32 = 0;\nvar bas: i32 = 1;\nvar i: i32 = 0;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nwhile (i < n) : (i += 1) {\nvar j: i32 = 0;\nwhile (j < bas) : (j += 1) {\ncount += 1;\n}\nbas *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\nint count = 0, base = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (var i = 0; i < n; i++) {\nfor (var j = 0; j < base; j++) {\ncount++;\n}\nbase *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n

    Fig. \u6307\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \u5728\u5b9e\u9645\u7b97\u6cd5\u4e2d\uff0c\u6307\u6570\u9636\u5e38\u51fa\u73b0\u4e8e\u9012\u5f52\u51fd\u6570\u3002\u4f8b\u5982\u4ee5\u4e0b\u4ee3\u7801\uff0c\u4e0d\u65ad\u5730\u4e00\u5206\u4e3a\u4e8c\uff0c\u7ecf\u8fc7 \\(n\\) \u6b21\u5206\u88c2\u540e\u505c\u6b62\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\nif (n == 1)\nreturn 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\nif (n == 1)\nreturn 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.py
    def exp_recur(n: int) -> int:\n\"\"\"\u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\nif n == 1:\nreturn 1\nreturn exp_recur(n - 1) + exp_recur(n - 1) + 1\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc expRecur(n int) int {\nif n == 1 {\nreturn 1\n}\nreturn expRecur(n-1) + expRecur(n-1) + 1\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction expRecur(n) {\nif (n == 1) return 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.ts
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction expRecur(n: number): number {\nif (n == 1) return 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\nif (n == 1)\nreturn 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.cs
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\nif (n == 1) return 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.swift
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc expRecur(n: Int) -> Int {\nif n == 1 {\nreturn 1\n}\nreturn expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn expRecur(n: i32) i32 {\nif (n == 1) return 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.dart
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\nif (n == 1) return 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#olog-n","title":"\u5bf9\u6570\u9636 \\(O(\\log n)\\)","text":"

    \u4e0e\u6307\u6570\u9636\u76f8\u53cd\uff0c\u5bf9\u6570\u9636\u53cd\u6620\u4e86\u201c\u6bcf\u8f6e\u7f29\u51cf\u5230\u4e00\u534a\u7684\u60c5\u51b5\u201d\u3002\u5bf9\u6570\u9636\u4ec5\u6b21\u4e8e\u5e38\u6570\u9636\uff0c\u65f6\u95f4\u589e\u957f\u7f13\u6162\uff0c\u662f\u7406\u60f3\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u3002

    \u5bf9\u6570\u9636\u5e38\u51fa\u73b0\u4e8e\u300c\u4e8c\u5206\u67e5\u627e\u300d\u548c\u300c\u5206\u6cbb\u7b97\u6cd5\u300d\u4e2d\uff0c\u4f53\u73b0\u4e86\u201c\u4e00\u5206\u4e3a\u591a\u201d\u548c\u201c\u5316\u7e41\u4e3a\u7b80\u201d\u7684\u7b97\u6cd5\u601d\u60f3\u3002

    \u8bbe\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u7531\u4e8e\u6bcf\u8f6e\u7f29\u51cf\u5230\u4e00\u534a\uff0c\u56e0\u6b64\u5faa\u73af\u6b21\u6570\u662f \\(\\log_2 n\\) \uff0c\u5373 \\(2^n\\) \u7684\u53cd\u51fd\u6570\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(float n) {\nint count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(float n) {\nint count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.py
    def logarithmic(n: float) -> int:\n\"\"\"\u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\ncount = 0\nwhile n > 1:\nn = n / 2\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc logarithmic(n float64) int {\ncount := 0\nfor n > 1 {\nn = n / 2\ncount++\n}\nreturn count\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n) {\nlet count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n: number): number {\nlet count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(float n) {\nint count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(float n) {\nint count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc logarithmic(n: Double) -> Int {\nvar count = 0\nvar n = n\nwhile n > 1 {\nn = n / 2\ncount += 1\n}\nreturn count\n}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn logarithmic(n: f32) i32 {\nvar count: i32 = 0;\nvar n_var = n;\nwhile (n_var > 1)\n{\nn_var = n_var / 2;\ncount +=1;\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(num n) {\nint count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n

    Fig. \u5bf9\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \u4e0e\u6307\u6570\u9636\u7c7b\u4f3c\uff0c\u5bf9\u6570\u9636\u4e5f\u5e38\u51fa\u73b0\u4e8e\u9012\u5f52\u51fd\u6570\u3002\u4ee5\u4e0b\u4ee3\u7801\u5f62\u6210\u4e86\u4e00\u4e2a\u9ad8\u5ea6\u4e3a \\(\\log_2 n\\) \u7684\u9012\u5f52\u6811\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(float n) {\nif (n <= 1)\nreturn 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(float n) {\nif (n <= 1)\nreturn 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.py
    def log_recur(n: float) -> int:\n\"\"\"\u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\nif n <= 1:\nreturn 0\nreturn log_recur(n / 2) + 1\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc logRecur(n float64) int {\nif n <= 1 {\nreturn 0\n}\nreturn logRecur(n/2) + 1\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n) {\nif (n <= 1) return 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n: number): number {\nif (n <= 1) return 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(float n) {\nif (n <= 1)\nreturn 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(float n) {\nif (n <= 1) return 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc logRecur(n: Double) -> Int {\nif n <= 1 {\nreturn 0\n}\nreturn logRecur(n: n / 2) + 1\n}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn logRecur(n: f32) i32 {\nif (n <= 1) return 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(num n) {\nif (n <= 1) return 0;\nreturn logRecur(n / 2) + 1;\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#on-log-n","title":"\u7ebf\u6027\u5bf9\u6570\u9636 \\(O(n \\log n)\\)","text":"

    \u7ebf\u6027\u5bf9\u6570\u9636\u5e38\u51fa\u73b0\u4e8e\u5d4c\u5957\u5faa\u73af\u4e2d\uff0c\u4e24\u5c42\u5faa\u73af\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u522b\u4e3a \\(O(\\log n)\\) \u548c \\(O(n)\\) \u3002

    \u4e3b\u6d41\u6392\u5e8f\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u901a\u5e38\u4e3a \\(O(n \\log n)\\) \uff0c\u4f8b\u5982\u5feb\u901f\u6392\u5e8f\u3001\u5f52\u5e76\u6392\u5e8f\u3001\u5806\u6392\u5e8f\u7b49\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(float n) {\nif (n <= 1)\nreturn 1;\nint count = linearLogRecur(n / 2) +\nlinearLogRecur(n / 2);\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(float n) {\nif (n <= 1)\nreturn 1;\nint count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.py
    def linear_log_recur(n: float) -> int:\n\"\"\"\u7ebf\u6027\u5bf9\u6570\u9636\"\"\"\nif n <= 1:\nreturn 1\ncount: int = linear_log_recur(n // 2) + linear_log_recur(n // 2)\nfor _ in range(n):\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n float64) int {\nif n <= 1 {\nreturn 1\n}\ncount := linearLogRecur(n/2) +\nlinearLogRecur(n/2)\nfor i := 0.0; i < n; i++ {\ncount++\n}\nreturn count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n) {\nif (n <= 1) return 1;\nlet count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\nfor (let i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n: number): number {\nif (n <= 1) return 1;\nlet count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\nfor (let i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(float n) {\nif (n <= 1)\nreturn 1;\nint count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(float n) {\nif (n <= 1) return 1;\nint count = linearLogRecur(n / 2) +\nlinearLogRecur(n / 2);\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n: Double) -> Int {\nif n <= 1 {\nreturn 1\n}\nvar count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\nfor _ in stride(from: 0, to: n, by: 1) {\ncount += 1\n}\nreturn count\n}\n
    time_complexity.zig
    // \u7ebf\u6027\u5bf9\u6570\u9636\nfn linearLogRecur(n: f32) i32 {\nif (n <= 1) return 1;\nvar count: i32 = linearLogRecur(n / 2) +\nlinearLogRecur(n / 2);\nvar i: f32 = 0;\nwhile (i < n) : (i += 1) {\ncount += 1;\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(num n) {\nif (n <= 1) return 1;\nint count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\nfor (var i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n

    Fig. \u7ebf\u6027\u5bf9\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/time_complexity/#on_1","title":"\u9636\u4e58\u9636 \\(O(n!)\\)","text":"

    \u9636\u4e58\u9636\u5bf9\u5e94\u6570\u5b66\u4e0a\u7684\u300c\u5168\u6392\u5217\u300d\u95ee\u9898\u3002\u7ed9\u5b9a \\(n\\) \u4e2a\u4e92\u4e0d\u91cd\u590d\u7684\u5143\u7d20\uff0c\u6c42\u5176\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u65b9\u6848\uff0c\u65b9\u6848\u6570\u91cf\u4e3a\uff1a

    \\[ n! = n \\times (n - 1) \\times (n - 2) \\times \\cdots \\times 2 \\times 1 \\]

    \u9636\u4e58\u901a\u5e38\u4f7f\u7528\u9012\u5f52\u5b9e\u73b0\u3002\u4f8b\u5982\u4ee5\u4e0b\u4ee3\u7801\uff0c\u7b2c\u4e00\u5c42\u5206\u88c2\u51fa \\(n\\) \u4e2a\uff0c\u7b2c\u4e8c\u5c42\u5206\u88c2\u51fa \\(n - 1\\) \u4e2a\uff0c\u4ee5\u6b64\u7c7b\u63a8\uff0c\u76f4\u81f3\u7b2c \\(n\\) \u5c42\u65f6\u7ec8\u6b62\u5206\u88c2\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\nif (n == 0)\nreturn 1;\nint count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (int i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\nif (n == 0)\nreturn 1;\nint count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (int i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.py
    def factorial_recur(n: int) -> int:\n\"\"\"\u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\nif n == 0:\nreturn 1\ncount = 0\n# \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor _ in range(n):\ncount += factorial_recur(n - 1)\nreturn count\n
    time_complexity.go
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n int) int {\nif n == 0 {\nreturn 1\n}\ncount := 0\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor i := 0; i < n; i++ {\ncount += factorialRecur(n - 1)\n}\nreturn count\n}\n
    time_complexity.js
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n) {\nif (n == 0) return 1;\nlet count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (let i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n: number): number {\nif (n == 0) return 1;\nlet count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (let i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\nif (n == 0)\nreturn 1;\nint count = 0;\nfor (int i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\nif (n == 0) return 1;\nint count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (int i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n: Int) -> Int {\nif n == 0 {\nreturn 1\n}\nvar count = 0\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor _ in 0 ..< n {\ncount += factorialRecur(n: n - 1)\n}\nreturn count\n}\n
    time_complexity.zig
    // \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn factorialRecur(n: i32) i32 {\nif (n == 0) return 1;\nvar count: i32 = 0;\nvar i: i32 = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nwhile (i < n) : (i += 1) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\nif (n == 0) return 1;\nint count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (var i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n

    Fig. \u9636\u4e58\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/time_complexity/#226","title":"2.2.6. \u00a0 \u6700\u5dee\u3001\u6700\u4f73\u3001\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6","text":"

    \u67d0\u4e9b\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u662f\u56fa\u5b9a\u7684\uff0c\u800c\u662f\u4e0e\u8f93\u5165\u6570\u636e\u7684\u5206\u5e03\u6709\u5173\u3002\u4f8b\u5982\uff0c\u5047\u8bbe\u8f93\u5165\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4 nums \uff0c\u5176\u4e2d nums \u7531\u4ece \\(1\\) \u81f3 \\(n\\) \u7684\u6570\u5b57\u7ec4\u6210\uff0c\u4f46\u5143\u7d20\u987a\u5e8f\u662f\u968f\u673a\u6253\u4e71\u7684\uff1b\u7b97\u6cd5\u7684\u4efb\u52a1\u662f\u8fd4\u56de\u5143\u7d20 \\(1\\) \u7684\u7d22\u5f15\u3002\u6211\u4eec\u53ef\u4ee5\u5f97\u51fa\u4ee5\u4e0b\u7ed3\u8bba\uff1a

    • \u5f53 nums = [?, ?, ..., 1] \uff0c\u5373\u5f53\u672b\u5c3e\u5143\u7d20\u662f \\(1\\) \u65f6\uff0c\u9700\u8981\u5b8c\u6574\u904d\u5386\u6570\u7ec4\uff0c\u6b64\u65f6\u8fbe\u5230 \u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n)\\)\uff1b
    • \u5f53 nums = [1, ?, ?, ...] \uff0c\u5373\u5f53\u9996\u4e2a\u6570\u5b57\u4e3a \\(1\\) \u65f6\uff0c\u65e0\u8bba\u6570\u7ec4\u591a\u957f\u90fd\u4e0d\u9700\u8981\u7ee7\u7eed\u904d\u5386\uff0c\u6b64\u65f6\u8fbe\u5230 \u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 \\(\\Omega(1)\\)\uff1b

    \u201c\u51fd\u6570\u6e10\u8fd1\u4e0a\u754c\u201d\u4f7f\u7528\u5927 \\(O\\) \u8bb0\u53f7\u8868\u793a\uff0c\u4ee3\u8868\u300c\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u300d\u3002\u76f8\u5e94\u5730\uff0c\u201c\u51fd\u6570\u6e10\u8fd1\u4e0b\u754c\u201d\u7528 \\(\\Omega\\) \u8bb0\u53f7\u6765\u8868\u793a\uff0c\u4ee3\u8868\u300c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u300d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart worst_best_time_complexity.java
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nint[] randomNumbers(int n) {\nInteger[] nums = new Integer[n];\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (int i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nCollections.shuffle(Arrays.asList(nums));\n// Integer[] -> int[]\nint[] res = new int[n];\nfor (int i = 0; i < n; i++) {\nres[i] = nums[i];\n}\nreturn res;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int[] nums) {\nfor (int i = 0; i < nums.length; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] == 1)\nreturn i;\n}\nreturn -1;\n}\n
    worst_best_time_complexity.cpp
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nvector<int> randomNumbers(int n) {\nvector<int> nums(n);\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (int i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u4f7f\u7528\u7cfb\u7edf\u65f6\u95f4\u751f\u6210\u968f\u673a\u79cd\u5b50\nunsigned seed = chrono::system_clock::now().time_since_epoch().count();\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nshuffle(nums.begin(), nums.end(), default_random_engine(seed));\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(vector<int> &nums) {\nfor (int i = 0; i < nums.size(); i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] == 1)\nreturn i;\n}\nreturn -1;\n}\n
    worst_best_time_complexity.py
    def random_numbers(n: int) -> list[int]:\n\"\"\"\u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a: 1, 2, ..., n \uff0c\u987a\u5e8f\u88ab\u6253\u4e71\"\"\"\n# \u751f\u6210\u6570\u7ec4 nums =: 1, 2, 3, ..., n\nnums = [i for i in range(1, n + 1)]\n# \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nrandom.shuffle(nums)\nreturn nums\ndef find_one(nums: list[int]) -> int:\n\"\"\"\u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\"\"\"\nfor i in range(len(nums)):\n# \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n# \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif nums[i] == 1:\nreturn i\nreturn -1\n
    worst_best_time_complexity.go
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfunc randomNumbers(n int) []int {\nnums := make([]int, n)\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor i := 0; i < n; i++ {\nnums[i] = i + 1\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nrand.Shuffle(len(nums), func(i, j int) {\nnums[i], nums[j] = nums[j], nums[i]\n})\nreturn nums\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums []int) int {\nfor i := 0; i < len(nums); i++ {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif nums[i] == 1 {\nreturn i\n}\n}\nreturn -1\n}\n
    worst_best_time_complexity.js
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfunction randomNumbers(n) {\nconst nums = Array(n);\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (let i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nfor (let i = 0; i < n; i++) {\nconst r = Math.floor(Math.random() * (i + 1));\nconst temp = nums[i];\nnums[i] = nums[r];\nnums[r] = temp;\n}\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums) {\nfor (let i = 0; i < nums.length; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] === 1) {\nreturn i;\n}\n}\nreturn -1;\n}\n
    worst_best_time_complexity.ts
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfunction randomNumbers(n: number): number[] {\nconst nums = Array(n);\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (let i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nfor (let i = 0; i < n; i++) {\nconst r = Math.floor(Math.random() * (i + 1));\nconst temp = nums[i];\nnums[i] = nums[r];\nnums[r] = temp;\n}\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums: number[]): number {\nfor (let i = 0; i < nums.length; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] === 1) {\nreturn i;\n}\n}\nreturn -1;\n}\n
    worst_best_time_complexity.c
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nint *randomNumbers(int n) {\n// \u5206\u914d\u5806\u533a\u5185\u5b58\uff08\u521b\u5efa\u4e00\u7ef4\u53ef\u53d8\u957f\u6570\u7ec4\uff1a\u6570\u7ec4\u4e2d\u5143\u7d20\u6570\u91cf\u4e3an\uff0c\u5143\u7d20\u7c7b\u578b\u4e3aint\uff09\nint *nums = (int *)malloc(n * sizeof(int));\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (int i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nfor (int i = n - 1; i > 0; i--) {\nint j = rand() % (i + 1);\nint temp = nums[i];\nnums[i] = nums[j];\nnums[j] = temp;\n}\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int *nums, int n) {\nfor (int i = 0; i < n; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] == 1)\nreturn i;\n}\nreturn -1;\n}\n
    worst_best_time_complexity.cs
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nint[] randomNumbers(int n) {\nint[] nums = new int[n];\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (int i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nfor (int i = 0; i < nums.Length; i++) {\nvar index = new Random().Next(i, nums.Length);\nvar tmp = nums[i];\nvar ran = nums[index];\nnums[i] = ran;\nnums[index] = tmp;\n}\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int[] nums) {\nfor (int i = 0; i < nums.Length; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] == 1)\nreturn i;\n}\nreturn -1;\n}\n
    worst_best_time_complexity.swift
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfunc randomNumbers(n: Int) -> [Int] {\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nvar nums = Array(1 ... n)\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nnums.shuffle()\nreturn nums\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums: [Int]) -> Int {\nfor i in nums.indices {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif nums[i] == 1 {\nreturn i\n}\n}\nreturn -1\n}\n
    worst_best_time_complexity.zig
    // \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71\npub fn randomNumbers(comptime n: usize) [n]i32 {\nvar nums: [n]i32 = undefined;\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (nums) |*num, i| {\nnum.* = @intCast(i32, i) + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nconst rand = std.crypto.random;\nrand.shuffle(i32, &nums);\nreturn nums;\n}\n// \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\npub fn findOne(nums: []i32) i32 {\nfor (nums) |num, i| {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (num == 1) return @intCast(i32, i);\n}\nreturn -1;\n}\n
    worst_best_time_complexity.dart
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nList<int> randomNumbers(int n) {\nfinal nums = List.filled(n, 0);\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (var i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nnums.shuffle();\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(List<int> nums) {\nfor (var i = 0; i < nums.length; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] == 1) return i;\n}\nreturn -1;\n}\n

    Tip

    \u5b9e\u9645\u5e94\u7528\u4e2d\u6211\u4eec\u5f88\u5c11\u4f7f\u7528\u300c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u300d\uff0c\u56e0\u4e3a\u901a\u5e38\u53ea\u6709\u5728\u5f88\u5c0f\u6982\u7387\u4e0b\u624d\u80fd\u8fbe\u5230\uff0c\u53ef\u80fd\u4f1a\u5e26\u6765\u4e00\u5b9a\u7684\u8bef\u5bfc\u6027\u3002\u76f8\u53cd\uff0c\u300c\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u300d\u66f4\u4e3a\u5b9e\u7528\uff0c\u56e0\u4e3a\u5b83\u7ed9\u51fa\u4e86\u4e00\u4e2a\u201c\u6548\u7387\u5b89\u5168\u503c\u201d\uff0c\u8ba9\u6211\u4eec\u53ef\u4ee5\u653e\u5fc3\u5730\u4f7f\u7528\u7b97\u6cd5\u3002

    \u4ece\u4e0a\u8ff0\u793a\u4f8b\u53ef\u4ee5\u770b\u51fa\uff0c\u6700\u5dee\u6216\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u53ea\u51fa\u73b0\u5728\u201c\u7279\u6b8a\u5206\u5e03\u7684\u6570\u636e\u201d\u4e2d\uff0c\u8fd9\u4e9b\u60c5\u51b5\u7684\u51fa\u73b0\u6982\u7387\u53ef\u80fd\u5f88\u5c0f\uff0c\u56e0\u6b64\u5e76\u4e0d\u80fd\u6700\u771f\u5b9e\u5730\u53cd\u6620\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u3002\u76f8\u8f83\u4e4b\u4e0b\uff0c\u300c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u300d\u53ef\u4ee5\u4f53\u73b0\u7b97\u6cd5\u5728\u968f\u673a\u8f93\u5165\u6570\u636e\u4e0b\u7684\u8fd0\u884c\u6548\u7387\uff0c\u7528 \\(\\Theta\\) \u8bb0\u53f7\u6765\u8868\u793a\u3002

    \u5bf9\u4e8e\u90e8\u5206\u7b97\u6cd5\uff0c\u6211\u4eec\u53ef\u4ee5\u7b80\u5355\u5730\u63a8\u7b97\u51fa\u968f\u673a\u6570\u636e\u5206\u5e03\u4e0b\u7684\u5e73\u5747\u60c5\u51b5\u3002\u6bd4\u5982\u4e0a\u8ff0\u793a\u4f8b\uff0c\u7531\u4e8e\u8f93\u5165\u6570\u7ec4\u662f\u88ab\u6253\u4e71\u7684\uff0c\u56e0\u6b64\u5143\u7d20 \\(1\\) \u51fa\u73b0\u5728\u4efb\u610f\u7d22\u5f15\u7684\u6982\u7387\u90fd\u662f\u76f8\u7b49\u7684\uff0c\u90a3\u4e48\u7b97\u6cd5\u7684\u5e73\u5747\u5faa\u73af\u6b21\u6570\u5219\u662f\u6570\u7ec4\u957f\u5ea6\u7684\u4e00\u534a \\(\\frac{n}{2}\\) \uff0c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(\\Theta(\\frac{n}{2}) = \\Theta(n)\\) \u3002

    \u4f46\u5728\u5b9e\u9645\u5e94\u7528\u4e2d\uff0c\u5c24\u5176\u662f\u8f83\u4e3a\u590d\u6742\u7684\u7b97\u6cd5\uff0c\u8ba1\u7b97\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u6bd4\u8f83\u56f0\u96be\uff0c\u56e0\u4e3a\u5f88\u96be\u7b80\u4fbf\u5730\u5206\u6790\u51fa\u5728\u6570\u636e\u5206\u5e03\u4e0b\u7684\u6574\u4f53\u6570\u5b66\u671f\u671b\u3002\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u901a\u5e38\u4f7f\u7528\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4f5c\u4e3a\u7b97\u6cd5\u6548\u7387\u7684\u8bc4\u5224\u6807\u51c6\u3002

    \u4e3a\u4ec0\u4e48\u5f88\u5c11\u770b\u5230 \\(\\Theta\\) \u7b26\u53f7\uff1f

    \u53ef\u80fd\u7531\u4e8e \\(O\\) \u7b26\u53f7\u8fc7\u4e8e\u6717\u6717\u4e0a\u53e3\uff0c\u6211\u4eec\u5e38\u5e38\u4f7f\u7528\u5b83\u6765\u8868\u793a\u300c\u5e73\u5747\u590d\u6742\u5ea6\u300d\uff0c\u4f46\u4ece\u4e25\u683c\u610f\u4e49\u4e0a\u770b\uff0c\u8fd9\u79cd\u505a\u6cd5\u5e76\u4e0d\u89c4\u8303\u3002\u5728\u672c\u4e66\u548c\u5176\u4ed6\u8d44\u6599\u4e2d\uff0c\u82e5\u9047\u5230\u7c7b\u4f3c\u201c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n)\\)\u201d\u7684\u8868\u8ff0\uff0c\u8bf7\u5c06\u5176\u76f4\u63a5\u7406\u89e3\u4e3a \\(\\Theta(n)\\) \u3002

    "},{"location":"chapter_data_structure/","title":"3. \u00a0 \u6570\u636e\u7ed3\u6784","text":""},{"location":"chapter_data_structure/basic_data_types/","title":"3.2. \u00a0 \u57fa\u672c\u6570\u636e\u7c7b\u578b","text":"

    \u8c08\u53ca\u8ba1\u7b97\u673a\u4e2d\u7684\u6570\u636e\uff0c\u6211\u4eec\u4f1a\u60f3\u5230\u6587\u672c\u3001\u56fe\u7247\u3001\u89c6\u9891\u3001\u8bed\u97f3\u30013D \u6a21\u578b\u7b49\u5404\u79cd\u5f62\u5f0f\u3002\u5c3d\u7ba1\u8fd9\u4e9b\u6570\u636e\u7684\u7ec4\u7ec7\u5f62\u5f0f\u5404\u5f02\uff0c\u4f46\u5b83\u4eec\u90fd\u7531\u5404\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6784\u6210\u3002

    \u57fa\u672c\u6570\u636e\u7c7b\u578b\u662f CPU \u53ef\u4ee5\u76f4\u63a5\u8fdb\u884c\u8fd0\u7b97\u7684\u7c7b\u578b\uff0c\u5728\u7b97\u6cd5\u4e2d\u76f4\u63a5\u88ab\u4f7f\u7528\u3002\u5b83\u5305\u62ec\uff1a

    • \u6574\u6570\u7c7b\u578b byte , short , int , long \uff1b
    • \u6d6e\u70b9\u6570\u7c7b\u578b float , double \uff0c\u7528\u4e8e\u8868\u793a\u5c0f\u6570\uff1b
    • \u5b57\u7b26\u7c7b\u578b char \uff0c\u7528\u4e8e\u8868\u793a\u5404\u79cd\u8bed\u8a00\u7684\u5b57\u6bcd\u3001\u6807\u70b9\u7b26\u53f7\u3001\u751a\u81f3\u8868\u60c5\u7b26\u53f7\u7b49\uff1b
    • \u5e03\u5c14\u7c7b\u578b bool \uff0c\u7528\u4e8e\u8868\u793a\u201c\u662f\u201d\u4e0e\u201c\u5426\u201d\u5224\u65ad\uff1b

    \u6240\u6709\u57fa\u672c\u6570\u636e\u7c7b\u578b\u90fd\u4ee5\u4e8c\u8fdb\u5236\u7684\u5f62\u5f0f\u5b58\u50a8\u5728\u8ba1\u7b97\u673a\u4e2d\u3002\u5728\u8ba1\u7b97\u673a\u4e2d\uff0c\u6211\u4eec\u5c06 \\(1\\) \u4e2a\u4e8c\u8fdb\u5236\u4f4d\u79f0\u4e3a \\(1\\) \u6bd4\u7279\uff0c\u5e76\u89c4\u5b9a \\(1\\) \u5b57\u8282\uff08byte\uff09\u7531 \\(8\\) \u6bd4\u7279\uff08bits\uff09\u7ec4\u6210\u3002\u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u53d6\u503c\u8303\u56f4\u53d6\u51b3\u4e8e\u5176\u5360\u7528\u7684\u7a7a\u95f4\u5927\u5c0f\uff0c\u4f8b\u5982\uff1a

    • \u6574\u6570\u7c7b\u578b byte \u5360\u7528 \\(1\\) byte = \\(8\\) bits \uff0c\u53ef\u4ee5\u8868\u793a \\(2^{8}\\) \u4e2a\u4e0d\u540c\u7684\u6570\u5b57\uff1b
    • \u6574\u6570\u7c7b\u578b int \u5360\u7528 \\(4\\) bytes = \\(32\\) bits \uff0c\u53ef\u4ee5\u8868\u793a \\(2^{32}\\) \u4e2a\u6570\u5b57\uff1b

    \u4e0b\u8868\u5217\u4e3e\u4e86\u5404\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u5360\u7528\u7a7a\u95f4\u3001\u53d6\u503c\u8303\u56f4\u548c\u9ed8\u8ba4\u503c\u3002\u6b64\u8868\u683c\u65e0\u9700\u786c\u80cc\uff0c\u5927\u81f4\u7406\u89e3\u5373\u53ef\uff0c\u9700\u8981\u65f6\u53ef\u4ee5\u901a\u8fc7\u67e5\u8868\u6765\u56de\u5fc6\u3002

    \u7c7b\u578b \u7b26\u53f7 \u5360\u7528\u7a7a\u95f4 \u6700\u5c0f\u503c \u6700\u5927\u503c \u9ed8\u8ba4\u503c \u6574\u6570 byte 1 byte \\(-2^7\\) (\\(-128\\)) \\(2^7 - 1\\) (\\(127\\)) \\(0\\) short 2 bytes \\(-2^{15}\\) \\(2^{15} - 1\\) \\(0\\) int 4 bytes \\(-2^{31}\\) \\(2^{31} - 1\\) \\(0\\) long 8 bytes \\(-2^{63}\\) \\(2^{63} - 1\\) \\(0\\) \u6d6e\u70b9\u6570 float 4 bytes \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0 f\\) double 8 bytes \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) \\(0.0\\) \u5b57\u7b26 char 2 bytes / 1 byte \\(0\\) \\(2^{16} - 1\\) \\(0\\) \u5e03\u5c14 bool 1 byte \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\)

    Tip

    \u5b57\u7b26\u7684\u5360\u7528\u7a7a\u95f4\u5927\u5c0f\u53d6\u51b3\u4e8e\u7f16\u7a0b\u8bed\u8a00\u91c7\u7528\u7684\u5b57\u7b26\u7f16\u7801\u65b9\u6cd5\uff0c\u8be6\u89c1\u300c\u5b57\u7b26\u7f16\u7801\u300d\u7ae0\u8282\u3002

    \u73b0\u4ee3\u8ba1\u7b97\u673a CPU \u901a\u5e38\u5c06 1 \u5b57\u8282\u4f5c\u4e3a\u6700\u5c0f\u5bfb\u5740\u5185\u5b58\u5355\u5143\u3002\u56e0\u6b64\uff0c\u5373\u4f7f\u8868\u793a\u5e03\u5c14\u91cf\u4ec5\u9700 1 \u4f4d\uff08\\(0\\) \u6216 \\(1\\)\uff09\uff0c\u5b83\u5728\u5185\u5b58\u4e2d\u901a\u5e38\u88ab\u5b58\u50a8\u4e3a 1 \u5b57\u8282\u3002

    \u90a3\u4e48\uff0c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u4e0e\u6570\u636e\u7ed3\u6784\u4e4b\u95f4\u6709\u4ec0\u4e48\u8054\u7cfb\u4e0e\u533a\u522b\u5462\uff1f\u6211\u4eec\u77e5\u9053\uff0c\u6570\u636e\u7ed3\u6784\u662f\u5728\u8ba1\u7b97\u673a\u4e2d\u7ec4\u7ec7\u4e0e\u5b58\u50a8\u6570\u636e\u7684\u65b9\u5f0f\u3002\u5b83\u7684\u4e3b\u8bed\u662f\u201c\u7ed3\u6784\u201d\uff0c\u800c\u975e\u201c\u6570\u636e\u201d\u3002\u5982\u679c\u60f3\u8981\u8868\u793a\u201c\u4e00\u6392\u6570\u5b57\u201d\uff0c\u6211\u4eec\u81ea\u7136\u4f1a\u60f3\u5230\u4f7f\u7528\u6570\u7ec4\u3002\u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u7684\u7ebf\u6027\u7ed3\u6784\u53ef\u4ee5\u8868\u793a\u6570\u5b57\u7684\u76f8\u90bb\u5173\u7cfb\u548c\u987a\u5e8f\u5173\u7cfb\uff0c\u4f46\u81f3\u4e8e\u5b58\u50a8\u7684\u5185\u5bb9\u662f\u6574\u6570 int \u3001\u5c0f\u6570 float \u3001\u8fd8\u662f\u5b57\u7b26 char \uff0c\u5219\u4e0e\u201c\u6570\u636e\u7ed3\u6784\u201d\u65e0\u5173\u3002

    \u6362\u53e5\u8bdd\u8bf4\uff0c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u63d0\u4f9b\u4e86\u6570\u636e\u7684\u201c\u5185\u5bb9\u7c7b\u578b\u201d\uff0c\u800c\u6570\u636e\u7ed3\u6784\u63d0\u4f9b\u4e86\u6570\u636e\u7684\u201c\u7ec4\u7ec7\u65b9\u5f0f\u201d\u3002\u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4e0d\u540c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u4f7f\u7528\u591a\u79cd\u300c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u300d\u6765\u521d\u59cb\u5316\u300c\u6570\u7ec4\u300d */\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] booleans = new boolean[5];\n
    /* \u4f7f\u7528\u591a\u79cd\u300c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u300d\u6765\u521d\u59cb\u5316\u300c\u6570\u7ec4\u300d */\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool booleans[5];\n
    # Python \u7684 list \u53ef\u4ee5\u81ea\u7531\u5b58\u50a8\u5404\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u548c\u5bf9\u8c61\nlist = [0, 0.0, 'a', False]\n
    // \u4f7f\u7528\u591a\u79cd\u300c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u300d\u6765\u521d\u59cb\u5316\u300c\u6570\u7ec4\u300d\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar booleans = [5]bool{}\n
    /* JavaScript \u7684\u6570\u7ec4\u53ef\u4ee5\u81ea\u7531\u5b58\u50a8\u5404\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u548c\u5bf9\u8c61 */\nconst array = [0, 0.0, 'a', false];\n
    /* \u4f7f\u7528\u591a\u79cd\u300c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u300d\u6765\u521d\u59cb\u5316\u300c\u6570\u7ec4\u300d */\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst booleans: boolean[] = [];\n
    /* \u4f7f\u7528\u591a\u79cd\u300c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u300d\u6765\u521d\u59cb\u5316\u300c\u6570\u7ec4\u300d */\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool booleans[10];\n
    /* \u4f7f\u7528\u591a\u79cd\u300c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u300d\u6765\u521d\u59cb\u5316\u300c\u6570\u7ec4\u300d */\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] booleans = new bool[5];\n
    /* \u4f7f\u7528\u591a\u79cd\u300c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u300d\u6765\u521d\u59cb\u5316\u300c\u6570\u7ec4\u300d */\nlet numbers = Array(repeating: Int(), count: 5)\nlet decimals = Array(repeating: Double(), count: 5)\nlet characters = Array(repeating: Character(\"a\"), count: 5)\nlet booleans = Array(repeating: Bool(), count: 5)\n
    \n
    /* \u4f7f\u7528\u591a\u79cd\u300c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u300d\u6765\u521d\u59cb\u5316\u300c\u6570\u7ec4\u300d */\nList<int> numbers = List.filled(5, 0);\nList<double> decimals = List.filled(5, 0.0);\nList<String> characters = List.filled(5, 'a');\nList<bool> booleans = List.filled(5, false);\n
    "},{"location":"chapter_data_structure/character_encoding/","title":"3.4. \u00a0 \u5b57\u7b26\u7f16\u7801 *","text":"

    \u5728\u8ba1\u7b97\u673a\u4e2d\uff0c\u6240\u6709\u6570\u636e\u90fd\u662f\u4ee5\u4e8c\u8fdb\u5236\u6570\u7684\u5f62\u5f0f\u5b58\u50a8\u7684\uff0c\u5b57\u7b26 char \u4e5f\u4e0d\u4f8b\u5916\u3002\u4e3a\u4e86\u8868\u793a\u5b57\u7b26\uff0c\u6211\u4eec\u9700\u8981\u5efa\u7acb\u4e00\u5957\u300c\u5b57\u7b26\u96c6\u300d\uff0c\u89c4\u5b9a\u6bcf\u4e2a\u5b57\u7b26\u548c\u4e8c\u8fdb\u5236\u6570\u4e4b\u95f4\u7684\u4e00\u4e00\u5bf9\u5e94\u5173\u7cfb\u3002\u6709\u4e86\u5b57\u7b26\u96c6\u4e4b\u540e\uff0c\u8ba1\u7b97\u673a\u5c31\u53ef\u4ee5\u901a\u8fc7\u67e5\u8868\u5b8c\u6210\u4e8c\u8fdb\u5236\u6570\u5230\u5b57\u7b26\u7684\u8f6c\u6362\u3002

    "},{"location":"chapter_data_structure/character_encoding/#341-ascii","title":"3.4.1. \u00a0 ASCII \u5b57\u7b26\u96c6","text":"

    \u300cASCII \u7801\u300d\u662f\u6700\u65e9\u51fa\u73b0\u7684\u5b57\u7b26\u96c6\uff0c\u5168\u79f0\u4e3a\u201c\u7f8e\u56fd\u6807\u51c6\u4fe1\u606f\u4ea4\u6362\u4ee3\u7801\u201d\u3002\u5b83\u4f7f\u7528 7 \u4f4d\u4e8c\u8fdb\u5236\u6570\uff08\u5373\u4e00\u4e2a\u5b57\u8282\u7684\u4f4e 7 \u4f4d\uff09\u8868\u793a\u4e00\u4e2a\u5b57\u7b26\uff0c\u6700\u591a\u80fd\u591f\u8868\u793a 128 \u4e2a\u4e0d\u540c\u7684\u5b57\u7b26\u3002\u8fd9\u5305\u62ec\u82f1\u6587\u5b57\u6bcd\u7684\u5927\u5c0f\u5199\u3001\u6570\u5b57 0-9 \u3001\u4e00\u4e9b\u6807\u70b9\u7b26\u53f7\uff0c\u4ee5\u53ca\u4e00\u4e9b\u63a7\u5236\u5b57\u7b26\uff08\u5982\u6362\u884c\u7b26\u548c\u5236\u8868\u7b26\uff09\u3002

    Fig. ASCII \u7801

    \u7136\u800c\uff0cASCII \u7801\u4ec5\u80fd\u591f\u8868\u793a\u82f1\u6587\u3002\u968f\u7740\u8ba1\u7b97\u673a\u7684\u5168\u7403\u5316\uff0c\u8bde\u751f\u4e86\u4e00\u79cd\u80fd\u591f\u8868\u793a\u66f4\u591a\u8bed\u8a00\u7684\u5b57\u7b26\u96c6\u300cEASCII\u300d\u3002\u5b83\u5728 ASCII \u7684 7 \u4f4d\u57fa\u7840\u4e0a\u6269\u5c55\u5230 8 \u4f4d\uff0c\u80fd\u591f\u8868\u793a 256 \u4e2a\u4e0d\u540c\u7684\u5b57\u7b26\u3002\u5728\u4e16\u754c\u8303\u56f4\u5185\uff0c\u9646\u7eed\u51fa\u73b0\u4e86\u4e00\u6279\u9002\u7528\u4e8e\u4e0d\u540c\u5730\u533a\u7684 EASCII \u5b57\u7b26\u96c6\u3002\u8fd9\u4e9b\u5b57\u7b26\u96c6\u7684\u524d 128 \u4e2a\u5b57\u7b26\u7edf\u4e00\u4e3a ASCII \u7801\uff0c\u540e 128 \u4e2a\u5b57\u7b26\u5b9a\u4e49\u4e0d\u540c\uff0c\u4ee5\u9002\u5e94\u4e0d\u540c\u8bed\u8a00\u7684\u9700\u6c42\u3002

    "},{"location":"chapter_data_structure/character_encoding/#342-gbk","title":"3.4.2. \u00a0 GBK \u5b57\u7b26\u96c6","text":"

    \u540e\u6765\u4eba\u4eec\u53d1\u73b0\uff0cEASCII \u7801\u4ecd\u7136\u65e0\u6cd5\u6ee1\u8db3\u8bb8\u591a\u8bed\u8a00\u7684\u5b57\u7b26\u6570\u91cf\u8981\u6c42\u3002\u4f8b\u5982\uff0c\u6c49\u5b57\u5927\u7ea6\u6709\u8fd1\u5341\u4e07\u4e2a\uff0c\u5149\u65e5\u5e38\u4f7f\u7528\u7684\u5c31\u6709\u51e0\u5343\u4e2a\u3002\u4e2d\u56fd\u56fd\u5bb6\u6807\u51c6\u603b\u5c40\u4e8e 1980 \u5e74\u53d1\u5e03\u4e86\u300cGB2312\u300d\u5b57\u7b26\u96c6\uff0c\u5176\u6536\u5f55\u4e86 6763 \u4e2a\u6c49\u5b57\uff0c\u57fa\u672c\u6ee1\u8db3\u4e86\u6c49\u5b57\u7684\u8ba1\u7b97\u673a\u5904\u7406\u9700\u8981\u3002

    \u7136\u800c\uff0cGB2312 \u65e0\u6cd5\u5904\u7406\u90e8\u5206\u7684\u7f55\u89c1\u5b57\u548c\u7e41\u4f53\u5b57\u3002\u4e4b\u540e\u5728 GB2312 \u7684\u57fa\u7840\u4e0a\uff0c\u6269\u5c55\u5f97\u5230\u4e86\u300cGBK\u300d\u5b57\u7b26\u96c6\uff0c\u5b83\u5171\u6536\u5f55\u4e86 21886 \u4e2a\u6c49\u5b57\u3002\u5728 GBK \u7f16\u7801\u65b9\u6848\u4e2d\uff0cASCII \u5b57\u7b26\u4f7f\u7528\u4e00\u4e2a\u5b57\u8282\u8868\u793a\uff0c\u6c49\u5b57\u4f7f\u7528\u4e24\u4e2a\u5b57\u8282\u8868\u793a\u3002

    "},{"location":"chapter_data_structure/character_encoding/#343-unicode","title":"3.4.3. \u00a0 Unicode \u5b57\u7b26\u96c6","text":"

    \u968f\u7740\u8ba1\u7b97\u673a\u7684\u84ec\u52c3\u53d1\u5c55\uff0c\u5b57\u7b26\u96c6\u4e0e\u7f16\u7801\u6807\u51c6\u767e\u82b1\u9f50\u653e\uff0c\u800c\u8fd9\u5e26\u6765\u4e86\u8bb8\u591a\u95ee\u9898\u3002\u4e00\u65b9\u9762\uff0c\u8fd9\u4e9b\u5b57\u7b26\u96c6\u4e00\u822c\u53ea\u5b9a\u4e49\u4e86\u7279\u5b9a\u8bed\u8a00\u7684\u5b57\u7b26\uff0c\u65e0\u6cd5\u5728\u591a\u8bed\u8a00\u73af\u5883\u4e0b\u6b63\u5e38\u5de5\u4f5c\uff1b\u53e6\u4e00\u65b9\u9762\uff0c\u540c\u4e00\u79cd\u8bed\u8a00\u4e5f\u5b58\u5728\u591a\u79cd\u5b57\u7b26\u96c6\u6807\u51c6\uff0c\u5982\u679c\u4e24\u53f0\u7535\u8111\u5b89\u88c5\u7684\u662f\u4e0d\u540c\u7684\u7f16\u7801\u6807\u51c6\uff0c\u5219\u5728\u4fe1\u606f\u4f20\u9012\u65f6\u5c31\u4f1a\u51fa\u73b0\u4e71\u7801\u3002

    \u90a3\u4e2a\u65f6\u4ee3\u7684\u4eba\u4eec\u5c31\u5728\u60f3\uff1a\u5982\u679c\u63a8\u51fa\u4e00\u4e2a\u8db3\u591f\u5b8c\u6574\u7684\u5b57\u7b26\u96c6\uff0c\u5c06\u4e16\u754c\u8303\u56f4\u5185\u7684\u6240\u6709\u8bed\u8a00\u548c\u7b26\u53f7\u90fd\u6536\u5f55\u5176\u4e2d\uff0c\u4e0d\u5c31\u53ef\u4ee5\u89e3\u51b3\u8de8\u8bed\u8a00\u73af\u5883\u548c\u4e71\u7801\u95ee\u9898\u4e86\u5417\uff1f\u5728\u8fd9\u79cd\u60f3\u6cd5\u7684\u9a71\u52a8\u4e0b\uff0c\u4e00\u4e2a\u5927\u800c\u5168\u7684\u5b57\u7b26\u96c6 Unicode \u5e94\u8fd0\u800c\u751f\u3002

    \u300cUnicode\u300d\u7684\u5168\u79f0\u4e3a\u201c\u7edf\u4e00\u5b57\u7b26\u7f16\u7801\u201d\uff0c\u7406\u8bba\u4e0a\u80fd\u5bb9\u7eb3\u4e00\u767e\u591a\u4e07\u4e2a\u5b57\u7b26\u3002\u5b83\u81f4\u529b\u4e8e\u5c06\u5168\u7403\u8303\u56f4\u5185\u7684\u5b57\u7b26\u7eb3\u5165\u5230\u7edf\u4e00\u7684\u5b57\u7b26\u96c6\u4e4b\u4e2d\uff0c\u63d0\u4f9b\u4e00\u79cd\u901a\u7528\u7684\u5b57\u7b26\u96c6\u6765\u5904\u7406\u548c\u663e\u793a\u5404\u79cd\u8bed\u8a00\u6587\u5b57\uff0c\u51cf\u5c11\u56e0\u4e3a\u7f16\u7801\u6807\u51c6\u4e0d\u540c\u800c\u4ea7\u751f\u7684\u4e71\u7801\u95ee\u9898\u3002

    \u81ea 1991 \u5e74\u53d1\u5e03\u4ee5\u6765\uff0cUnicode \u4e0d\u65ad\u6269\u5145\u65b0\u7684\u8bed\u8a00\u4e0e\u5b57\u7b26\u3002\u622a\u6b62 2022 \u5e74 9 \u6708\uff0cUnicode \u5df2\u7ecf\u5305\u542b 149186 \u4e2a\u5b57\u7b26\uff0c\u5305\u62ec\u5404\u79cd\u8bed\u8a00\u7684\u5b57\u7b26\u3001\u7b26\u53f7\u3001\u751a\u81f3\u662f\u8868\u60c5\u7b26\u53f7\u7b49\u3002\u5728\u5e9e\u5927\u7684 Unicode \u5b57\u7b26\u96c6\u4e2d\uff0c\u5e38\u7528\u7684\u5b57\u7b26\u5360\u7528 2 \u5b57\u8282\uff0c\u6709\u4e9b\u751f\u50fb\u7684\u5b57\u7b26\u5360 3 \u5b57\u8282\u751a\u81f3 4 \u5b57\u8282\u3002

    Unicode \u662f\u4e00\u79cd\u5b57\u7b26\u96c6\u6807\u51c6\uff0c\u672c\u8d28\u4e0a\u662f\u7ed9\u6bcf\u4e2a\u5b57\u7b26\u5206\u914d\u4e00\u4e2a\u7f16\u53f7\uff08\u79f0\u4e3a\u201c\u7801\u70b9\u201d\uff09\uff0c\u4f46\u5b83\u5e76\u6ca1\u6709\u89c4\u5b9a\u5728\u8ba1\u7b97\u673a\u4e2d\u5982\u4f55\u5b58\u50a8\u8fd9\u4e9b\u5b57\u7b26\u7801\u70b9\u3002\u6211\u4eec\u4e0d\u7981\u4f1a\u95ee\uff1a\u5f53\u591a\u79cd\u957f\u5ea6\u7684 Unicode \u7801\u70b9\u540c\u65f6\u51fa\u73b0\u5728\u540c\u4e00\u4e2a\u6587\u672c\u4e2d\u65f6\uff0c\u7cfb\u7edf\u5982\u4f55\u89e3\u6790\u5b57\u7b26\uff1f\u4f8b\u5982\uff0c\u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a 2 \u5b57\u8282\u7684\u7f16\u7801\uff0c\u7cfb\u7edf\u5982\u4f55\u786e\u8ba4\u5b83\u662f\u4e00\u4e2a 2 \u5b57\u8282\u7684\u5b57\u7b26\u8fd8\u662f\u4e24\u4e2a 1 \u5b57\u8282\u7684\u5b57\u7b26\uff1f

    \u5bf9\u4e8e\u4ee5\u4e0a\u95ee\u9898\uff0c\u4e00\u79cd\u76f4\u63a5\u7684\u89e3\u51b3\u65b9\u6848\u662f\u5c06\u6240\u6709\u5b57\u7b26\u5b58\u50a8\u4e3a\u7b49\u957f\u7684\u7f16\u7801\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u201cHello\u201d\u4e2d\u7684\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 1 \u5b57\u8282\uff0c\u201c\u7b97\u6cd5\u201d\u4e2d\u7684\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 2 \u5b57\u8282\u3002\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u9ad8\u4f4d\u586b 0 \uff0c\u5c06\u201cHello \u7b97\u6cd5\u201d\u4e2d\u7684\u6240\u6709\u5b57\u7b26\u90fd\u7f16\u7801\u4e3a 2 \u5b57\u8282\u957f\u5ea6\u3002\u8fd9\u6837\u7cfb\u7edf\u5c31\u53ef\u4ee5\u6bcf\u9694 2 \u5b57\u8282\u89e3\u6790\u4e00\u4e2a\u5b57\u7b26\uff0c\u6062\u590d\u51fa\u8fd9\u4e2a\u77ed\u8bed\u7684\u5185\u5bb9\u4e86\u3002

    Fig. Unicode \u7f16\u7801\u793a\u4f8b

    \u7136\u800c\uff0cASCII \u7801\u5df2\u7ecf\u5411\u6211\u4eec\u8bc1\u660e\uff0c\u7f16\u7801\u82f1\u6587\u53ea\u9700\u8981 1 \u5b57\u8282\u3002\u82e5\u91c7\u7528\u4e0a\u8ff0\u65b9\u6848\uff0c\u82f1\u6587\u6587\u672c\u5360\u7528\u7a7a\u95f4\u7684\u5927\u5c0f\u5c06\u4f1a\u662f ASCII \u7f16\u7801\u4e0b\u5927\u5c0f\u7684 2 \u500d\uff0c\u975e\u5e38\u6d6a\u8d39\u5185\u5b58\u7a7a\u95f4\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u9700\u8981\u4e00\u79cd\u66f4\u52a0\u9ad8\u6548\u7684 Unicode \u7f16\u7801\u65b9\u6cd5\u3002

    "},{"location":"chapter_data_structure/character_encoding/#344-utf-8","title":"3.4.4. \u00a0 UTF-8 \u7f16\u7801","text":"

    \u76ee\u524d\uff0cUTF-8 \u5df2\u6210\u4e3a\u56fd\u9645\u4e0a\u4f7f\u7528\u6700\u5e7f\u6cdb\u7684 Unicode \u7f16\u7801\u65b9\u6cd5\u3002\u5b83\u662f\u4e00\u79cd\u53ef\u53d8\u957f\u7684\u7f16\u7801\uff0c\u4f7f\u7528 1 \u5230 4 \u4e2a\u5b57\u8282\u6765\u8868\u793a\u4e00\u4e2a\u5b57\u7b26\uff0c\u6839\u636e\u5b57\u7b26\u7684\u590d\u6742\u6027\u800c\u53d8\u3002ASCII \u5b57\u7b26\u53ea\u9700\u8981 1 \u4e2a\u5b57\u8282\uff0c\u62c9\u4e01\u5b57\u6bcd\u548c\u5e0c\u814a\u5b57\u6bcd\u9700\u8981 2 \u4e2a\u5b57\u8282\uff0c\u5e38\u7528\u7684\u4e2d\u6587\u5b57\u7b26\u9700\u8981 3 \u4e2a\u5b57\u8282\uff0c\u5176\u4ed6\u7684\u4e00\u4e9b\u751f\u50fb\u5b57\u7b26\u9700\u8981 4 \u4e2a\u5b57\u8282\u3002

    UTF-8 \u7684\u7f16\u7801\u89c4\u5219\u5e76\u4e0d\u590d\u6742\uff0c\u5206\u4e3a\u4e24\u79cd\u60c5\u51b5\uff1a

    • \u5bf9\u4e8e\u957f\u5ea6\u4e3a 1 \u5b57\u8282\u7684\u5b57\u7b26\uff0c\u5c06\u6700\u9ad8\u4f4d\u8bbe\u7f6e\u4e3a \\(0\\) \u3001\u5176\u4f59 7 \u4f4d\u8bbe\u7f6e\u4e3a Unicode \u7801\u70b9\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0cASCII \u5b57\u7b26\u5728 Unicode \u5b57\u7b26\u96c6\u4e2d\u5360\u636e\u4e86\u524d 128 \u4e2a\u7801\u70b9\u3002\u4e5f\u5c31\u662f\u8bf4\uff0cUTF-8 \u7f16\u7801\u53ef\u4ee5\u5411\u4e0b\u517c\u5bb9 ASCII \u7801\u3002\u8fd9\u610f\u5473\u7740\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528 UTF-8 \u6765\u89e3\u6790\u5e74\u4ee3\u4e45\u8fdc\u7684 ASCII \u7801\u6587\u672c\u3002
    • \u5bf9\u4e8e\u957f\u5ea6\u4e3a \\(n\\) \u5b57\u8282\u7684\u5b57\u7b26\uff08\u5176\u4e2d \\(n > 1\\)\uff09\uff0c\u5c06\u9996\u4e2a\u5b57\u8282\u7684\u9ad8 \\(n\\) \u4f4d\u90fd\u8bbe\u7f6e\u4e3a \\(1\\) \u3001\u7b2c \\(n + 1\\) \u4f4d\u8bbe\u7f6e\u4e3a \\(0\\) \uff1b\u4ece\u7b2c\u4e8c\u4e2a\u5b57\u8282\u5f00\u59cb\uff0c\u5c06\u6bcf\u4e2a\u5b57\u8282\u7684\u9ad8 2 \u4f4d\u90fd\u8bbe\u7f6e\u4e3a \\(10\\) \uff1b\u5176\u4f59\u6240\u6709\u4f4d\u7528\u4e8e\u586b\u5145\u5b57\u7b26\u7684 Unicode \u7801\u70b9\u3002

    \u4e0b\u56fe\u5c55\u793a\u4e86\u201cHello\u7b97\u6cd5\u201d\u5bf9\u5e94\u7684 UTF-8 \u7f16\u7801\u3002\u5c06\u6700\u9ad8 \\(n\\) \u4f4d\u8bbe\u7f6e\u4e3a \\(1\\) \u6bd4\u8f83\u5bb9\u6613\u7406\u89e3\uff0c\u53ef\u4ee5\u5411\u7cfb\u7edf\u6307\u51fa\u5b57\u7b26\u7684\u957f\u5ea6\u4e3a \\(n\\) \u3002\u90a3\u4e48\uff0c\u4e3a\u4ec0\u4e48\u8981\u5c06\u5176\u4f59\u6240\u6709\u5b57\u8282\u7684\u9ad8 2 \u4f4d\u90fd\u8bbe\u7f6e\u4e3a \\(10\\) \u5462\uff1f\u5b9e\u9645\u4e0a\uff0c\u8fd9\u4e2a \\(10\\) \u80fd\u591f\u8d77\u5230\u6821\u9a8c\u7b26\u7684\u4f5c\u7528\uff0c\u56e0\u4e3a\u5728 UTF-8 \u7f16\u7801\u89c4\u5219\u4e0b\uff0c\u4e0d\u53ef\u80fd\u6709\u5b57\u7b26\u7684\u6700\u9ad8\u4e24\u4f4d\u662f \\(10\\) \u3002\u8fd9\u662f\u56e0\u4e3a\u957f\u5ea6\u4e3a 1 \u5b57\u8282\u7684\u5b57\u7b26\u7684\u6700\u9ad8\u4e00\u4f4d\u662f \\(0\\) \u3002\u5047\u8bbe\u7cfb\u7edf\u4ece\u4e00\u4e2a\u9519\u8bef\u7684\u5b57\u8282\u5f00\u59cb\u89e3\u6790\u6587\u672c\uff0c\u5b57\u8282\u5934\u90e8\u7684 \\(10\\) \u80fd\u591f\u5e2e\u52a9\u7cfb\u7edf\u5feb\u901f\u7684\u5224\u65ad\u51fa\u5f02\u5e38\u3002

    Fig. UTF-8 \u7f16\u7801\u793a\u4f8b

    \u9664\u4e86 UTF-8 \u4e4b\u5916\uff0c\u5e38\u89c1\u7684\u7f16\u7801\u65b9\u5f0f\u8fd8\u5305\u62ec UTF-16 \u548c UTF-32 \u3002\u5b83\u4eec\u4e3a Unicode \u5b57\u7b26\u96c6\u63d0\u4f9b\u4e86\u4e0d\u540c\u7684\u7f16\u7801\u65b9\u6cd5\u3002

    • UTF-16 \u7f16\u7801\uff1a\u4f7f\u7528 2 \u6216 4 \u4e2a\u5b57\u8282\u6765\u8868\u793a\u4e00\u4e2a\u5b57\u7b26\u3002\u6240\u6709\u7684 ASCII \u5b57\u7b26\u548c\u5f88\u591a\u5e38\u7528\u7684\u975e\u82f1\u6587\u5b57\u7b26\uff0c\u90fd\u7528 2 \u4e2a\u5b57\u8282\u8868\u793a\uff1b\u5c11\u6570\u5b57\u7b26\u9700\u8981\u7528\u5230 4 \u4e2a\u5b57\u8282\u8868\u793a\u3002\u5bf9\u4e8e 2 \u5b57\u8282\u7684\u5b57\u7b26\uff0cUTF-16 \u7f16\u7801\u4e0e Unicode \u7801\u70b9\u76f8\u7b49\u3002
    • UTF-32 \u7f16\u7801\uff1a\u6bcf\u4e2a\u5b57\u7b26\u90fd\u4f7f\u7528 4 \u4e2a\u5b57\u8282\u3002\u8fd9\u610f\u5473\u7740 UTF-32 \u4f1a\u6bd4 UTF-8 \u548c UTF-16 \u66f4\u5360\u7528\u7a7a\u95f4\uff0c\u7279\u522b\u662f\u5bf9\u4e8e\u4e3b\u8981\u4f7f\u7528 ASCII \u5b57\u7b26\u7684\u6587\u672c\u3002

    \u4ece\u5b58\u50a8\u7a7a\u95f4\u7684\u89d2\u5ea6\u770b\uff0c\u4f7f\u7528 UTF-8 \u8868\u793a\u82f1\u6587\u5b57\u7b26\u975e\u5e38\u9ad8\u6548\uff0c\u56e0\u4e3a\u5b83\u4ec5\u9700 1 \u4e2a\u5b57\u8282\uff1b\u4f7f\u7528 UTF-16 \u7f16\u7801\u67d0\u4e9b\u975e\u82f1\u6587\u5b57\u7b26\uff08\u4f8b\u5982\u4e2d\u6587\uff09\u4f1a\u66f4\u52a0\u9ad8\u6548\uff0c\u56e0\u4e3a\u5b83\u53ea\u9700\u8981 2 \u4e2a\u5b57\u8282\uff0c\u800c UTF-8 \u53ef\u80fd\u9700\u8981 3 \u4e2a\u5b57\u8282\u3002\u4ece\u517c\u5bb9\u6027\u7684\u89d2\u5ea6\u770b\uff0cUTF-8 \u7684\u901a\u7528\u6027\u6700\u4f73\uff0c\u8bb8\u591a\u5de5\u5177\u548c\u5e93\u90fd\u4f18\u5148\u652f\u6301 UTF-8 \u3002

    "},{"location":"chapter_data_structure/character_encoding/#345","title":"3.4.5. \u00a0 \u7f16\u7a0b\u8bed\u8a00\u7684\u5b57\u7b26\u7f16\u7801","text":"

    \u5bf9\u4e8e\u4ee5\u5f80\u7684\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\uff0c\u7a0b\u5e8f\u8fd0\u884c\u4e2d\u7684\u5b57\u7b26\u4e32\u90fd\u91c7\u7528 UTF-16 \u6216 UTF-32 \u8fd9\u7c7b\u7b49\u957f\u7684\u7f16\u7801\u3002\u8fd9\u662f\u56e0\u4e3a\u5728\u7b49\u957f\u7f16\u7801\u4e0b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5b57\u7b26\u4e32\u770b\u4f5c\u6570\u7ec4\u6765\u5904\u7406\uff0c\u5177\u4f53\u6765\u8bf4\uff1a

    • \u968f\u673a\u8bbf\u95ee: UTF-16 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u53ef\u4ee5\u5f88\u5bb9\u6613\u5730\u8fdb\u884c\u968f\u673a\u8bbf\u95ee\u3002UTF-8 \u662f\u4e00\u79cd\u53d8\u957f\u7f16\u7801\uff0c\u8981\u627e\u5230\u7b2c \\(i\\) \u4e2a\u5b57\u7b26\uff0c\u6211\u4eec\u9700\u8981\u4ece\u5b57\u7b26\u4e32\u7684\u5f00\u59cb\u5904\u904d\u5386\u5230\u7b2c \\(i\\) \u4e2a\u5b57\u7b26\uff0c\u8fd9\u9700\u8981 \\(O(n)\\) \u7684\u65f6\u95f4\u3002
    • \u5b57\u7b26\u8ba1\u6570: \u4e0e\u968f\u673a\u8bbf\u95ee\u7c7b\u4f3c\uff0c\u8ba1\u7b97 UTF-16 \u5b57\u7b26\u4e32\u7684\u957f\u5ea6\u4e5f\u662f \\(O(1)\\) \u7684\u64cd\u4f5c\u3002\u4f46\u662f\uff0c\u8ba1\u7b97 UTF-8 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u7684\u957f\u5ea6\u9700\u8981\u904d\u5386\u6574\u4e2a\u5b57\u7b26\u4e32\u3002
    • \u5b57\u7b26\u4e32\u64cd\u4f5c: \u5728 UTF-16 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u4e2d\uff0c\u5f88\u591a\u5b57\u7b26\u4e32\u64cd\u4f5c\uff08\u5982\u5206\u5272\u3001\u8fde\u63a5\u3001\u63d2\u5165\u3001\u5220\u9664\u7b49\uff09\u90fd\u66f4\u5bb9\u6613\u8fdb\u884c\u3002\u5728 UTF-8 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u4e0a\u8fdb\u884c\u8fd9\u4e9b\u64cd\u4f5c\u901a\u5e38\u9700\u8981\u989d\u5916\u7684\u8ba1\u7b97\uff0c\u4ee5\u786e\u4fdd\u4e0d\u4f1a\u4ea7\u751f\u65e0\u6548\u7684 UTF-8 \u7f16\u7801\u3002

    \u7f16\u7a0b\u8bed\u8a00\u7684\u5b57\u7b26\u7f16\u7801\u65b9\u6848\u8bbe\u8ba1\u662f\u4e00\u4e2a\u5f88\u6709\u8da3\u7684\u8bdd\u9898\uff0c\u6d89\u53ca\u5230\u8bb8\u591a\u56e0\u7d20\uff1a

    • Java \u7684 String \u7c7b\u578b\u4f7f\u7528 UTF-16 \u7f16\u7801\uff0c\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 2 \u5b57\u8282\u3002\u8fd9\u662f\u56e0\u4e3a Java \u8bed\u8a00\u8bbe\u8ba1\u4e4b\u521d\uff0c\u4eba\u4eec\u8ba4\u4e3a 16 \u4f4d\u8db3\u4ee5\u8868\u793a\u6240\u6709\u53ef\u80fd\u7684\u5b57\u7b26\u3002\u7136\u800c\uff0c\u8fd9\u662f\u4e00\u4e2a\u4e0d\u6b63\u786e\u7684\u5224\u65ad\u3002\u540e\u6765 Unicode \u89c4\u8303\u6269\u5c55\u5230\u4e86\u8d85\u8fc7 16 \u4f4d\uff0c\u6240\u4ee5 Java \u4e2d\u7684\u5b57\u7b26\u73b0\u5728\u53ef\u80fd\u7531\u4e00\u5bf9 16 \u4f4d\u7684\u503c\uff08\u79f0\u4e3a\u201c\u4ee3\u7406\u5bf9\u201d\uff09\u8868\u793a\u3002
    • JavaScript \u548c TypeScript \u7684\u5b57\u7b26\u4e32\u4f7f\u7528 UTF-16 \u7f16\u7801\u7684\u539f\u56e0\u4e0e Java \u7c7b\u4f3c\u3002\u5f53 JavaScript \u8bed\u8a00\u5728 1995 \u5e74\u88ab Netscape \u516c\u53f8\u9996\u6b21\u5f15\u5165\u65f6\uff0cUnicode \u8fd8\u5904\u4e8e\u76f8\u5bf9\u65e9\u671f\u7684\u9636\u6bb5\uff0c\u90a3\u65f6\u5019\u4f7f\u7528 16 \u4f4d\u7684\u7f16\u7801\u5c31\u8db3\u591f\u8868\u793a\u6240\u6709\u7684 Unicode \u5b57\u7b26\u4e86\u3002
    • C# \u4f7f\u7528 UTF-16 \u7f16\u7801\uff0c\u4e3b\u8981\u56e0\u4e3a .NET \u5e73\u53f0\u662f\u7531 Microsoft \u8bbe\u8ba1\u7684\uff0c\u800c Microsoft \u7684\u5f88\u591a\u6280\u672f\uff0c\u5305\u62ec Windows \u64cd\u4f5c\u7cfb\u7edf\uff0c\u90fd\u5e7f\u6cdb\u5730\u4f7f\u7528 UTF-16 \u7f16\u7801\u3002

    \u7531\u4e8e\u4ee5\u4e0a\u7f16\u7a0b\u8bed\u8a00\u5bf9\u5b57\u7b26\u6570\u91cf\u7684\u4f4e\u4f30\uff0c\u5b83\u4eec\u4e0d\u5f97\u4e0d\u91c7\u53d6\u201c\u4ee3\u7406\u5bf9\u201d\u7684\u65b9\u5f0f\u6765\u8868\u793a\u8d85\u8fc7 16 \u4f4d\u957f\u5ea6\u7684 Unicode \u5b57\u7b26\u3002\u8fd9\u662f\u4e00\u4e2a\u4e0d\u5f97\u5df2\u4e3a\u4e4b\u7684\u65e0\u5948\u4e4b\u4e3e\u3002\u4e00\u65b9\u9762\uff0c\u5305\u542b\u4ee3\u7406\u5bf9\u7684\u5b57\u7b26\u4e32\u4e2d\uff0c\u4e00\u4e2a\u5b57\u7b26\u53ef\u80fd\u5360\u7528 2 \u5b57\u8282\u6216 4 \u5b57\u8282\uff0c\u56e0\u6b64\u4e27\u5931\u4e86\u7b49\u957f\u7f16\u7801\u7684\u4f18\u52bf\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u5904\u7406\u4ee3\u7406\u5bf9\u9700\u8981\u589e\u52a0\u989d\u5916\u4ee3\u7801\uff0c\u8fd9\u589e\u52a0\u4e86\u7f16\u7a0b\u7684\u590d\u6742\u6027\u548c Debug \u96be\u5ea6\u3002

    \u51fa\u4e8e\u4ee5\u4e0a\u539f\u56e0\uff0c\u90e8\u5206\u7f16\u7a0b\u8bed\u8a00\u63d0\u51fa\u4e86\u4e0d\u540c\u7684\u7f16\u7801\u65b9\u6848\uff1a

    • Python 3 \u4f7f\u7528\u4e00\u79cd\u7075\u6d3b\u7684\u5b57\u7b26\u4e32\u8868\u793a\uff0c\u5b58\u50a8\u7684\u5b57\u7b26\u957f\u5ea6\u53d6\u51b3\u4e8e\u5b57\u7b26\u4e32\u4e2d\u6700\u5927\u7684 Unicode \u7801\u70b9\u3002\u5bf9\u4e8e\u5168\u90e8\u662f ASCII \u5b57\u7b26\u7684\u5b57\u7b26\u4e32\uff0c\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 1 \u4e2a\u5b57\u8282\uff1b\u5982\u679c\u5b57\u7b26\u4e32\u4e2d\u5305\u542b\u7684\u5b57\u7b26\u8d85\u51fa\u4e86 ASCII \u8303\u56f4\uff0c\u4f46\u5168\u90e8\u5728\u57fa\u672c\u591a\u8bed\u8a00\u5e73\u9762\uff08BMP\uff09\u5185\uff0c\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 2 \u4e2a\u5b57\u8282\uff1b\u5982\u679c\u5b57\u7b26\u4e32\u4e2d\u6709\u8d85\u51fa BMP \u7684\u5b57\u7b26\uff0c\u90a3\u4e48\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 4 \u4e2a\u5b57\u8282\u3002
    • Go \u8bed\u8a00\u7684 string \u7c7b\u578b\u5728\u5185\u90e8\u4f7f\u7528 UTF-8 \u7f16\u7801\u3002Go \u8bed\u8a00\u8fd8\u63d0\u4f9b\u4e86 rune \u7c7b\u578b\uff0c\u5b83\u7528\u4e8e\u8868\u793a\u5355\u4e2a Unicode \u7801\u70b9\u3002
    • Rust \u8bed\u8a00\u7684 str \u548c String \u7c7b\u578b\u5728\u5185\u90e8\u4f7f\u7528 UTF-8 \u7f16\u7801\u3002Rust \u4e5f\u63d0\u4f9b\u4e86 char \u7c7b\u578b\uff0c\u7528\u4e8e\u8868\u793a\u5355\u4e2a Unicode \u7801\u70b9\u3002

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u4ee5\u4e0a\u8ba8\u8bba\u7684\u90fd\u662f\u5b57\u7b26\u4e32\u5728\u7f16\u7a0b\u8bed\u8a00\u4e2d\u7684\u5b58\u50a8\u65b9\u5f0f\uff0c\u8fd9\u548c\u5b57\u7b26\u4e32\u5982\u4f55\u5728\u6587\u4ef6\u4e2d\u5b58\u50a8\u6216\u5728\u7f51\u7edc\u4e2d\u4f20\u8f93\u662f\u4e24\u4e2a\u4e0d\u540c\u7684\u95ee\u9898\u3002\u5728\u6587\u4ef6\u5b58\u50a8\u6216\u7f51\u7edc\u4f20\u8f93\u4e2d\uff0c\u6211\u4eec\u4e00\u822c\u4f1a\u5c06\u5b57\u7b26\u4e32\u7f16\u7801\u4e3a UTF-8 \u683c\u5f0f\uff0c\u4ee5\u8fbe\u5230\u6700\u4f18\u7684\u517c\u5bb9\u6027\u548c\u7a7a\u95f4\u6548\u7387\u3002

    "},{"location":"chapter_data_structure/classification_of_data_structure/","title":"3.1. \u00a0 \u6570\u636e\u7ed3\u6784\u5206\u7c7b","text":"

    \u6570\u636e\u7ed3\u6784\u53ef\u4ee5\u4ece\u903b\u8f91\u7ed3\u6784\u548c\u7269\u7406\u7ed3\u6784\u4e24\u4e2a\u7ef4\u5ea6\u8fdb\u884c\u5206\u7c7b\u3002

    "},{"location":"chapter_data_structure/classification_of_data_structure/#311","title":"3.1.1. \u00a0 \u903b\u8f91\u7ed3\u6784\uff1a\u7ebf\u6027\u4e0e\u975e\u7ebf\u6027","text":"

    \u300c\u903b\u8f91\u7ed3\u6784\u300d\u63ed\u793a\u4e86\u6570\u636e\u5143\u7d20\u4e4b\u95f4\u7684\u903b\u8f91\u5173\u7cfb\u3002\u5728\u6570\u7ec4\u548c\u94fe\u8868\u4e2d\uff0c\u6570\u636e\u6309\u7167\u987a\u5e8f\u4f9d\u6b21\u6392\u5217\uff0c\u4f53\u73b0\u4e86\u6570\u636e\u4e4b\u95f4\u7684\u7ebf\u6027\u5173\u7cfb\uff1b\u800c\u5728\u6811\u4e2d\uff0c\u6570\u636e\u4ece\u9876\u90e8\u5411\u4e0b\u6309\u5c42\u6b21\u6392\u5217\uff0c\u8868\u73b0\u51fa\u7956\u5148\u4e0e\u540e\u4ee3\u4e4b\u95f4\u7684\u6d3e\u751f\u5173\u7cfb\uff1b\u56fe\u5219\u7531\u8282\u70b9\u548c\u8fb9\u6784\u6210\uff0c\u53cd\u6620\u4e86\u590d\u6742\u7684\u7f51\u7edc\u5173\u7cfb\u3002

    \u903b\u8f91\u7ed3\u6784\u901a\u5e38\u5206\u4e3a\u300c\u7ebf\u6027\u300d\u548c\u300c\u975e\u7ebf\u6027\u300d\u4e24\u7c7b\u3002\u7ebf\u6027\u7ed3\u6784\u6bd4\u8f83\u76f4\u89c2\uff0c\u6307\u6570\u636e\u5728\u903b\u8f91\u5173\u7cfb\u4e0a\u5448\u7ebf\u6027\u6392\u5217\uff1b\u975e\u7ebf\u6027\u7ed3\u6784\u5219\u76f8\u53cd\uff0c\u5448\u975e\u7ebf\u6027\u6392\u5217\uff0c\u4f8b\u5982\u7f51\u72b6\u6216\u6811\u72b6\u7ed3\u6784\u3002

    • \u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff1a\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\uff1b
    • \u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff1a\u6811\u3001\u56fe\u3001\u5806\u3001\u54c8\u5e0c\u8868\uff1b

    Fig. \u7ebf\u6027\u4e0e\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784

    "},{"location":"chapter_data_structure/classification_of_data_structure/#312","title":"3.1.2. \u00a0 \u7269\u7406\u7ed3\u6784\uff1a\u8fde\u7eed\u4e0e\u79bb\u6563","text":"

    \u5728\u8ba1\u7b97\u673a\u4e2d\uff0c\u5185\u5b58\u548c\u786c\u76d8\u662f\u4e24\u79cd\u4e3b\u8981\u7684\u5b58\u50a8\u786c\u4ef6\u8bbe\u5907\u3002\u300c\u786c\u76d8\u300d\u4e3b\u8981\u7528\u4e8e\u957f\u671f\u5b58\u50a8\u6570\u636e\uff0c\u5bb9\u91cf\u8f83\u5927\uff08\u901a\u5e38\u53ef\u8fbe\u5230 TB \u7ea7\u522b\uff09\u3001\u901f\u5ea6\u8f83\u6162\u3002\u300c\u5185\u5b58\u300d\u7528\u4e8e\u8fd0\u884c\u7a0b\u5e8f\u65f6\u6682\u5b58\u6570\u636e\uff0c\u901f\u5ea6\u8f83\u5feb\uff0c\u4f46\u5bb9\u91cf\u8f83\u5c0f\uff08\u901a\u5e38\u4e3a GB \u7ea7\u522b\uff09\u3002

    \u5728\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\uff0c\u76f8\u5173\u6570\u636e\u90fd\u5b58\u50a8\u5728\u5185\u5b58\u4e2d\u3002\u4e0b\u56fe\u5c55\u793a\u4e86\u4e00\u4e2a\u8ba1\u7b97\u673a\u5185\u5b58\u6761\uff0c\u5176\u4e2d\u6bcf\u4e2a\u9ed1\u8272\u65b9\u5757\u90fd\u5305\u542b\u4e00\u5757\u5185\u5b58\u7a7a\u95f4\u3002\u6211\u4eec\u53ef\u4ee5\u5c06\u5185\u5b58\u60f3\u8c61\u6210\u4e00\u4e2a\u5de8\u5927\u7684 Excel \u8868\u683c\uff0c\u5176\u4e2d\u6bcf\u4e2a\u5355\u5143\u683c\u90fd\u53ef\u4ee5\u5b58\u50a8 1 byte \u7684\u6570\u636e\uff0c\u5728\u7b97\u6cd5\u8fd0\u884c\u65f6\uff0c\u6240\u6709\u6570\u636e\u90fd\u88ab\u5b58\u50a8\u5728\u8fd9\u4e9b\u5355\u5143\u683c\u4e2d\u3002

    \u7cfb\u7edf\u901a\u8fc7\u300c\u5185\u5b58\u5730\u5740 Memory Location\u300d\u6765\u8bbf\u95ee\u76ee\u6807\u5185\u5b58\u4f4d\u7f6e\u7684\u6570\u636e\u3002\u8ba1\u7b97\u673a\u6839\u636e\u7279\u5b9a\u89c4\u5219\u4e3a\u8868\u683c\u4e2d\u7684\u6bcf\u4e2a\u5355\u5143\u683c\u5206\u914d\u7f16\u53f7\uff0c\u786e\u4fdd\u6bcf\u4e2a\u5185\u5b58\u7a7a\u95f4\u90fd\u6709\u552f\u4e00\u7684\u5185\u5b58\u5730\u5740\u3002\u6709\u4e86\u8fd9\u4e9b\u5730\u5740\uff0c\u7a0b\u5e8f\u4fbf\u53ef\u4ee5\u8bbf\u95ee\u5185\u5b58\u4e2d\u7684\u6570\u636e\u3002

    Fig. \u5185\u5b58\u6761\u3001\u5185\u5b58\u7a7a\u95f4\u3001\u5185\u5b58\u5730\u5740

    \u5185\u5b58\u662f\u6240\u6709\u7a0b\u5e8f\u7684\u5171\u4eab\u8d44\u6e90\uff0c\u5f53\u5185\u5b58\u88ab\u67d0\u4e2a\u7a0b\u5e8f\u5360\u7528\u65f6\uff0c\u5176\u4ed6\u7a0b\u5e8f\u65e0\u6cd5\u540c\u65f6\u4f7f\u7528\u3002\u56e0\u6b64\uff0c\u5728\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u8bbe\u8ba1\u4e2d\uff0c\u5185\u5b58\u8d44\u6e90\u662f\u4e00\u4e2a\u91cd\u8981\u7684\u8003\u8651\u56e0\u7d20\u3002\u4f8b\u5982\uff0c\u7b97\u6cd5\u6240\u5360\u7528\u7684\u5185\u5b58\u5cf0\u503c\u4e0d\u5e94\u8d85\u8fc7\u7cfb\u7edf\u5269\u4f59\u7a7a\u95f2\u5185\u5b58\uff1b\u5982\u679c\u8fd0\u884c\u7684\u7a0b\u5e8f\u5f88\u591a\u5e76\u4e14\u7f3a\u5c11\u5927\u91cf\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\uff0c\u90a3\u4e48\u6240\u9009\u7528\u7684\u6570\u636e\u7ed3\u6784\u5fc5\u987b\u80fd\u591f\u5b58\u50a8\u5728\u79bb\u6563\u7684\u5185\u5b58\u7a7a\u95f4\u5185\u3002

    \u300c\u7269\u7406\u7ed3\u6784\u300d\u53cd\u6620\u4e86\u6570\u636e\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u7684\u5b58\u50a8\u65b9\u5f0f\uff0c\u53ef\u5206\u4e3a\u6570\u7ec4\u7684\u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u548c\u94fe\u8868\u7684\u79bb\u6563\u7a7a\u95f4\u5b58\u50a8\u3002\u7269\u7406\u7ed3\u6784\u4ece\u5e95\u5c42\u51b3\u5b9a\u4e86\u6570\u636e\u7684\u8bbf\u95ee\u3001\u66f4\u65b0\u3001\u589e\u5220\u7b49\u64cd\u4f5c\u65b9\u6cd5\uff0c\u540c\u65f6\u5728\u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u65b9\u9762\u5448\u73b0\u51fa\u4e92\u8865\u7684\u7279\u70b9\u3002

    Fig. \u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u4e0e\u79bb\u6563\u7a7a\u95f4\u5b58\u50a8

    \u6240\u6709\u6570\u636e\u7ed3\u6784\u90fd\u662f\u57fa\u4e8e\u6570\u7ec4\u3001\u94fe\u8868\u6216\u4e8c\u8005\u7684\u7ec4\u5408\u5b9e\u73b0\u7684\u3002\u4f8b\u5982\uff0c\u6808\u548c\u961f\u5217\u65e2\u53ef\u4ee5\u4f7f\u7528\u6570\u7ec4\u5b9e\u73b0\uff0c\u4e5f\u53ef\u4ee5\u4f7f\u7528\u94fe\u8868\u5b9e\u73b0\uff1b\u800c\u54c8\u5e0c\u8868\u7684\u5b9e\u73b0\u53ef\u80fd\u540c\u65f6\u5305\u542b\u6570\u7ec4\u548c\u94fe\u8868\u3002

    • \u57fa\u4e8e\u6570\u7ec4\u53ef\u5b9e\u73b0\uff1a\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\u3001\u77e9\u9635\u3001\u5f20\u91cf\uff08\u7ef4\u5ea6 \\(\\geq 3\\) \u7684\u6570\u7ec4\uff09\u7b49\uff1b
    • \u57fa\u4e8e\u94fe\u8868\u53ef\u5b9e\u73b0\uff1a\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\u7b49\uff1b

    \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u4e5f\u88ab\u79f0\u4e3a\u300c\u9759\u6001\u6570\u636e\u7ed3\u6784\u300d\uff0c\u8fd9\u610f\u5473\u7740\u6b64\u7c7b\u6570\u636e\u7ed3\u6784\u5728\u521d\u59cb\u5316\u540e\u957f\u5ea6\u4e0d\u53ef\u53d8\u3002\u76f8\u5bf9\u5e94\u5730\uff0c\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u88ab\u79f0\u4e3a\u300c\u52a8\u6001\u6570\u636e\u7ed3\u6784\u300d\uff0c\u8fd9\u7c7b\u6570\u636e\u7ed3\u6784\u5728\u521d\u59cb\u5316\u540e\uff0c\u4ecd\u53ef\u4ee5\u5728\u7a0b\u5e8f\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u5bf9\u5176\u957f\u5ea6\u8fdb\u884c\u8c03\u6574\u3002

    Tip

    \u5982\u82e5\u611f\u89c9\u7406\u89e3\u7269\u7406\u7ed3\u6784\u6709\u56f0\u96be\uff0c\u5efa\u8bae\u5148\u9605\u8bfb\u4e0b\u4e00\u7ae0\u201c\u6570\u7ec4\u4e0e\u94fe\u8868\u201d\uff0c\u7136\u540e\u518d\u56de\u5934\u7406\u89e3\u7269\u7406\u7ed3\u6784\u7684\u542b\u4e49\u3002\u6570\u7ec4\u4e0e\u94fe\u8868\u662f\u5176\u4ed6\u6240\u6709\u6570\u636e\u7ed3\u6784\u7684\u57fa\u77f3\uff0c\u5efa\u8bae\u4f60\u6295\u5165\u66f4\u591a\u65f6\u95f4\u6df1\u5165\u4e86\u89e3\u8fd9\u4e24\u79cd\u57fa\u672c\u6570\u636e\u7ed3\u6784\u3002

    "},{"location":"chapter_data_structure/number_encoding/","title":"3.3. \u00a0 \u6570\u5b57\u7f16\u7801 *","text":"

    Note

    \u5728\u672c\u4e66\u4e2d\uff0c\u6807\u9898\u5e26\u6709\u7684 * \u7b26\u53f7\u7684\u662f\u9009\u8bfb\u7ae0\u8282\u3002\u5982\u679c\u4f60\u65f6\u95f4\u6709\u9650\u6216\u611f\u5230\u7406\u89e3\u56f0\u96be\uff0c\u5efa\u8bae\u5148\u8df3\u8fc7\uff0c\u7b49\u5b66\u5b8c\u5fc5\u8bfb\u7ae0\u8282\u540e\u518d\u5355\u72ec\u653b\u514b\u3002

    "},{"location":"chapter_data_structure/number_encoding/#331","title":"3.3.1. \u00a0 \u539f\u7801\u3001\u53cd\u7801\u548c\u8865\u7801","text":"

    \u4ece\u4e0a\u4e00\u8282\u7684\u8868\u683c\u4e2d\u6211\u4eec\u53d1\u73b0\uff0c\u6240\u6709\u6574\u6570\u7c7b\u578b\u80fd\u591f\u8868\u793a\u7684\u8d1f\u6570\u90fd\u6bd4\u6b63\u6570\u591a\u4e00\u4e2a\u3002\u4f8b\u5982\uff0cbyte \u7684\u53d6\u503c\u8303\u56f4\u662f \\([-128, 127]\\) \u3002\u8fd9\u4e2a\u73b0\u8c61\u6bd4\u8f83\u53cd\u76f4\u89c9\uff0c\u5b83\u7684\u5185\u5728\u539f\u56e0\u6d89\u53ca\u5230\u539f\u7801\u3001\u53cd\u7801\u3001\u8865\u7801\u7684\u76f8\u5173\u77e5\u8bc6\u3002\u5728\u5c55\u5f00\u5206\u6790\u4e4b\u524d\uff0c\u6211\u4eec\u9996\u5148\u7ed9\u51fa\u4e09\u8005\u7684\u5b9a\u4e49\uff1a

    • \u539f\u7801\uff1a\u6211\u4eec\u5c06\u6570\u5b57\u7684\u4e8c\u8fdb\u5236\u8868\u793a\u7684\u6700\u9ad8\u4f4d\u89c6\u4e3a\u7b26\u53f7\u4f4d\uff0c\u5176\u4e2d \\(0\\) \u8868\u793a\u6b63\u6570\uff0c\\(1\\) \u8868\u793a\u8d1f\u6570\uff0c\u5176\u4f59\u4f4d\u8868\u793a\u6570\u5b57\u7684\u503c\u3002
    • \u53cd\u7801\uff1a\u6b63\u6570\u7684\u53cd\u7801\u4e0e\u5176\u539f\u7801\u76f8\u540c\uff0c\u8d1f\u6570\u7684\u53cd\u7801\u662f\u5bf9\u5176\u539f\u7801\u9664\u7b26\u53f7\u4f4d\u5916\u7684\u6240\u6709\u4f4d\u53d6\u53cd\u3002
    • \u8865\u7801\uff1a\u6b63\u6570\u7684\u8865\u7801\u4e0e\u5176\u539f\u7801\u76f8\u540c\uff0c\u8d1f\u6570\u7684\u8865\u7801\u662f\u5728\u5176\u53cd\u7801\u7684\u57fa\u7840\u4e0a\u52a0 \\(1\\) \u3002

    Fig. \u539f\u7801\u3001\u53cd\u7801\u4e0e\u8865\u7801\u4e4b\u95f4\u7684\u76f8\u4e92\u8f6c\u6362

    \u663e\u7136\uff0c\u300c\u539f\u7801\u300d\u6700\u4e3a\u76f4\u89c2\uff0c\u7136\u800c\u6570\u5b57\u5374\u662f\u4ee5\u300c\u8865\u7801\u300d\u7684\u5f62\u5f0f\u5b58\u50a8\u5728\u8ba1\u7b97\u673a\u4e2d\u7684\u3002\u8fd9\u662f\u56e0\u4e3a\u539f\u7801\u5b58\u5728\u4e00\u4e9b\u5c40\u9650\u6027\u3002

    \u4e00\u65b9\u9762\uff0c\u8d1f\u6570\u7684\u539f\u7801\u4e0d\u80fd\u76f4\u63a5\u7528\u4e8e\u8fd0\u7b97\u3002\u4f8b\u5982\uff0c\u6211\u4eec\u5728\u539f\u7801\u4e0b\u8ba1\u7b97 \\(1 + (-2)\\) \uff0c\u5f97\u5230\u7684\u7ed3\u679c\u662f \\(-3\\) \uff0c\u8fd9\u663e\u7136\u662f\u4e0d\u5bf9\u7684\u3002

    \\[ \\begin{aligned} & 1 + (-2) \\newline & = 0000 \\space 0001 + 1000 \\space 0010 \\newline & = 1000 \\space 0011 \\newline & = -3 \\end{aligned} \\]

    \u4e3a\u4e86\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u8ba1\u7b97\u673a\u5f15\u5165\u4e86\u300c\u53cd\u7801\u300d\u3002\u4f8b\u5982\uff0c\u6211\u4eec\u5148\u5c06\u539f\u7801\u8f6c\u6362\u4e3a\u53cd\u7801\uff0c\u5e76\u5728\u53cd\u7801\u4e0b\u8ba1\u7b97 \\(1 + (-2)\\) \uff0c\u5e76\u5c06\u7ed3\u679c\u4ece\u53cd\u7801\u8f6c\u5316\u56de\u539f\u7801\uff0c\u5219\u53ef\u5f97\u5230\u6b63\u786e\u7ed3\u679c \\(-1\\) \u3002

    \\[ \\begin{aligned} & 1 + (-2) \\newline & = 0000 \\space 0001 \\space \\text{(\u539f\u7801)} + 1000 \\space 0010 \\space \\text{(\u539f\u7801)} \\newline & = 0000 \\space 0001 \\space \\text{(\u53cd\u7801)} + 1111 \\space 1101 \\space \\text{(\u53cd\u7801)} \\newline & = 1111 \\space 1110 \\space \\text{(\u53cd\u7801)} \\newline & = 1000 \\space 0001 \\space \\text{(\u539f\u7801)} \\newline & = -1 \\end{aligned} \\]

    \u53e6\u4e00\u65b9\u9762\uff0c\u6570\u5b57\u96f6\u7684\u539f\u7801\u6709 \\(+0\\) \u548c \\(-0\\) \u4e24\u79cd\u8868\u793a\u65b9\u5f0f\u3002\u8fd9\u610f\u5473\u7740\u6570\u5b57\u96f6\u5bf9\u5e94\u7740\u4e24\u4e2a\u4e0d\u540c\u7684\u4e8c\u8fdb\u5236\u7f16\u7801\uff0c\u800c\u8fd9\u53ef\u80fd\u4f1a\u5e26\u6765\u6b67\u4e49\u95ee\u9898\u3002\u4f8b\u5982\uff0c\u5728\u6761\u4ef6\u5224\u65ad\u4e2d\uff0c\u5982\u679c\u6ca1\u6709\u533a\u5206\u6b63\u96f6\u548c\u8d1f\u96f6\uff0c\u53ef\u80fd\u4f1a\u5bfc\u81f4\u9519\u8bef\u7684\u5224\u65ad\u7ed3\u679c\u3002\u5982\u679c\u6211\u4eec\u60f3\u8981\u5904\u7406\u6b63\u96f6\u548c\u8d1f\u96f6\u6b67\u4e49\uff0c\u5219\u9700\u8981\u5f15\u5165\u989d\u5916\u7684\u5224\u65ad\u64cd\u4f5c\uff0c\u5176\u53ef\u80fd\u4f1a\u964d\u4f4e\u8ba1\u7b97\u673a\u7684\u8fd0\u7b97\u6548\u7387\u3002

    \\[ \\begin{aligned} +0 & = 0000 \\space 0000 \\newline -0 & = 1000 \\space 0000 \\end{aligned} \\]

    \u4e0e\u539f\u7801\u4e00\u6837\uff0c\u53cd\u7801\u4e5f\u5b58\u5728\u6b63\u8d1f\u96f6\u6b67\u4e49\u95ee\u9898\u3002\u4e3a\u6b64\uff0c\u8ba1\u7b97\u673a\u8fdb\u4e00\u6b65\u5f15\u5165\u4e86\u300c\u8865\u7801\u300d\u3002\u90a3\u4e48\uff0c\u8865\u7801\u6709\u4ec0\u4e48\u4f5c\u7528\u5462\uff1f\u6211\u4eec\u5148\u6765\u5206\u6790\u4e00\u4e0b\u8d1f\u96f6\u7684\u8865\u7801\u7684\u8ba1\u7b97\u8fc7\u7a0b\uff1a

    \\[ \\begin{aligned} -0 = \\space & 1000 \\space 0000 \\space \\text{(\u539f\u7801)} \\newline = \\space & 1111 \\space 1111 \\space \\text{(\u53cd\u7801)} \\newline = 1 \\space & 0000 \\space 0000 \\space \\text{(\u8865\u7801)} \\newline \\end{aligned} \\]

    \u5728\u8d1f\u96f6\u7684\u53cd\u7801\u57fa\u7840\u4e0a\u52a0 \\(1\\) \u4f1a\u4ea7\u751f\u8fdb\u4f4d\uff0c\u800c\u7531\u4e8e byte \u7684\u957f\u5ea6\u53ea\u6709 8 \u4f4d\uff0c\u56e0\u6b64\u6ea2\u51fa\u5230\u7b2c 9 \u4f4d\u7684 \\(1\\) \u4f1a\u88ab\u820d\u5f03\u3002\u4ece\u800c\u5f97\u5230\u8d1f\u96f6\u7684\u8865\u7801\u4e3a \\(0000 \\space 0000\\) \uff0c\u4e0e\u6b63\u96f6\u7684\u8865\u7801\u76f8\u540c\u3002\u8fd9\u610f\u5473\u7740\u5728\u8865\u7801\u8868\u793a\u4e2d\u53ea\u5b58\u5728\u4e00\u4e2a\u96f6\uff0c\u4ece\u800c\u89e3\u51b3\u4e86\u6b63\u8d1f\u96f6\u6b67\u4e49\u95ee\u9898\u3002

    \u8fd8\u5269\u4f59\u6700\u540e\u4e00\u4e2a\u7591\u60d1\uff1abyte \u7684\u53d6\u503c\u8303\u56f4\u662f \\([-128, 127]\\) \uff0c\u591a\u51fa\u6765\u7684\u4e00\u4e2a\u8d1f\u6570 \\(-128\\) \u662f\u5982\u4f55\u5f97\u5230\u7684\u5462\uff1f\u6211\u4eec\u6ce8\u610f\u5230\uff0c\u533a\u95f4 \\([-127, +127]\\) \u5185\u7684\u6240\u6709\u6574\u6570\u90fd\u6709\u5bf9\u5e94\u7684\u539f\u7801\u3001\u53cd\u7801\u548c\u8865\u7801\uff0c\u5e76\u4e14\u539f\u7801\u548c\u8865\u7801\u4e4b\u95f4\u662f\u53ef\u4ee5\u4e92\u76f8\u8f6c\u6362\u7684\u3002

    \u7136\u800c\uff0c\u8865\u7801 \\(1000 \\space 0000\\) \u662f\u4e00\u4e2a\u4f8b\u5916\uff0c\u5b83\u5e76\u6ca1\u6709\u5bf9\u5e94\u7684\u539f\u7801\u3002\u6839\u636e\u8f6c\u6362\u65b9\u6cd5\uff0c\u6211\u4eec\u5f97\u5230\u8be5\u8865\u7801\u7684\u539f\u7801\u4e3a \\(0000 \\space 0000\\) \u3002\u8fd9\u663e\u7136\u662f\u77db\u76fe\u7684\uff0c\u56e0\u4e3a\u8be5\u539f\u7801\u8868\u793a\u6570\u5b57 \\(0\\) \uff0c\u5b83\u7684\u8865\u7801\u5e94\u8be5\u662f\u81ea\u8eab\u3002\u8ba1\u7b97\u673a\u89c4\u5b9a\u8fd9\u4e2a\u7279\u6b8a\u7684\u8865\u7801 \\(1000 \\space 0000\\) \u4ee3\u8868 \\(-128\\) \u3002\u5b9e\u9645\u4e0a\uff0c\\((-1) + (-127)\\) \u5728\u8865\u7801\u4e0b\u7684\u8ba1\u7b97\u7ed3\u679c\u5c31\u662f \\(-128\\) \u3002

    \\[ \\begin{aligned} & (-127) + (-1) \\newline & = 1111 \\space 1111 \\space \\text{(\u539f\u7801)} + 1000 \\space 0001 \\space \\text{(\u539f\u7801)} \\newline & = 1000 \\space 0000 \\space \\text{(\u53cd\u7801)} + 1111 \\space 1110 \\space \\text{(\u53cd\u7801)} \\newline & = 1000 \\space 0001 \\space \\text{(\u8865\u7801)} + 1111 \\space 1111 \\space \\text{(\u8865\u7801)} \\newline & = 1000 \\space 0000 \\space \\text{(\u8865\u7801)} \\newline & = -128 \\end{aligned} \\]

    \u4f60\u53ef\u80fd\u5df2\u7ecf\u53d1\u73b0\uff0c\u4e0a\u8ff0\u7684\u6240\u6709\u8ba1\u7b97\u90fd\u662f\u52a0\u6cd5\u8fd0\u7b97\u3002\u8fd9\u6697\u793a\u7740\u4e00\u4e2a\u91cd\u8981\u4e8b\u5b9e\uff1a\u8ba1\u7b97\u673a\u5185\u90e8\u7684\u786c\u4ef6\u7535\u8def\u4e3b\u8981\u662f\u57fa\u4e8e\u52a0\u6cd5\u8fd0\u7b97\u8bbe\u8ba1\u7684\u3002\u8fd9\u662f\u56e0\u4e3a\u52a0\u6cd5\u8fd0\u7b97\u76f8\u5bf9\u4e8e\u5176\u4ed6\u8fd0\u7b97\uff08\u6bd4\u5982\u4e58\u6cd5\u3001\u9664\u6cd5\u548c\u51cf\u6cd5\uff09\u6765\u8bf4\uff0c\u786c\u4ef6\u5b9e\u73b0\u8d77\u6765\u66f4\u7b80\u5355\uff0c\u66f4\u5bb9\u6613\u8fdb\u884c\u5e76\u884c\u5316\u5904\u7406\uff0c\u4ece\u800c\u63d0\u9ad8\u8fd0\u7b97\u901f\u5ea6\u3002

    \u7136\u800c\uff0c\u8fd9\u5e76\u4e0d\u610f\u5473\u7740\u8ba1\u7b97\u673a\u53ea\u80fd\u505a\u52a0\u6cd5\u3002\u901a\u8fc7\u5c06\u52a0\u6cd5\u4e0e\u4e00\u4e9b\u57fa\u672c\u903b\u8f91\u8fd0\u7b97\u7ed3\u5408\uff0c\u8ba1\u7b97\u673a\u80fd\u591f\u5b9e\u73b0\u5404\u79cd\u5176\u4ed6\u7684\u6570\u5b66\u8fd0\u7b97\u3002\u4f8b\u5982\uff0c\u8ba1\u7b97\u51cf\u6cd5 \\(a - b\\) \u53ef\u4ee5\u8f6c\u6362\u4e3a\u8ba1\u7b97\u52a0\u6cd5 \\(a + (-b)\\) \uff1b\u8ba1\u7b97\u4e58\u6cd5\u548c\u9664\u6cd5\u53ef\u4ee5\u8f6c\u6362\u4e3a\u8ba1\u7b97\u591a\u6b21\u52a0\u6cd5\u6216\u51cf\u6cd5\u3002

    \u73b0\u5728\uff0c\u6211\u4eec\u53ef\u4ee5\u603b\u7ed3\u51fa\u8ba1\u7b97\u673a\u4f7f\u7528\u8865\u7801\u7684\u539f\u56e0\uff1a\u57fa\u4e8e\u8865\u7801\u8868\u793a\uff0c\u8ba1\u7b97\u673a\u53ef\u4ee5\u7528\u540c\u6837\u7684\u7535\u8def\u548c\u64cd\u4f5c\u6765\u5904\u7406\u6b63\u6570\u548c\u8d1f\u6570\u7684\u52a0\u6cd5\uff0c\u4e0d\u9700\u8981\u8bbe\u8ba1\u7279\u6b8a\u7684\u786c\u4ef6\u7535\u8def\u6765\u5904\u7406\u51cf\u6cd5\uff0c\u5e76\u4e14\u65e0\u9700\u7279\u522b\u5904\u7406\u6b63\u8d1f\u96f6\u7684\u6b67\u4e49\u95ee\u9898\u3002\u8fd9\u5927\u5927\u7b80\u5316\u4e86\u786c\u4ef6\u8bbe\u8ba1\uff0c\u5e76\u63d0\u9ad8\u4e86\u8fd0\u7b97\u6548\u7387\u3002

    \u8865\u7801\u7684\u8bbe\u8ba1\u975e\u5e38\u7cbe\u5999\uff0c\u7531\u4e8e\u7bc7\u5e45\u5173\u7cfb\u6211\u4eec\u5148\u4ecb\u7ecd\u5230\u8fd9\u91cc\u3002\u5efa\u8bae\u6709\u5174\u8da3\u7684\u8bfb\u8005\u8fdb\u4e00\u6b65\u6df1\u5ea6\u4e86\u89e3\u3002

    "},{"location":"chapter_data_structure/number_encoding/#332","title":"3.3.2. \u00a0 \u6d6e\u70b9\u6570\u7f16\u7801","text":"

    \u7ec6\u5fc3\u7684\u4f60\u53ef\u80fd\u4f1a\u53d1\u73b0\uff1aint \u548c float \u957f\u5ea6\u76f8\u540c\uff0c\u90fd\u662f 4 bytes\uff0c\u4f46\u4e3a\u4ec0\u4e48 float \u7684\u53d6\u503c\u8303\u56f4\u8fdc\u5927\u4e8e int \uff1f\u8fd9\u975e\u5e38\u53cd\u76f4\u89c9\uff0c\u56e0\u4e3a\u6309\u7406\u8bf4 float \u9700\u8981\u8868\u793a\u5c0f\u6570\uff0c\u53d6\u503c\u8303\u56f4\u5e94\u8be5\u53d8\u5c0f\u624d\u5bf9\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8fd9\u662f\u56e0\u4e3a\u6d6e\u70b9\u6570 float \u91c7\u7528\u4e86\u4e0d\u540c\u7684\u8868\u793a\u65b9\u5f0f\u3002\u6839\u636e IEEE 754 \u6807\u51c6\uff0c32-bit \u957f\u5ea6\u7684 float \u7531\u4ee5\u4e0b\u90e8\u5206\u6784\u6210\uff1a

    • \u7b26\u53f7\u4f4d \\(\\mathrm{S}\\) \uff1a\u5360 1 bit \uff1b
    • \u6307\u6570\u4f4d \\(\\mathrm{E}\\) \uff1a\u5360 8 bits \uff1b
    • \u5206\u6570\u4f4d \\(\\mathrm{N}\\) \uff1a\u5360 24 bits \uff0c\u5176\u4e2d 23 \u4f4d\u663e\u5f0f\u5b58\u50a8\uff1b

    \u8bbe 32-bit \u4e8c\u8fdb\u5236\u6570\u7684\u7b2c \\(i\\) \u4f4d\u4e3a \\(b_i\\) \uff0c\u5219 float \u503c\u7684\u8ba1\u7b97\u65b9\u6cd5\u5b9a\u4e49\u4e3a\uff1a

    \\[ \\text { val } = (-1)^{b_{31}} \\times 2^{\\left(b_{30} b_{29} \\ldots b_{23}\\right)_2-127} \\times\\left(1 . b_{22} b_{21} \\ldots b_0\\right)_2 \\]

    \u8f6c\u5316\u5230\u5341\u8fdb\u5236\u4e0b\u7684\u8ba1\u7b97\u516c\u5f0f\u4e3a

    \\[ \\text { val }=(-1)^{\\mathrm{S}} \\times 2^{\\mathrm{E} -127} \\times (1 + \\mathrm{N}) \\]

    \u5176\u4e2d\u5404\u9879\u7684\u53d6\u503c\u8303\u56f4\u4e3a

    \\[ \\begin{aligned} \\mathrm{S} \\in & \\{ 0, 1\\} , \\quad \\mathrm{E} \\in \\{ 1, 2, \\dots, 254 \\} \\newline (1 + \\mathrm{N}) = & (1 + \\sum_{i=1}^{23} b_{23-i} 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\]

    Fig. IEEE 754 \u6807\u51c6\u4e0b\u7684 float \u8868\u793a\u65b9\u5f0f

    \u4ee5\u4e0a\u56fe\u4e3a\u4f8b\uff0c\\(\\mathrm{S} = 0\\) \uff0c \\(\\mathrm{E} = 124\\) \uff0c\\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\) \uff0c\u6613\u5f97

    \\[ \\text { val } = (-1)^0 \\times 2^{124 - 127} \\times (1 + 0.375) = 0.171875 \\]

    \u73b0\u5728\u6211\u4eec\u53ef\u4ee5\u56de\u7b54\u6700\u521d\u7684\u95ee\u9898\uff1afloat \u7684\u8868\u793a\u65b9\u5f0f\u5305\u542b\u6307\u6570\u4f4d\uff0c\u5bfc\u81f4\u5176\u53d6\u503c\u8303\u56f4\u8fdc\u5927\u4e8e int \u3002\u6839\u636e\u4ee5\u4e0a\u8ba1\u7b97\uff0cfloat \u53ef\u8868\u793a\u7684\u6700\u5927\u6b63\u6570\u4e3a \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\) \uff0c\u5207\u6362\u7b26\u53f7\u4f4d\u4fbf\u53ef\u5f97\u5230\u6700\u5c0f\u8d1f\u6570\u3002

    \u5c3d\u7ba1\u6d6e\u70b9\u6570 float \u6269\u5c55\u4e86\u53d6\u503c\u8303\u56f4\uff0c\u4f46\u5176\u526f\u4f5c\u7528\u662f\u727a\u7272\u4e86\u7cbe\u5ea6\u3002\u6574\u6570\u7c7b\u578b int \u5c06\u5168\u90e8 32 \u4f4d\u7528\u4e8e\u8868\u793a\u6570\u5b57\uff0c\u6570\u5b57\u662f\u5747\u5300\u5206\u5e03\u7684\uff1b\u800c\u7531\u4e8e\u6307\u6570\u4f4d\u7684\u5b58\u5728\uff0c\u6d6e\u70b9\u6570 float \u7684\u6570\u503c\u8d8a\u5927\uff0c\u76f8\u90bb\u4e24\u4e2a\u6570\u5b57\u4e4b\u95f4\u7684\u5dee\u503c\u5c31\u4f1a\u8d8b\u5411\u8d8a\u5927\u3002

    \u8fdb\u4e00\u6b65\u5730\uff0c\u6307\u6570\u4f4d \\(E = 0\\) \u548c \\(E = 255\\) \u5177\u6709\u7279\u6b8a\u542b\u4e49\uff0c\u7528\u4e8e\u8868\u793a\u96f6\u3001\u65e0\u7a77\u5927\u3001\\(\\mathrm{NaN}\\) \u7b49\u3002

    \u6307\u6570\u4f4d E \u5206\u6570\u4f4d \\(\\mathrm{N} = 0\\) \u5206\u6570\u4f4d \\(\\mathrm{N} \\ne 0\\) \u8ba1\u7b97\u516c\u5f0f \\(0\\) \\(\\pm 0\\) \u6b21\u6b63\u89c4\u6570 \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) \u6b63\u89c4\u6570 \u6b63\u89c4\u6570 \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\)

    \u7279\u522b\u5730\uff0c\u6b21\u6b63\u89c4\u6570\u663e\u8457\u63d0\u5347\u4e86\u6d6e\u70b9\u6570\u7684\u7cbe\u5ea6\uff0c\u8fd9\u662f\u56e0\u4e3a\uff1a

    • \u6700\u5c0f\u6b63\u6b63\u89c4\u6570\u4e3a \\(2^{-126} \\approx 1.18 \\times 10^{-38}\\) \uff1b
    • \u6700\u5c0f\u6b63\u6b21\u6b63\u89c4\u6570\u4e3a \\(2^{-126} \\times 2^{-23} \\approx 1.4 \\times 10^{-45}\\) \uff1b

    \u53cc\u7cbe\u5ea6 double \u4e5f\u91c7\u7528\u7c7b\u4f3c float \u7684\u8868\u793a\u65b9\u6cd5\uff0c\u6b64\u5904\u4e0d\u518d\u8be6\u8ff0\u3002

    "},{"location":"chapter_data_structure/summary/","title":"3.5. \u00a0 \u5c0f\u7ed3","text":"

    \u6570\u636e\u7ed3\u6784\u5206\u7c7b

    • \u6570\u636e\u7ed3\u6784\u53ef\u4ee5\u4ece\u903b\u8f91\u7ed3\u6784\u548c\u7269\u7406\u7ed3\u6784\u4e24\u4e2a\u89d2\u5ea6\u8fdb\u884c\u5206\u7c7b\u3002\u903b\u8f91\u7ed3\u6784\u63cf\u8ff0\u4e86\u6570\u636e\u5143\u7d20\u4e4b\u95f4\u7684\u903b\u8f91\u5173\u7cfb\uff0c\u800c\u7269\u7406\u7ed3\u6784\u63cf\u8ff0\u4e86\u6570\u636e\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u7684\u5b58\u50a8\u65b9\u5f0f\u3002
    • \u5e38\u89c1\u7684\u903b\u8f91\u7ed3\u6784\u5305\u62ec\u7ebf\u6027\u3001\u6811\u72b6\u548c\u7f51\u72b6\u7b49\u3002\u901a\u5e38\u6211\u4eec\u6839\u636e\u903b\u8f91\u7ed3\u6784\u5c06\u6570\u636e\u7ed3\u6784\u5206\u4e3a\u7ebf\u6027\uff08\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\uff09\u548c\u975e\u7ebf\u6027\uff08\u6811\u3001\u56fe\u3001\u5806\uff09\u4e24\u79cd\u3002\u54c8\u5e0c\u8868\u7684\u5b9e\u73b0\u53ef\u80fd\u540c\u65f6\u5305\u542b\u7ebf\u6027\u548c\u975e\u7ebf\u6027\u7ed3\u6784\u3002
    • \u5f53\u7a0b\u5e8f\u8fd0\u884c\u65f6\uff0c\u6570\u636e\u88ab\u5b58\u50a8\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u3002\u6bcf\u4e2a\u5185\u5b58\u7a7a\u95f4\u90fd\u62e5\u6709\u5bf9\u5e94\u7684\u5185\u5b58\u5730\u5740\uff0c\u7a0b\u5e8f\u901a\u8fc7\u8fd9\u4e9b\u5185\u5b58\u5730\u5740\u8bbf\u95ee\u6570\u636e\u3002
    • \u7269\u7406\u7ed3\u6784\u4e3b\u8981\u5206\u4e3a\u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\uff08\u6570\u7ec4\uff09\u548c\u79bb\u6563\u7a7a\u95f4\u5b58\u50a8\uff08\u94fe\u8868\uff09\u3002\u6240\u6709\u6570\u636e\u7ed3\u6784\u90fd\u662f\u7531\u6570\u7ec4\u3001\u94fe\u8868\u6216\u4e24\u8005\u7684\u7ec4\u5408\u5b9e\u73b0\u7684\u3002

    \u6570\u636e\u7c7b\u578b\u4e0e\u7f16\u7801

    • \u8ba1\u7b97\u673a\u4e2d\u7684\u57fa\u672c\u6570\u636e\u7c7b\u578b\u5305\u62ec\u6574\u6570 byte, short, int, long \u3001\u6d6e\u70b9\u6570 float, double \u3001\u5b57\u7b26 char \u548c\u5e03\u5c14 boolean \u3002\u5b83\u4eec\u7684\u53d6\u503c\u8303\u56f4\u53d6\u51b3\u4e8e\u5360\u7528\u7a7a\u95f4\u5927\u5c0f\u548c\u8868\u793a\u65b9\u5f0f\u3002
    • \u539f\u7801\u3001\u53cd\u7801\u548c\u8865\u7801\u662f\u5728\u8ba1\u7b97\u673a\u4e2d\u7f16\u7801\u6570\u5b57\u7684\u4e09\u79cd\u65b9\u6cd5\uff0c\u5b83\u4eec\u4e4b\u95f4\u662f\u53ef\u4ee5\u76f8\u4e92\u8f6c\u6362\u7684\u3002\u6574\u6570\u7684\u539f\u7801\u7684\u6700\u9ad8\u4f4d\u662f\u7b26\u53f7\u4f4d\uff0c\u5176\u4f59\u4f4d\u662f\u6570\u5b57\u7684\u503c\u3002
    • \u6574\u6570\u5728\u8ba1\u7b97\u673a\u4e2d\u662f\u4ee5\u8865\u7801\u7684\u5f62\u5f0f\u5b58\u50a8\u7684\u3002\u5728\u8865\u7801\u8868\u793a\u4e0b\uff0c\u8ba1\u7b97\u673a\u53ef\u4ee5\u5bf9\u6b63\u6570\u548c\u8d1f\u6570\u7684\u52a0\u6cd5\u4e00\u89c6\u540c\u4ec1\uff0c\u4e0d\u9700\u8981\u4e3a\u51cf\u6cd5\u64cd\u4f5c\u5355\u72ec\u8bbe\u8ba1\u7279\u6b8a\u7684\u786c\u4ef6\u7535\u8def\uff0c\u5e76\u4e14\u4e0d\u5b58\u5728\u6b63\u8d1f\u96f6\u6b67\u4e49\u7684\u95ee\u9898\u3002
    • \u6d6e\u70b9\u6570\u7684\u7f16\u7801\u7531 1 \u4f4d\u7b26\u53f7\u4f4d\u30018 \u4f4d\u6307\u6570\u4f4d\u548c 23 \u4f4d\u5206\u6570\u4f4d\u6784\u6210\u3002\u7531\u4e8e\u5b58\u5728\u6307\u6570\u4f4d\uff0c\u6d6e\u70b9\u6570\u7684\u53d6\u503c\u8303\u56f4\u8fdc\u5927\u4e8e\u6574\u6570\uff0c\u4ee3\u4ef7\u662f\u727a\u7272\u4e86\u7cbe\u5ea6\u3002
    • ASCII \u7801\u662f\u6700\u65e9\u51fa\u73b0\u7684\u82f1\u6587\u5b57\u7b26\u96c6\uff0c\u957f\u5ea6\u4e3a 1 \u5b57\u8282\uff0c\u5171\u6536\u5f55 127 \u4e2a\u5b57\u7b26\u3002GBK \u5b57\u7b26\u96c6\u662f\u5e38\u7528\u7684\u4e2d\u6587\u5b57\u7b26\u96c6\uff0c\u5171\u6536\u5f55\u4e24\u4e07\u591a\u4e2a\u6c49\u5b57\u3002Unicode \u81f4\u529b\u4e8e\u63d0\u4f9b\u4e00\u4e2a\u5b8c\u6574\u7684\u5b57\u7b26\u96c6\u6807\u51c6\uff0c\u6536\u5f55\u4e16\u754c\u5185\u5404\u79cd\u8bed\u8a00\u7684\u5b57\u7b26\uff0c\u4ece\u800c\u89e3\u51b3\u7531\u4e8e\u5b57\u7b26\u7f16\u7801\u65b9\u6cd5\u4e0d\u4e00\u81f4\u800c\u5bfc\u81f4\u7684\u4e71\u7801\u95ee\u9898\u3002
    • UTF-8 \u662f\u6700\u53d7\u6b22\u8fce\u7684 Unicode \u7f16\u7801\u65b9\u6cd5\uff0c\u901a\u7528\u6027\u975e\u5e38\u597d\u3002\u5b83\u662f\u4e00\u79cd\u53d8\u957f\u7684\u7f16\u7801\u65b9\u6cd5\uff0c\u5177\u6709\u5f88\u597d\u7684\u6269\u5c55\u6027\uff0c\u6709\u6548\u63d0\u5347\u4e86\u5b58\u50a8\u7a7a\u95f4\u7684\u4f7f\u7528\u6548\u7387\u3002UTF-16 \u548c UTF-32 \u662f\u7b49\u957f\u7684\u7f16\u7801\u65b9\u6cd5\u3002\u5728\u7f16\u7801\u4e2d\u6587\u65f6\uff0cUTF-16 \u6bd4 UTF-8 \u7684\u5360\u7528\u7a7a\u95f4\u66f4\u5c0f\u3002Java, C# \u7b49\u7f16\u7a0b\u8bed\u8a00\u9ed8\u8ba4\u4f7f\u7528 UTF-16 \u7f16\u7801\u3002
    "},{"location":"chapter_data_structure/summary/#351-q-a","title":"3.5.1. \u00a0 Q & A","text":"

    \u4e3a\u4ec0\u4e48\u54c8\u5e0c\u8868\u540c\u65f6\u5305\u542b\u7ebf\u6027\u6570\u636e\u7ed3\u6784\u548c\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff1f

    \u54c8\u5e0c\u8868\u5e95\u5c42\u662f\u6570\u7ec4\uff0c\u800c\u4e3a\u4e86\u89e3\u51b3\u54c8\u5e0c\u51b2\u7a81\uff0c\u6211\u4eec\u53ef\u80fd\u4f1a\u4f7f\u7528\u201c\u62c9\u94fe\u6cd5\u201d\uff08\u540e\u7eed\u6563\u5217\u8868\u7ae0\u8282\u4f1a\u8bb2\uff09\u3002\u5728\u62c9\u94fe\u6cd5\u4e2d\uff0c\u6570\u7ec4\u4e2d\u6bcf\u4e2a\u5730\u5740\uff08\u6876\uff09\u6307\u5411\u4e00\u4e2a\u94fe\u8868\uff1b\u5f53\u8fd9\u4e2a\u94fe\u8868\u957f\u5ea6\u8d85\u8fc7\u4e00\u5b9a\u9608\u503c\u65f6\uff0c\u53c8\u53ef\u80fd\u88ab\u8f6c\u5316\u4e3a\u6811\uff08\u901a\u5e38\u4e3a\u7ea2\u9ed1\u6811\uff09\u3002\u56e0\u6b64\uff0c\u54c8\u5e0c\u8868\u53ef\u80fd\u540c\u65f6\u5305\u542b\u7ebf\u6027\uff08\u6570\u7ec4\u3001\u94fe\u8868\uff09\u548c\u975e\u7ebf\u6027\uff08\u6811\uff09\u6570\u636e\u7ed3\u6784\u3002

    char \u7c7b\u578b\u7684\u957f\u5ea6\u662f 1 bytes \u5417\uff1f

    \u8fd9\u4e2a\u4e0e\u7f16\u7a0b\u8bed\u8a00\u91c7\u7528\u7684\u7f16\u7801\u65b9\u6cd5\u6709\u5173\u3002\u4f8b\u5982\uff0cJava, JS, TS, C# \u90fd\u91c7\u7528 UTF-16 \u7f16\u7801\uff08\u4fdd\u5b58 Unicode \u7801\u70b9\uff09\uff0c\u56e0\u6b64 char \u7c7b\u578b\u7684\u957f\u5ea6\u4e3a 2 bytes \u3002

    "},{"location":"chapter_dynamic_programming/","title":"13. \u00a0 \u52a8\u6001\u89c4\u5212","text":""},{"location":"chapter_dynamic_programming/dp_problem_features/","title":"13.2. \u00a0 \u52a8\u6001\u89c4\u5212\u95ee\u9898\u7279\u6027","text":"

    \u5728\u4e0a\u8282\u4e2d\uff0c\u6211\u4eec\u5b66\u4e60\u4e86\u52a8\u6001\u89c4\u5212\u95ee\u9898\u7684\u66b4\u529b\u89e3\u6cd5\uff0c\u4ece\u9012\u5f52\u6811\u4e2d\u89c2\u5bdf\u5230\u6d77\u91cf\u7684\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u4ee5\u53ca\u4e86\u89e3\u5230\u52a8\u6001\u89c4\u5212\u662f\u5982\u4f55\u901a\u8fc7\u8bb0\u5f55\u89e3\u6765\u4f18\u5316\u65f6\u95f4\u590d\u6742\u5ea6\u7684\u3002

    \u5b9e\u9645\u4e0a\uff0c\u52a8\u6001\u89c4\u5212\u6700\u5e38\u7528\u6765\u6c42\u89e3\u6700\u4f18\u65b9\u6848\u95ee\u9898\uff0c\u4f8b\u5982\u5bfb\u627e\u6700\u77ed\u8def\u5f84\u3001\u6700\u5927\u5229\u6da6\u3001\u6700\u5c11\u65f6\u95f4\u7b49\u3002\u8fd9\u7c7b\u95ee\u9898\u4e0d\u4ec5\u5305\u542b\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u5f80\u5f80\u8fd8\u5177\u6709\u53e6\u5916\u4e24\u5927\u7279\u6027\uff1a\u6700\u4f18\u5b50\u7ed3\u6784\u3001\u65e0\u540e\u6548\u6027\u3002

    "},{"location":"chapter_dynamic_programming/dp_problem_features/#1321","title":"13.2.1. \u00a0 \u6700\u4f18\u5b50\u7ed3\u6784","text":"

    \u6211\u4eec\u5bf9\u722c\u697c\u68af\u95ee\u9898\u7a0d\u4f5c\u6539\u52a8\uff0c\u4f7f\u4e4b\u66f4\u52a0\u9002\u5408\u5c55\u793a\u6700\u4f18\u5b50\u7ed3\u6784\u6982\u5ff5\u3002

    \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7

    \u7ed9\u5b9a\u4e00\u4e2a\u697c\u68af\uff0c\u4f60\u6bcf\u6b65\u53ef\u4ee5\u4e0a \\(1\\) \u9636\u6216\u8005 \\(2\\) \u9636\uff0c\u6bcf\u4e00\u9636\u697c\u68af\u4e0a\u90fd\u8d34\u6709\u4e00\u4e2a\u975e\u8d1f\u6574\u6570\uff0c\u8868\u793a\u4f60\u5728\u8be5\u53f0\u9636\u6240\u9700\u8981\u4ed8\u51fa\u7684\u4ee3\u4ef7\u3002\u7ed9\u5b9a\u4e00\u4e2a\u975e\u8d1f\u6574\u6570\u6570\u7ec4 \\(cost\\) \uff0c\u5176\u4e2d \\(cost[i]\\) \u8868\u793a\u5728\u7b2c \\(i\\) \u4e2a\u53f0\u9636\u9700\u8981\u4ed8\u51fa\u7684\u4ee3\u4ef7\uff0c\\(cost[0]\\) \u4e3a\u5730\u9762\u8d77\u59cb\u70b9\u3002\u8bf7\u8ba1\u7b97\u6700\u5c11\u9700\u8981\u4ed8\u51fa\u591a\u5c11\u4ee3\u4ef7\u624d\u80fd\u5230\u8fbe\u9876\u90e8\uff1f

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u82e5\u7b2c \\(1\\) , \\(2\\) , \\(3\\) \u9636\u7684\u4ee3\u4ef7\u5206\u522b\u4e3a \\(1\\) , \\(10\\) , \\(1\\) \uff0c\u5219\u4ece\u5730\u9762\u722c\u5230\u7b2c \\(3\\) \u9636\u7684\u6700\u5c0f\u4ee3\u4ef7\u4e3a \\(2\\) \u3002

    Fig. \u722c\u5230\u7b2c 3 \u9636\u7684\u6700\u5c0f\u4ee3\u4ef7

    \u8bbe \\(dp[i]\\) \u4e3a\u722c\u5230\u7b2c \\(i\\) \u9636\u7d2f\u8ba1\u4ed8\u51fa\u7684\u4ee3\u4ef7\uff0c\u7531\u4e8e\u7b2c \\(i\\) \u9636\u53ea\u53ef\u80fd\u4ece \\(i - 1\\) \u9636\u6216 \\(i - 2\\) \u9636\u8d70\u6765\uff0c\u56e0\u6b64 \\(dp[i]\\) \u53ea\u53ef\u80fd\u7b49\u4e8e \\(dp[i - 1] + cost[i]\\) \u6216 \\(dp[i - 2] + cost[i]\\) \u3002\u4e3a\u4e86\u5c3d\u53ef\u80fd\u51cf\u5c11\u4ee3\u4ef7\uff0c\u6211\u4eec\u5e94\u8be5\u9009\u62e9\u4e24\u8005\u4e2d\u8f83\u5c0f\u7684\u90a3\u4e00\u4e2a\uff0c\u5373\uff1a

    \\[ dp[i] = \\min(dp[i-1], dp[i-2]) + cost[i] \\]

    \u8fd9\u4fbf\u53ef\u4ee5\u5f15\u51fa\u300c\u6700\u4f18\u5b50\u7ed3\u6784\u300d\u7684\u542b\u4e49\uff1a\u539f\u95ee\u9898\u7684\u6700\u4f18\u89e3\u662f\u4ece\u5b50\u95ee\u9898\u7684\u6700\u4f18\u89e3\u6784\u5efa\u5f97\u6765\u7684\u3002\u5bf9\u4e8e\u672c\u9898\uff0c\u6211\u4eec\u4ece\u4e24\u4e2a\u5b50\u95ee\u9898\u6700\u4f18\u89e3 \\(dp[i-1]\\) , \\(dp[i-2]\\) \u4e2d\u6311\u9009\u51fa\u8f83\u4f18\u7684\u90a3\u4e00\u4e2a\uff0c\u5e76\u7528\u5b83\u6784\u5efa\u51fa\u539f\u95ee\u9898 \\(dp[i]\\) \u7684\u6700\u4f18\u89e3\u3002

    \u76f8\u8f83\u4e8e\u5206\u6cbb\u95ee\u9898\uff0c\u52a8\u6001\u89c4\u5212\u95ee\u9898\u7684\u89e3\u4e5f\u662f\u7531\u5176\u5b50\u95ee\u9898\u7684\u89e3\u6784\u6210\u7684\u3002\u4e0d\u540c\u7684\u662f\uff0c\u52a8\u6001\u89c4\u5212\u4e2d\u5b50\u95ee\u9898\u7684\u89e3\u4e0d\u4ec5\u63ed\u793a\u4e86\u95ee\u9898\u7684\u5c40\u90e8\u6700\u4f18\u89e3\uff0c\u800c\u4e14\u8fd8\u901a\u8fc7\u7279\u5b9a\u7684\u9012\u63a8\u5173\u7cfb\u94fe\u63a5\u8d77\u6765\uff0c\u5171\u540c\u6784\u5efa\u51fa\u539f\u95ee\u9898\u7684\u5168\u5c40\u6700\u4f18\u89e3\u3002

    \u90a3\u4e48\uff0c\u4e0a\u8282\u7684\u722c\u697c\u68af\u9898\u76ee\u6709\u6ca1\u6709\u6700\u4f18\u5b50\u7ed3\u6784\u5462\uff1f\u5b83\u8981\u6c42\u89e3\u7684\u662f\u65b9\u6848\u6570\u91cf\uff0c\u770b\u4f3c\u662f\u4e00\u4e2a\u8ba1\u6570\u95ee\u9898\uff0c\u4f46\u5982\u679c\u6362\u4e00\u79cd\u95ee\u6cd5\uff1a\u6c42\u89e3\u6700\u5927\u65b9\u6848\u6570\u91cf\u3002\u6211\u4eec\u610f\u5916\u5730\u53d1\u73b0\uff0c\u867d\u7136\u9898\u76ee\u4fee\u6539\u524d\u540e\u662f\u7b49\u4ef7\u7684\uff0c\u4f46\u6700\u4f18\u5b50\u7ed3\u6784\u6d6e\u73b0\u51fa\u6765\u4e86\uff1a\u7b2c \\(n\\) \u9636\u6700\u5927\u65b9\u6848\u6570\u91cf\u7b49\u4e8e\u7b2c \\(n-1\\) \u9636\u548c\u7b2c \\(n-2\\) \u9636\u6700\u5927\u65b9\u6848\u6570\u91cf\u4e4b\u548c\u3002\u6240\u4ee5\u8bf4\uff0c\u6700\u4f18\u5b50\u7ed3\u6784\u7684\u662f\u4e00\u4e2a\u6bd4\u8f83\u5bbd\u6cdb\u7684\u6982\u5ff5\uff0c\u5728\u4e0d\u540c\u95ee\u9898\u4e2d\u4f1a\u6709\u4e0d\u540c\u7684\u542b\u4e49\u3002

    \u6839\u636e\u4ee5\u4e0a\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff0c\u4ee5\u53ca\u521d\u59cb\u72b6\u6001 \\(dp[1] = cost[1]\\) , \\(dp[2] = cost[2]\\) \uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u51fa\u52a8\u6001\u89c4\u5212\u89e3\u9898\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_cost_climbing_stairs_dp.java
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(int[] cost) {\nint n = cost.length - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[] dp = new int[n + 1];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = cost[1];\ndp[2] = cost[2];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n}\nreturn dp[n];\n}\n
    min_cost_climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(vector<int> &cost) {\nint n = cost.size() - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nvector<int> dp(n + 1);\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = cost[1];\ndp[2] = cost[2];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n}\nreturn dp[n];\n}\n
    min_cost_climbing_stairs_dp.py
    def min_cost_climbing_stairs_dp(cost: list[int]) -> int:\n\"\"\"\u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(cost) - 1\nif n == 1 or n == 2:\nreturn cost[n]\n# \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\ndp = [0] * (n + 1)\n# \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1], dp[2] = cost[1], cost[2]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor i in range(3, n + 1):\ndp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\nreturn dp[n]\n
    min_cost_climbing_stairs_dp.go
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.js
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.ts
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.c
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(int[] cost) {\nint n = cost.Length - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[] dp = new int[n + 1];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = cost[1];\ndp[2] = cost[2];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n}\nreturn dp[n];\n}\n
    min_cost_climbing_stairs_dp.swift
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.zig
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.dart
    [class]{}-[func]{minCostClimbingStairsDP}\n

    Fig. \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \u8fd9\u9053\u9898\u540c\u6837\u4e5f\u53ef\u4ee5\u8fdb\u884c\u72b6\u6001\u538b\u7f29\uff0c\u5c06\u4e00\u7ef4\u538b\u7f29\u81f3\u96f6\u7ef4\uff0c\u4f7f\u5f97\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n)\\) \u964d\u4f4e\u81f3 \\(O(1)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_cost_climbing_stairs_dp.java
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(int[] cost) {\nint n = cost.length - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\nint a = cost[1], b = cost[2];\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = Math.min(a, tmp) + cost[i];\na = tmp;\n}\nreturn b;\n}\n
    min_cost_climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(vector<int> &cost) {\nint n = cost.size() - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\nint a = cost[1], b = cost[2];\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = min(a, tmp) + cost[i];\na = tmp;\n}\nreturn b;\n}\n
    min_cost_climbing_stairs_dp.py
    def min_cost_climbing_stairs_dp_comp(cost: list[int]) -> int:\n\"\"\"\u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(cost) - 1\nif n == 1 or n == 2:\nreturn cost[n]\na, b = cost[1], cost[2]\nfor i in range(3, n + 1):\na, b = b, min(a, b) + cost[i]\nreturn b\n
    min_cost_climbing_stairs_dp.go
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.js
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.ts
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.c
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(int[] cost) {\nint n = cost.Length - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\nint a = cost[1], b = cost[2];\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = Math.Min(a, tmp) + cost[i];\na = tmp;\n}\nreturn b;\n}\n
    min_cost_climbing_stairs_dp.swift
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.zig
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.dart
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    "},{"location":"chapter_dynamic_programming/dp_problem_features/#1322","title":"13.2.2. \u00a0 \u65e0\u540e\u6548\u6027","text":"

    \u300c\u65e0\u540e\u6548\u6027\u300d\u662f\u52a8\u6001\u89c4\u5212\u80fd\u591f\u6709\u6548\u89e3\u51b3\u95ee\u9898\u7684\u91cd\u8981\u7279\u6027\u4e4b\u4e00\uff0c\u5b9a\u4e49\u4e3a\uff1a\u7ed9\u5b9a\u4e00\u4e2a\u786e\u5b9a\u7684\u72b6\u6001\uff0c\u5b83\u7684\u672a\u6765\u53d1\u5c55\u53ea\u4e0e\u5f53\u524d\u72b6\u6001\u6709\u5173\uff0c\u800c\u4e0e\u5f53\u524d\u72b6\u6001\u8fc7\u53bb\u6240\u7ecf\u5386\u8fc7\u7684\u6240\u6709\u72b6\u6001\u65e0\u5173\u3002

    \u4ee5\u722c\u697c\u68af\u95ee\u9898\u4e3a\u4f8b\uff0c\u7ed9\u5b9a\u72b6\u6001 \\(i\\) \uff0c\u5b83\u4f1a\u53d1\u5c55\u51fa\u72b6\u6001 \\(i+1\\) \u548c\u72b6\u6001 \\(i+2\\) \uff0c\u5206\u522b\u5bf9\u5e94\u8df3 \\(1\\) \u6b65\u548c\u8df3 \\(2\\) \u6b65\u3002\u5728\u505a\u51fa\u8fd9\u4e24\u79cd\u9009\u62e9\u65f6\uff0c\u6211\u4eec\u65e0\u9700\u8003\u8651\u72b6\u6001 \\(i\\) \u4e4b\u524d\u7684\u72b6\u6001\uff0c\u5373\u5b83\u4eec\u5bf9\u72b6\u6001 \\(i\\) \u7684\u672a\u6765\u6ca1\u6709\u5f71\u54cd\u3002

    \u7136\u800c\uff0c\u5982\u679c\u6211\u4eec\u5411\u722c\u697c\u68af\u95ee\u9898\u6dfb\u52a0\u4e00\u4e2a\u7ea6\u675f\uff0c\u60c5\u51b5\u5c31\u4e0d\u4e00\u6837\u4e86\u3002

    \u5e26\u7ea6\u675f\u722c\u697c\u68af

    \u7ed9\u5b9a\u4e00\u4e2a\u5171\u6709 \\(n\\) \u9636\u7684\u697c\u68af\uff0c\u4f60\u6bcf\u6b65\u53ef\u4ee5\u4e0a \\(1\\) \u9636\u6216\u8005 \\(2\\) \u9636\uff0c\u4f46\u4e0d\u80fd\u8fde\u7eed\u4e24\u8f6e\u8df3 \\(1\\) \u9636\uff0c\u8bf7\u95ee\u6709\u591a\u5c11\u79cd\u65b9\u6848\u53ef\u4ee5\u722c\u5230\u697c\u9876\u3002

    \u4f8b\u5982\uff0c\u722c\u4e0a\u7b2c \\(3\\) \u9636\u4ec5\u5269 \\(2\\) \u79cd\u53ef\u884c\u65b9\u6848\uff0c\u5176\u4e2d\u8fde\u7eed\u4e09\u6b21\u8df3 \\(1\\) \u9636\u7684\u65b9\u6848\u4e0d\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\uff0c\u56e0\u6b64\u88ab\u820d\u5f03\u3002

    Fig. \u5e26\u7ea6\u675f\u722c\u5230\u7b2c 3 \u9636\u7684\u65b9\u6848\u6570\u91cf

    \u5728\u8be5\u95ee\u9898\u4e2d\uff0c\u4e0b\u4e00\u6b65\u9009\u62e9\u4e0d\u80fd\u7531\u5f53\u524d\u72b6\u6001\uff08\u5f53\u524d\u697c\u68af\u9636\u6570\uff09\u72ec\u7acb\u51b3\u5b9a\uff0c\u8fd8\u548c\u524d\u4e00\u4e2a\u72b6\u6001\uff08\u4e0a\u8f6e\u697c\u68af\u9636\u6570\uff09\u6709\u5173\u3002\u5982\u679c\u4e0a\u4e00\u8f6e\u662f\u8df3 \\(1\\) \u9636\u4e0a\u6765\u7684\uff0c\u90a3\u4e48\u4e0b\u4e00\u8f6e\u5c31\u5fc5\u987b\u8df3 \\(2\\) \u9636\u3002

    \u4e0d\u96be\u53d1\u73b0\uff0c\u6b64\u95ee\u9898\u5df2\u4e0d\u6ee1\u8db3\u65e0\u540e\u6548\u6027\uff0c\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b \\(dp[i] = dp[i-1] + dp[i-2]\\) \u4e5f\u5931\u6548\u4e86\uff0c\u56e0\u4e3a \\(dp[i-1]\\) \u4ee3\u8868\u672c\u8f6e\u8df3 \\(1\\) \u9636\uff0c\u4f46\u5176\u4e2d\u5305\u542b\u4e86\u8bb8\u591a\u201c\u4e0a\u4e00\u8f6e\u8df3 \\(1\\) \u9636\u4e0a\u6765\u7684\u201d\u65b9\u6848\uff0c\u800c\u4e3a\u4e86\u6ee1\u8db3\u7ea6\u675f\uff0c\u6211\u4eec\u4e0d\u80fd\u5c06 \\(dp[i-1]\\) \u76f4\u63a5\u8ba1\u5165 \\(dp[i]\\) \u4e2d\u3002

    \u4e3a\u4e86\u89e3\u51b3\u8be5\u95ee\u9898\uff0c\u6211\u4eec\u9700\u8981\u6269\u5c55\u72b6\u6001\u5b9a\u4e49\uff1a\u72b6\u6001 \\([i, j]\\) \u8868\u793a\u5904\u5728\u7b2c \\(i\\) \u9636\u3001\u5e76\u4e14\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(j\\) \u9636\uff0c\u5176\u4e2d \\(j \\in \\{1, 2\\}\\) \u3002\u6b64\u72b6\u6001\u5b9a\u4e49\u6709\u6548\u5730\u533a\u5206\u4e86\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(1\\) \u9636\u8fd8\u662f \\(2\\) \u9636\uff0c\u6211\u4eec\u53ef\u4ee5\u636e\u6b64\u6765\u51b3\u5b9a\u4e0b\u4e00\u6b65\u8be5\u600e\u4e48\u8df3\uff1a

    • \u5f53 \\(j\\) \u7b49\u4e8e \\(1\\) \uff0c\u5373\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(1\\) \u9636\u65f6\uff0c\u8fd9\u4e00\u8f6e\u53ea\u80fd\u9009\u62e9\u8df3 \\(2\\) \u9636\uff1b
    • \u5f53 \\(j\\) \u7b49\u4e8e \\(2\\) \uff0c\u5373\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(2\\) \u9636\u65f6\uff0c\u8fd9\u4e00\u8f6e\u53ef\u9009\u62e9\u8df3 \\(1\\) \u9636\u6216\u8df3 \\(2\\) \u9636\uff1b

    \u5728\u8be5\u5b9a\u4e49\u4e0b\uff0c\\(dp[i, j]\\) \u8868\u793a\u72b6\u6001 \\([i, j]\\) \u5bf9\u5e94\u7684\u65b9\u6848\u6570\u3002\u7531\u6b64\uff0c\u6211\u4eec\u4fbf\u80fd\u63a8\u5bfc\u51fa\u4ee5\u4e0b\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff1a

    \\[ \\begin{cases} dp[i, 1] = dp[i-1, 2] \\\\ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2] \\end{cases} \\]

    Fig. \u8003\u8651\u7ea6\u675f\u4e0b\u7684\u9012\u63a8\u5173\u7cfb

    \u6700\u7ec8\uff0c\u8fd4\u56de \\(dp[n, 1] + dp[n, 2]\\) \u5373\u53ef\uff0c\u4e24\u8005\u4e4b\u548c\u4ee3\u8868\u722c\u5230\u7b2c \\(n\\) \u9636\u7684\u65b9\u6848\u603b\u6570\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_constraint_dp.java
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\nif (n == 1 || n == 2) {\nreturn n;\n}\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[][] dp = new int[n + 1][3];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1][1] = 1;\ndp[1][2] = 0;\ndp[2][1] = 0;\ndp[2][2] = 1;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i][1] = dp[i - 1][2];\ndp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n}\nreturn dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.cpp
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\nif (n == 1 || n == 2) {\nreturn n;\n}\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nvector<vector<int>> dp(n + 1, vector<int>(3, 0));\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1][1] = 1;\ndp[1][2] = 0;\ndp[2][1] = 0;\ndp[2][2] = 1;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i][1] = dp[i - 1][2];\ndp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n}\nreturn dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.py
    def climbing_stairs_constraint_dp(n: int) -> int:\n\"\"\"\u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nif n == 1 or n == 2:\nreturn n\n# \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\ndp = [[0] * 3 for _ in range(n + 1)]\n# \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1][1], dp[1][2] = 1, 0\ndp[2][1], dp[2][2] = 0, 1\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor i in range(3, n + 1):\ndp[i][1] = dp[i - 1][2]\ndp[i][2] = dp[i - 2][1] + dp[i - 2][2]\nreturn dp[n][1] + dp[n][2]\n
    climbing_stairs_constraint_dp.go
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.js
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.ts
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.c
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.cs
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\nif (n == 1 || n == 2) {\nreturn n;\n}\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[,] dp = new int[n + 1, 3];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1, 1] = 1;\ndp[1, 2] = 0;\ndp[2, 1] = 0;\ndp[2, 2] = 1;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i, 1] = dp[i - 1, 2];\ndp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n}\nreturn dp[n, 1] + dp[n, 2];\n}\n
    climbing_stairs_constraint_dp.swift
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.zig
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.dart
    [class]{}-[func]{climbingStairsConstraintDP}\n

    \u5728\u4e0a\u9762\u7684\u6848\u4f8b\u4e2d\uff0c\u7531\u4e8e\u4ec5\u9700\u591a\u8003\u8651\u524d\u9762\u4e00\u4e2a\u72b6\u6001\uff0c\u6211\u4eec\u4ecd\u7136\u53ef\u4ee5\u901a\u8fc7\u6269\u5c55\u72b6\u6001\u5b9a\u4e49\uff0c\u4f7f\u5f97\u95ee\u9898\u6062\u590d\u65e0\u540e\u6548\u6027\u3002\u7136\u800c\uff0c\u8bb8\u591a\u95ee\u9898\u5177\u6709\u975e\u5e38\u4e25\u91cd\u7684\u201c\u6709\u540e\u6548\u6027\u201d\uff0c\u4f8b\u5982\uff1a

    \u722c\u697c\u68af\u4e0e\u969c\u788d\u751f\u6210

    \u7ed9\u5b9a\u4e00\u4e2a\u5171\u6709 \\(n\\) \u9636\u7684\u697c\u68af\uff0c\u4f60\u6bcf\u6b65\u53ef\u4ee5\u4e0a \\(1\\) \u9636\u6216\u8005 \\(2\\) \u9636\u3002\u89c4\u5b9a\u5f53\u722c\u5230\u7b2c \\(i\\) \u9636\u65f6\uff0c\u7cfb\u7edf\u81ea\u52a8\u4f1a\u7ed9\u7b2c \\(2i\\) \u9636\u4e0a\u653e\u4e0a\u969c\u788d\u7269\uff0c\u4e4b\u540e\u6240\u6709\u8f6e\u90fd\u4e0d\u5141\u8bb8\u8df3\u5230\u7b2c \\(2i\\) \u9636\u4e0a\u3002\u4f8b\u5982\uff0c\u524d\u4e24\u8f6e\u5206\u522b\u8df3\u5230\u4e86\u7b2c \\(2, 3\\) \u9636\u4e0a\uff0c\u5219\u4e4b\u540e\u5c31\u4e0d\u80fd\u8df3\u5230\u7b2c \\(4, 6\\) \u9636\u4e0a\u3002\u8bf7\u95ee\u6709\u591a\u5c11\u79cd\u65b9\u6848\u53ef\u4ee5\u722c\u5230\u697c\u9876\u3002

    \u5728\u8fd9\u4e2a\u95ee\u9898\u4e2d\uff0c\u4e0b\u6b21\u8df3\u8dc3\u4f9d\u8d56\u4e8e\u8fc7\u53bb\u6240\u6709\u7684\u72b6\u6001\uff0c\u56e0\u4e3a\u6bcf\u4e00\u6b21\u8df3\u8dc3\u90fd\u4f1a\u5728\u66f4\u9ad8\u7684\u9636\u68af\u4e0a\u8bbe\u7f6e\u969c\u788d\uff0c\u5e76\u5f71\u54cd\u672a\u6765\u7684\u8df3\u8dc3\u3002\u5bf9\u4e8e\u8fd9\u7c7b\u95ee\u9898\uff0c\u52a8\u6001\u89c4\u5212\u5f80\u5f80\u96be\u4ee5\u89e3\u51b3\uff0c\u6216\u662f\u56e0\u4e3a\u8ba1\u7b97\u590d\u6742\u5ea6\u8fc7\u9ad8\u800c\u96be\u4ee5\u5e94\u7528\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u7ec4\u5408\u4f18\u5316\u95ee\u9898\uff08\u4f8b\u5982\u8457\u540d\u7684\u65c5\u884c\u5546\u95ee\u9898\uff09\u90fd\u4e0d\u6ee1\u8db3\u65e0\u540e\u6548\u6027\u3002\u5bf9\u4e8e\u8fd9\u7c7b\u95ee\u9898\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u9009\u62e9\u4f7f\u7528\u5176\u4ed6\u65b9\u6cd5\uff0c\u4f8b\u5982\u542f\u53d1\u5f0f\u641c\u7d22\u3001\u9057\u4f20\u7b97\u6cd5\u3001\u5f3a\u5316\u5b66\u4e60\u7b49\uff0c\u4ece\u800c\u964d\u4f4e\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u5728\u6709\u9650\u65f6\u95f4\u5185\u5f97\u5230\u80fd\u591f\u63a5\u53d7\u7684\u5c40\u90e8\u6700\u4f18\u89e3\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","title":"13.3. \u00a0 \u52a8\u6001\u89c4\u5212\u89e3\u9898\u601d\u8def","text":"

    \u4e0a\u4e24\u8282\u4ecb\u7ecd\u4e86\u52a8\u6001\u89c4\u5212\u95ee\u9898\u7684\u4e3b\u8981\u7279\u5f81\uff0c\u63a5\u4e0b\u6765\u6211\u4eec\u4e00\u8d77\u63a2\u7a76\u4e24\u4e2a\u66f4\u52a0\u5b9e\u7528\u7684\u95ee\u9898\uff1a

    1. \u5982\u4f55\u5224\u65ad\u4e00\u4e2a\u95ee\u9898\u662f\u4e0d\u662f\u52a8\u6001\u89c4\u5212\u95ee\u9898\uff1f
    2. \u6c42\u89e3\u52a8\u6001\u89c4\u5212\u95ee\u9898\u8be5\u4ece\u4f55\u5904\u5165\u624b\uff0c\u5b8c\u6574\u6b65\u9aa4\u662f\u4ec0\u4e48\uff1f
    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1331","title":"13.3.1. \u00a0 \u95ee\u9898\u5224\u65ad","text":"

    \u603b\u7684\u6765\u8bf4\uff0c\u5982\u679c\u4e00\u4e2a\u95ee\u9898\u5305\u542b\u91cd\u53e0\u5b50\u95ee\u9898\u3001\u6700\u4f18\u5b50\u7ed3\u6784\uff0c\u5e76\u6ee1\u8db3\u65e0\u540e\u6548\u6027\uff0c\u90a3\u4e48\u5b83\u901a\u5e38\u5c31\u9002\u5408\u7528\u52a8\u6001\u89c4\u5212\u6c42\u89e3\uff0c\u4f46\u6211\u4eec\u5f88\u96be\u4ece\u95ee\u9898\u63cf\u8ff0\u4e0a\u76f4\u63a5\u63d0\u53d6\u51fa\u8fd9\u4e9b\u7279\u6027\u3002\u56e0\u6b64\u6211\u4eec\u901a\u5e38\u4f1a\u653e\u5bbd\u6761\u4ef6\uff0c\u5148\u89c2\u5bdf\u95ee\u9898\u662f\u5426\u9002\u5408\u4f7f\u7528\u56de\u6eaf\uff08\u7a77\u4e3e\uff09\u89e3\u51b3\u3002

    \u9002\u5408\u7528\u56de\u6eaf\u89e3\u51b3\u7684\u95ee\u9898\u901a\u5e38\u6ee1\u8db3\u201c\u51b3\u7b56\u6811\u6a21\u578b\u201d\uff0c\u8fd9\u79cd\u95ee\u9898\u53ef\u4ee5\u4f7f\u7528\u6811\u5f62\u7ed3\u6784\u6765\u63cf\u8ff0\uff0c\u5176\u4e2d\u6bcf\u4e00\u4e2a\u8282\u70b9\u4ee3\u8868\u4e00\u4e2a\u51b3\u7b56\uff0c\u6bcf\u4e00\u6761\u8def\u5f84\u4ee3\u8868\u4e00\u4e2a\u51b3\u7b56\u5e8f\u5217\u3002

    \u6362\u53e5\u8bdd\u8bf4\uff0c\u5982\u679c\u95ee\u9898\u5305\u542b\u660e\u786e\u7684\u51b3\u7b56\u6982\u5ff5\uff0c\u5e76\u4e14\u89e3\u662f\u901a\u8fc7\u4e00\u7cfb\u5217\u51b3\u7b56\u4ea7\u751f\u7684\uff0c\u90a3\u4e48\u5b83\u5c31\u6ee1\u8db3\u51b3\u7b56\u6811\u6a21\u578b\uff0c\u901a\u5e38\u53ef\u4ee5\u4f7f\u7528\u56de\u6eaf\u6765\u89e3\u51b3\u3002

    \u5728\u6b64\u57fa\u7840\u4e0a\uff0c\u8fd8\u6709\u4e00\u4e9b\u5224\u65ad\u95ee\u9898\u662f\u52a8\u6001\u89c4\u5212\u95ee\u9898\u7684\u201c\u52a0\u5206\u9879\u201d\uff0c\u5305\u62ec\uff1a

    • \u95ee\u9898\u5305\u542b\u6700\u5927\uff08\u5c0f\uff09\u6216\u6700\u591a\uff08\u5c11\uff09\u7b49\u6700\u4f18\u5316\u63cf\u8ff0\uff1b
    • \u95ee\u9898\u7684\u72b6\u6001\u80fd\u591f\u4f7f\u7528\u4e00\u4e2a\u5217\u8868\u3001\u591a\u7ef4\u77e9\u9635\u6216\u6811\u6765\u8868\u793a\uff0c\u5e76\u4e14\u4e00\u4e2a\u72b6\u6001\u4e0e\u5176\u5468\u56f4\u7684\u72b6\u6001\u5b58\u5728\u67d0\u79cd\u9012\u63a8\u5173\u7cfb\uff1b

    \u800c\u76f8\u5e94\u7684\u201c\u51cf\u5206\u9879\u201d\u5305\u62ec\uff1a

    • \u95ee\u9898\u7684\u76ee\u6807\u662f\u627e\u51fa\u6240\u6709\u53ef\u80fd\u7684\u89e3\u51b3\u65b9\u6848\uff0c\u800c\u4e0d\u662f\u627e\u51fa\u6700\u4f18\u89e3\u3002
    • \u95ee\u9898\u63cf\u8ff0\u4e2d\u6709\u660e\u663e\u7684\u6392\u5217\u7ec4\u5408\u7684\u7279\u5f81\uff0c\u9700\u8981\u8fd4\u56de\u5177\u4f53\u7684\u591a\u4e2a\u65b9\u6848\u3002

    \u5982\u679c\u4e00\u4e2a\u95ee\u9898\u6ee1\u8db3\u51b3\u7b56\u6811\u6a21\u578b\uff0c\u5e76\u5177\u6709\u8f83\u4e3a\u660e\u663e\u7684\u201c\u52a0\u5206\u9879\u201c\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5047\u8bbe\u5b83\u662f\u4e00\u4e2a\u52a8\u6001\u89c4\u5212\u95ee\u9898\uff0c\u5e76\u5c1d\u8bd5\u6c42\u89e3\u5b83\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1332","title":"13.3.2. \u00a0 \u95ee\u9898\u6c42\u89e3","text":"

    \u52a8\u6001\u89c4\u5212\u7684\u89e3\u9898\u6d41\u7a0b\u53ef\u80fd\u4f1a\u56e0\u95ee\u9898\u7684\u6027\u8d28\u548c\u96be\u5ea6\u800c\u6709\u6240\u4e0d\u540c\uff0c\u4f46\u901a\u5e38\u9075\u5faa\u4ee5\u4e0b\u6b65\u9aa4\uff1a\u63cf\u8ff0\u51b3\u7b56\uff0c\u5b9a\u4e49\u72b6\u6001\uff0c\u5efa\u7acb \\(dp\\) \u8868\uff0c\u63a8\u5bfc\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff0c\u786e\u5b9a\u8fb9\u754c\u6761\u4ef6\u7b49\u3002

    \u4e3a\u4e86\u66f4\u5f62\u8c61\u5730\u5c55\u793a\u89e3\u9898\u6b65\u9aa4\uff0c\u6211\u4eec\u4f7f\u7528\u4e00\u4e2a\u7ecf\u5178\u95ee\u9898\u300c\u6700\u5c0f\u8def\u5f84\u548c\u300d\u6765\u4e3e\u4f8b\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a \\(n \\times m\\) \u7684\u4e8c\u7ef4\u7f51\u683c grid \uff0c\u7f51\u683c\u4e2d\u7684\u6bcf\u4e2a\u5355\u5143\u683c\u5305\u542b\u4e00\u4e2a\u975e\u8d1f\u6574\u6570\uff0c\u8868\u793a\u8be5\u5355\u5143\u683c\u7684\u4ee3\u4ef7\u3002\u673a\u5668\u4eba\u4ee5\u5de6\u4e0a\u89d2\u5355\u5143\u683c\u4e3a\u8d77\u59cb\u70b9\uff0c\u6bcf\u6b21\u53ea\u80fd\u5411\u4e0b\u6216\u8005\u5411\u53f3\u79fb\u52a8\u4e00\u6b65\uff0c\u76f4\u81f3\u5230\u8fbe\u53f3\u4e0b\u89d2\u5355\u5143\u683c\u3002\u8bf7\u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230\u53f3\u4e0b\u89d2\u7684\u6700\u5c0f\u8def\u5f84\u548c\u3002

    \u4f8b\u5982\u4ee5\u4e0b\u793a\u4f8b\u6570\u636e\uff0c\u7ed9\u5b9a\u7f51\u683c\u7684\u6700\u5c0f\u8def\u5f84\u548c\u4e3a \\(13\\) \u3002

    Fig. \u6700\u5c0f\u8def\u5f84\u548c\u793a\u4f8b\u6570\u636e

    \u7b2c\u4e00\u6b65\uff1a\u601d\u8003\u6bcf\u8f6e\u7684\u51b3\u7b56\uff0c\u5b9a\u4e49\u72b6\u6001\uff0c\u4ece\u800c\u5f97\u5230 \\(dp\\) \u8868

    \u672c\u9898\u7684\u6bcf\u4e00\u8f6e\u7684\u51b3\u7b56\u5c31\u662f\u4ece\u5f53\u524d\u683c\u5b50\u5411\u4e0b\u6216\u5411\u53f3\u4e00\u6b65\u3002\u8bbe\u5f53\u524d\u683c\u5b50\u7684\u884c\u5217\u7d22\u5f15\u4e3a \\([i, j]\\) \uff0c\u5219\u5411\u4e0b\u6216\u5411\u53f3\u8d70\u4e00\u6b65\u540e\uff0c\u7d22\u5f15\u53d8\u4e3a \\([i+1, j]\\) \u6216 \\([i, j+1]\\) \u3002\u56e0\u6b64\uff0c\u72b6\u6001\u5e94\u5305\u542b\u884c\u7d22\u5f15\u548c\u5217\u7d22\u5f15\u4e24\u4e2a\u53d8\u91cf\uff0c\u8bb0\u4e3a \\([i, j]\\) \u3002

    \u72b6\u6001 \\([i, j]\\) \u5bf9\u5e94\u7684\u5b50\u95ee\u9898\u4e3a\uff1a\u4ece\u8d77\u59cb\u70b9 \\([0, 0]\\) \u8d70\u5230 \\([i, j]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c\uff0c\u89e3\u8bb0\u4e3a \\(dp[i, j]\\) \u3002

    \u81f3\u6b64\uff0c\u6211\u4eec\u5c31\u5f97\u5230\u4e86\u4e00\u4e2a\u4e8c\u7ef4 \\(dp\\) \u77e9\u9635\uff0c\u5176\u5c3a\u5bf8\u4e0e\u8f93\u5165\u7f51\u683c \\(grid\\) \u76f8\u540c\u3002

    Fig. \u72b6\u6001\u5b9a\u4e49\u4e0e dp \u8868

    Note

    \u52a8\u6001\u89c4\u5212\u548c\u56de\u6eaf\u901a\u5e38\u90fd\u4f1a\u88ab\u63cf\u8ff0\u4e3a\u4e00\u4e2a\u51b3\u7b56\u5e8f\u5217\uff0c\u800c\u72b6\u6001\u901a\u5e38\u7531\u6240\u6709\u51b3\u7b56\u53d8\u91cf\u6784\u6210\u3002\u5b83\u5e94\u5f53\u5305\u542b\u63cf\u8ff0\u89e3\u9898\u8fdb\u5ea6\u7684\u6240\u6709\u53d8\u91cf\uff0c\u5176\u5305\u542b\u4e86\u8db3\u591f\u7684\u4fe1\u606f\uff0c\u80fd\u591f\u7528\u6765\u63a8\u5bfc\u51fa\u4e0b\u4e00\u4e2a\u72b6\u6001\u3002

    \u6bcf\u4e2a\u72b6\u6001\u90fd\u5bf9\u5e94\u4e00\u4e2a\u5b50\u95ee\u9898\uff0c\u6211\u4eec\u4f1a\u5b9a\u4e49\u4e00\u4e2a \\(dp\\) \u8868\u6765\u5b58\u50a8\u6240\u6709\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u72b6\u6001\u7684\u6bcf\u4e2a\u72ec\u7acb\u53d8\u91cf\u90fd\u662f \\(dp\\) \u8868\u7684\u4e00\u4e2a\u7ef4\u5ea6\u3002\u672c\u8d28\u4e0a\u770b\uff0c\\(dp\\) \u8868\u662f\u5b50\u95ee\u9898\u7684\u89e3\u548c\u72b6\u6001\u4e4b\u95f4\u7684\u6620\u5c04\u3002

    \u7b2c\u4e8c\u6b65\uff1a\u627e\u51fa\u6700\u4f18\u5b50\u7ed3\u6784\uff0c\u8fdb\u800c\u63a8\u5bfc\u51fa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b

    \u5bf9\u4e8e\u72b6\u6001 \\([i, j]\\) \uff0c\u5b83\u53ea\u80fd\u4ece\u4e0a\u8fb9\u683c\u5b50 \\([i-1, j]\\) \u548c\u5de6\u8fb9\u683c\u5b50 \\([i, j-1]\\) \u8f6c\u79fb\u800c\u6765\u3002\u56e0\u6b64\u6700\u4f18\u5b50\u7ed3\u6784\u4e3a\uff1a\u5230\u8fbe \\([i, j]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c\u7531 \\([i, j-1]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c\u4e0e \\([i-1, j]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c\uff0c\u8fd9\u4e24\u8005\u8f83\u5c0f\u7684\u90a3\u4e00\u4e2a\u51b3\u5b9a\u3002

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u53ef\u63a8\u51fa\u4ee5\u4e0b\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff1a

    \\[ dp[i, j] = \\min(dp[i-1, j], dp[i, j-1]) + grid[i, j] \\]

    Fig. \u6700\u4f18\u5b50\u7ed3\u6784\u4e0e\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b

    Note

    \u57fa\u4e8e\u5b9a\u4e49\u597d\u7684 \\(dp\\) \u8868\uff0c\u6211\u4eec\u601d\u8003\u539f\u95ee\u9898\u548c\u5b50\u95ee\u9898\u7684\u5173\u7cfb\uff0c\u627e\u51fa\u5982\u4f55\u901a\u8fc7\u5b50\u95ee\u9898\u7684\u89e3\u6765\u6784\u9020\u539f\u95ee\u9898\u7684\u89e3\u3002

    \u6700\u4f18\u5b50\u7ed3\u6784\u63ed\u793a\u4e86\u539f\u95ee\u9898\u548c\u5b50\u95ee\u9898\u7684\u9012\u63a8\u5173\u7cfb\uff0c\u4e00\u65e6\u6211\u4eec\u627e\u5230\u4e86\u6700\u4f18\u5b50\u7ed3\u6784\uff0c\u5c31\u53ef\u4ee5\u4f7f\u7528\u5b83\u6765\u6784\u5efa\u51fa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u3002

    \u7b2c\u4e09\u6b65\uff1a\u786e\u5b9a\u8fb9\u754c\u6761\u4ef6\u548c\u72b6\u6001\u8f6c\u79fb\u987a\u5e8f

    \u5728\u672c\u9898\u4e2d\uff0c\u5f53 \\(i=0\\) \u6216 \\(j=0\\) \u65f6\u53ea\u6709\u4e00\u79cd\u53ef\u80fd\u7684\u8def\u5f84\uff0c\u5373\u53ea\u80fd\u5411\u53f3\u79fb\u52a8\u6216\u53ea\u80fd\u5411\u4e0b\u79fb\u52a8\uff0c\u56e0\u6b64\u9996\u884c\u548c\u9996\u5217\u662f\u8fb9\u754c\u6761\u4ef6\u3002

    \u6bcf\u4e2a\u683c\u5b50\u662f\u7531\u5176\u5de6\u65b9\u683c\u5b50\u548c\u4e0a\u65b9\u683c\u5b50\u8f6c\u79fb\u800c\u6765\uff0c\u56e0\u6b64\u6211\u4eec\u4f7f\u7528\u4e24\u5c42\u5faa\u73af\u6765\u904d\u5386\u77e9\u9635\u5373\u53ef\uff0c\u5373\u5916\u5faa\u73af\u6b63\u5e8f\u904d\u5386\u5404\u884c\u3001\u5185\u5faa\u73af\u6b63\u5e8f\u904d\u5386\u5404\u5217\u3002

    Fig. \u8fb9\u754c\u6761\u4ef6\u4e0e\u72b6\u6001\u8f6c\u79fb\u987a\u5e8f

    Note

    \u8fb9\u754c\u6761\u4ef6\u5373\u521d\u59cb\u72b6\u6001\uff0c\u5728\u641c\u7d22\u4e2d\u7528\u4e8e\u526a\u679d\uff0c\u5728\u52a8\u6001\u89c4\u5212\u4e2d\u7528\u4e8e\u521d\u59cb\u5316 \\(dp\\) \u8868\u3002\u72b6\u6001\u8f6c\u79fb\u987a\u5e8f\u7684\u6838\u5fc3\u662f\u8981\u4fdd\u8bc1\u5728\u8ba1\u7b97\u5f53\u524d\u95ee\u9898\u65f6\uff0c\u6240\u6709\u5b83\u4f9d\u8d56\u7684\u66f4\u5c0f\u5b50\u95ee\u9898\u90fd\u5df2\u7ecf\u88ab\u6b63\u786e\u5730\u8ba1\u7b97\u51fa\u6765\u3002

    \u6700\u540e\uff0c\u6211\u4eec\u57fa\u4e8e\u4ee5\u4e0a\u7ed3\u679c\u5b9e\u73b0\u89e3\u6cd5\u5373\u53ef\u3002\u719f\u7ec3\u5ea6\u8f83\u9ad8\u540c\u5b66\u53ef\u4ee5\u76f4\u63a5\u5199\u51fa\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\uff0c\u521d\u5b66\u8005\u53ef\u4ee5\u6309\u7167\u201c\u66b4\u529b\u641c\u7d22 \\(\\rightarrow\\) \u8bb0\u5fc6\u5316\u641c\u7d22 \\(\\rightarrow\\) \u52a8\u6001\u89c4\u5212\u201d \u7684\u987a\u5e8f\u5b9e\u73b0\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1333","title":"13.3.3. \u00a0 \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u641c\u7d22","text":"

    \u4ece\u72b6\u6001 \\([i, j]\\) \u5f00\u59cb\u641c\u7d22\uff0c\u4e0d\u65ad\u5206\u89e3\u4e3a\u66f4\u5c0f\u7684\u72b6\u6001 \\([i-1, j]\\) \u548c \\([i, j-1]\\) \uff0c\u5305\u62ec\u4ee5\u4e0b\u9012\u5f52\u8981\u7d20\uff1a

    • \u9012\u5f52\u53c2\u6570\uff1a\u72b6\u6001 \\([i, j]\\) \uff1b\u8fd4\u56de\u503c\uff1a\u4ece \\([0, 0]\\) \u5230 \\([i, j]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c \\(dp[i, j]\\) \uff1b
    • \u7ec8\u6b62\u6761\u4ef6\uff1a\u5f53 \\(i = 0\\) \u4e14 \\(j = 0\\) \u65f6\uff0c\u8fd4\u56de\u4ee3\u4ef7 \\(grid[0][0]\\) \uff1b
    • \u526a\u679d\uff1a\u5f53 \\(i < 0\\) \u65f6\u6216 \\(j < 0\\) \u65f6\u7d22\u5f15\u8d8a\u754c\uff0c\u6b64\u65f6\u8fd4\u56de\u4ee3\u4ef7 \\(+\\infty\\) \uff0c\u4ee3\u8868\u4e0d\u53ef\u884c\uff1b
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nint minPathSumDFS(int[][] grid, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0) {\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn Integer.MAX_VALUE;\n}\n// \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFS(grid, i - 1, j);\nint up = minPathSumDFS(grid, i, j - 1);\n// \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nreturn Math.min(left, up) + grid[i][j];\n}\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nint minPathSumDFS(vector<vector<int>> &grid, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0) {\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn INT_MAX;\n}\n// \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFS(grid, i - 1, j);\nint up = minPathSumDFS(grid, i, j - 1);\n// \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nreturn min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n
    min_path_sum.py
    def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -> int:\n\"\"\"\u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22\"\"\"\n# \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif i == 0 and j == 0:\nreturn grid[0][0]\n# \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif i < 0 or j < 0:\nreturn inf\n# \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nleft = min_path_sum_dfs(grid, i - 1, j)\nup = min_path_sum_dfs(grid, i, j - 1)\n# \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nreturn min(left, up) + grid[i][j]\n
    min_path_sum.go
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.js
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.ts
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.c
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nint minPathSumDFS(int[][] grid, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0){\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn int.MaxValue;\n}\n// \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFS(grid, i - 1, j);\nint up = minPathSumDFS(grid, i, j - 1);\n// \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nreturn Math.Min(left, up) + grid[i][j];\n}\n
    min_path_sum.swift
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.zig
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.dart
    [class]{}-[func]{minPathSumDFS}\n

    \u6211\u4eec\u5c1d\u8bd5\u753b\u51fa\u4ee5 \\(dp[2, 1]\\) \u4e3a\u6839\u8282\u70b9\u7684\u9012\u5f52\u6811\u3002\u89c2\u5bdf\u4e0b\u56fe\uff0c\u9012\u5f52\u6811\u5305\u542b\u4e00\u4e9b\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u5176\u6570\u91cf\u4f1a\u968f\u7740\u7f51\u683c grid \u7684\u5c3a\u5bf8\u53d8\u5927\u800c\u6025\u5267\u589e\u591a\u3002

    \u76f4\u89c2\u4e0a\u770b\uff0c\u5b58\u5728\u591a\u6761\u8def\u5f84\u53ef\u4ee5\u4ece\u5de6\u4e0a\u89d2\u5230\u8fbe\u540c\u4e00\u5355\u5143\u683c\uff0c\u8fd9\u4fbf\u662f\u8be5\u95ee\u9898\u5b58\u5728\u91cd\u53e0\u5b50\u95ee\u9898\u7684\u5185\u5728\u539f\u56e0\u3002

    Fig. \u66b4\u529b\u641c\u7d22\u9012\u5f52\u6811

    \u6bcf\u4e2a\u72b6\u6001\u90fd\u6709\u5411\u4e0b\u548c\u5411\u53f3\u4e24\u79cd\u9009\u62e9\uff0c\u4ece\u5de6\u4e0a\u89d2\u8d70\u5230\u53f3\u4e0b\u89d2\u603b\u5171\u9700\u8981 \\(m + n - 2\\) \u6b65\uff0c\u6240\u4ee5\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^{m + n})\\) \u3002\u8bf7\u6ce8\u610f\uff0c\u8fd9\u79cd\u8ba1\u7b97\u65b9\u5f0f\u672a\u8003\u8651\u4e34\u8fd1\u7f51\u683c\u8fb9\u754c\u7684\u60c5\u51b5\uff0c\u5f53\u5230\u8fbe\u7f51\u7edc\u8fb9\u754c\u65f6\u53ea\u5269\u4e0b\u4e00\u79cd\u9009\u62e9\u3002\u56e0\u6b64\u5b9e\u9645\u7684\u8def\u5f84\u6570\u91cf\u4f1a\u5c11\u4e00\u4e9b\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1334","title":"13.3.4. \u00a0 \u65b9\u6cd5\u4e8c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22","text":"

    \u4e3a\u4e86\u907f\u514d\u91cd\u590d\u8ba1\u7b97\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u6211\u4eec\u5f15\u5165\u4e00\u4e2a\u548c\u7f51\u683c grid \u76f8\u540c\u5c3a\u5bf8\u7684\u8bb0\u5fc6\u5217\u8868 mem \uff0c\u7528\u4e8e\u8bb0\u5f55\u5404\u4e2a\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u63d0\u5347\u641c\u7d22\u6548\u7387\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0) {\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn Integer.MAX_VALUE;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][j] != -1) {\nreturn mem[i][j];\n}\n// \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFSMem(grid, mem, i - 1, j);\nint up = minPathSumDFSMem(grid, mem, i, j - 1);\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nmem[i][j] = Math.min(left, up) + grid[i][j];\nreturn mem[i][j];\n}\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint minPathSumDFSMem(vector<vector<int>> &grid, vector<vector<int>> &mem, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0) {\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn INT_MAX;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][j] != -1) {\nreturn mem[i][j];\n}\n// \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFSMem(grid, mem, i - 1, j);\nint up = minPathSumDFSMem(grid, mem, i, j - 1);\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nmem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\nreturn mem[i][j];\n}\n
    min_path_sum.py
    def min_path_sum_dfs_mem(\ngrid: list[list[int]], mem: list[list[int]], i: int, j: int\n) -> int:\n\"\"\"\u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\"\"\"\n# \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif i == 0 and j == 0:\nreturn grid[0][0]\n# \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif i < 0 or j < 0:\nreturn inf\n# \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif mem[i][j] != -1:\nreturn mem[i][j]\n# \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nleft = min_path_sum_dfs_mem(grid, mem, i - 1, j)\nup = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n# \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nmem[i][j] = min(left, up) + grid[i][j]\nreturn mem[i][j]\n
    min_path_sum.go
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.js
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.ts
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.c
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0) {\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn int.MaxValue;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][j] != -1) {\nreturn mem[i][j];\n}\n// \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFSMem(grid, mem, i - 1, j);\nint up = minPathSumDFSMem(grid, mem, i, j - 1);\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nmem[i][j] = Math.Min(left, up) + grid[i][j];\nreturn mem[i][j];\n}\n
    min_path_sum.swift
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.zig
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.dart
    [class]{}-[func]{minPathSumDFSMem}\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5f15\u5165\u8bb0\u5fc6\u5316\u53ef\u4ee5\u6d88\u9664\u6240\u6709\u91cd\u590d\u8ba1\u7b97\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u72b6\u6001\u603b\u6570\uff0c\u5373\u7f51\u683c\u5c3a\u5bf8 \\(O(nm)\\) \u3002

    Fig. \u8bb0\u5fc6\u5316\u641c\u7d22\u9012\u5f52\u6811

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1335","title":"13.3.5. \u00a0 \u65b9\u6cd5\u4e09\uff1a\u52a8\u6001\u89c4\u5212","text":"

    \u52a8\u6001\u89c4\u5212\u4ee3\u7801\u662f\u4ece\u5e95\u81f3\u9876\u7684\uff0c\u4ec5\u9700\u5faa\u73af\u5373\u53ef\u5b9e\u73b0\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(int[][] grid) {\nint n = grid.length, m = grid[0].length;\n// \u521d\u59cb\u5316 dp \u8868\nint[][] dp = new int[n][m];\ndp[0][0] = grid[0][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\nfor (int j = 1; j < m; j++) {\ndp[0][j] = dp[0][j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\nfor (int i = 1; i < n; i++) {\ndp[i][0] = dp[i - 1][0] + grid[i][0];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u5217\nfor (int i = 1; i < n; i++) {\nfor (int j = 1; j < m; j++) {\ndp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n}\n}\nreturn dp[n - 1][m - 1];\n}\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(vector<vector<int>> &grid) {\nint n = grid.size(), m = grid[0].size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<vector<int>> dp(n, vector<int>(m));\ndp[0][0] = grid[0][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\nfor (int j = 1; j < m; j++) {\ndp[0][j] = dp[0][j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\nfor (int i = 1; i < n; i++) {\ndp[i][0] = dp[i - 1][0] + grid[i][0];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u5217\nfor (int i = 1; i < n; i++) {\nfor (int j = 1; j < m; j++) {\ndp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n}\n}\nreturn dp[n - 1][m - 1];\n}\n
    min_path_sum.py
    def min_path_sum_dp(grid: list[list[int]]) -> int:\n\"\"\"\u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nn, m = len(grid), len(grid[0])\n# \u521d\u59cb\u5316 dp \u8868\ndp = [[0] * m for _ in range(n)]\ndp[0][0] = grid[0][0]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\nfor j in range(1, m):\ndp[0][j] = dp[0][j - 1] + grid[0][j]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\nfor i in range(1, n):\ndp[i][0] = dp[i - 1][0] + grid[i][0]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u5217\nfor i in range(1, n):\nfor j in range(1, m):\ndp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\nreturn dp[n - 1][m - 1]\n
    min_path_sum.go
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.js
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.ts
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.c
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(int[][] grid) {\nint n = grid.Length, m = grid[0].Length;\n// \u521d\u59cb\u5316 dp \u8868\nint[,] dp = new int[n, m];\ndp[0, 0] = grid[0][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\nfor (int j = 1; j < m; j++) {\ndp[0, j] = dp[0, j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\nfor (int i = 1; i < n; i++) {\ndp[i, 0] = dp[i - 1, 0] + grid[i][0];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u5217\nfor (int i = 1; i < n; i++) {\nfor (int j = 1; j < m; j++) {\ndp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n}\n}\nreturn dp[n - 1, m - 1];\n}\n
    min_path_sum.swift
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.zig
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.dart
    [class]{}-[func]{minPathSumDP}\n

    \u4e0b\u56fe\u5c55\u793a\u4e86\u6700\u5c0f\u8def\u5f84\u548c\u7684\u72b6\u6001\u8f6c\u79fb\u8fc7\u7a0b\u3002\u8be5\u8fc7\u7a0b\u904d\u5386\u4e86\u6574\u4e2a\u7f51\u683c\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(nm)\\) \uff1b\u6570\u7ec4 dp \u4f7f\u7528 \\(O(nm)\\) \u7a7a\u95f4\u3002

    <1><2><3><4><5><6><7><8><9><10><11><12>

    \u5982\u679c\u5e0c\u671b\u8fdb\u4e00\u6b65\u8282\u7701\u7a7a\u95f4\u4f7f\u7528\uff0c\u53ef\u4ee5\u8003\u8651\u8fdb\u884c\u72b6\u6001\u538b\u7f29\u3002\u6bcf\u4e2a\u683c\u5b50\u53ea\u4e0e\u5de6\u8fb9\u548c\u4e0a\u8fb9\u7684\u683c\u5b50\u6709\u5173\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u53ea\u7528\u4e00\u4e2a\u5355\u884c\u6570\u7ec4\u6765\u5b9e\u73b0 \\(dp\\) \u8868\u3002

    \u7531\u4e8e\u6570\u7ec4 dp \u53ea\u80fd\u8868\u793a\u4e00\u884c\u7684\u72b6\u6001\uff0c\u56e0\u6b64\u6211\u4eec\u65e0\u6cd5\u63d0\u524d\u521d\u59cb\u5316\u9996\u5217\u72b6\u6001\uff0c\u800c\u662f\u5728\u904d\u5386\u6bcf\u884c\u4e2d\u66f4\u65b0\u5b83\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(int[][] grid) {\nint n = grid.length, m = grid[0].length;\n// \u521d\u59cb\u5316 dp \u8868\nint[] dp = new int[m];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\ndp[0] = grid[0][0];\nfor (int j = 1; j < m; j++) {\ndp[j] = dp[j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\nfor (int i = 1; i < n; i++) {\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\ndp[0] = dp[0] + grid[i][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\nfor (int j = 1; j < m; j++) {\ndp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n}\n}\nreturn dp[m - 1];\n}\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(vector<vector<int>> &grid) {\nint n = grid.size(), m = grid[0].size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<int> dp(m);\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\ndp[0] = grid[0][0];\nfor (int j = 1; j < m; j++) {\ndp[j] = dp[j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\nfor (int i = 1; i < n; i++) {\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\ndp[0] = dp[0] + grid[i][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\nfor (int j = 1; j < m; j++) {\ndp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n}\n}\nreturn dp[m - 1];\n}\n
    min_path_sum.py
    def min_path_sum_dp_comp(grid: list[list[int]]) -> int:\n\"\"\"\u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\nn, m = len(grid), len(grid[0])\n# \u521d\u59cb\u5316 dp \u8868\ndp = [0] * m\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\ndp[0] = grid[0][0]\nfor j in range(1, m):\ndp[j] = dp[j - 1] + grid[0][j]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\nfor i in range(1, n):\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\ndp[0] = dp[0] + grid[i][0]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\nfor j in range(1, m):\ndp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\nreturn dp[m - 1]\n
    min_path_sum.go
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.js
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.ts
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.c
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(int[][] grid) {\nint n = grid.Length, m = grid[0].Length;\n// \u521d\u59cb\u5316 dp \u8868\nint[] dp = new int[m];\ndp[0] = grid[0][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\nfor (int j = 1; j < m; j++) {\ndp[j] = dp[j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\nfor (int i = 1; i < n; i++) {\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\ndp[0] = dp[0] + grid[i][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\nfor (int j = 1; j < m; j++) {\ndp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n}\n}\nreturn dp[m - 1];\n}\n
    min_path_sum.swift
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.zig
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.dart
    [class]{}-[func]{minPathSumDPComp}\n
    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","title":"13.1. \u00a0 \u521d\u63a2\u52a8\u6001\u89c4\u5212","text":"

    \u300c\u52a8\u6001\u89c4\u5212 Dynamic Programming\u300d\u662f\u4e00\u79cd\u901a\u8fc7\u5c06\u590d\u6742\u95ee\u9898\u5206\u89e3\u4e3a\u66f4\u7b80\u5355\u7684\u5b50\u95ee\u9898\u7684\u65b9\u5f0f\u6765\u6c42\u89e3\u95ee\u9898\u7684\u65b9\u6cd5\u3002\u5b83\u5c06\u4e00\u4e2a\u95ee\u9898\u5206\u89e3\u4e3a\u4e00\u7cfb\u5217\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\uff0c\u5e76\u901a\u8fc7\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\u6765\u907f\u514d\u91cd\u590d\u8ba1\u7b97\uff0c\u4ece\u800c\u5927\u5e45\u63d0\u5347\u65f6\u95f4\u6548\u7387\u3002

    \u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u4ece\u4e00\u4e2a\u7ecf\u5178\u4f8b\u9898\u5165\u624b\uff0c\u5148\u7ed9\u51fa\u5b83\u7684\u66b4\u529b\u56de\u6eaf\u89e3\u6cd5\uff0c\u89c2\u5bdf\u5176\u4e2d\u5305\u542b\u7684\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u518d\u9010\u6b65\u5bfc\u51fa\u66f4\u9ad8\u6548\u7684\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\u3002

    \u722c\u697c\u68af

    \u7ed9\u5b9a\u4e00\u4e2a\u5171\u6709 \\(n\\) \u9636\u7684\u697c\u68af\uff0c\u4f60\u6bcf\u6b65\u53ef\u4ee5\u4e0a \\(1\\) \u9636\u6216\u8005 \\(2\\) \u9636\uff0c\u8bf7\u95ee\u6709\u591a\u5c11\u79cd\u65b9\u6848\u53ef\u4ee5\u722c\u5230\u697c\u9876\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5bf9\u4e8e\u4e00\u4e2a \\(3\\) \u9636\u697c\u68af\uff0c\u5171\u6709 \\(3\\) \u79cd\u65b9\u6848\u53ef\u4ee5\u722c\u5230\u697c\u9876\u3002

    Fig. \u722c\u5230\u7b2c 3 \u9636\u7684\u65b9\u6848\u6570\u91cf

    \u672c\u9898\u7684\u76ee\u6807\u662f\u6c42\u89e3\u65b9\u6848\u6570\u91cf\uff0c\u6211\u4eec\u53ef\u4ee5\u8003\u8651\u901a\u8fc7\u56de\u6eaf\u6765\u7a77\u4e3e\u6240\u6709\u53ef\u80fd\u6027\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u5c06\u722c\u697c\u68af\u60f3\u8c61\u4e3a\u4e00\u4e2a\u591a\u8f6e\u9009\u62e9\u7684\u8fc7\u7a0b\uff1a\u4ece\u5730\u9762\u51fa\u53d1\uff0c\u6bcf\u8f6e\u9009\u62e9\u4e0a \\(1\\) \u9636\u6216 \\(2\\) \u9636\uff0c\u6bcf\u5f53\u5230\u8fbe\u697c\u68af\u9876\u90e8\u65f6\u5c31\u5c06\u65b9\u6848\u6570\u91cf\u52a0 \\(1\\) \uff0c\u5f53\u8d8a\u8fc7\u697c\u68af\u9876\u90e8\u65f6\u5c31\u5c06\u5176\u526a\u679d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_backtrack.java
    /* \u56de\u6eaf */\nvoid backtrack(List<Integer> choices, int state, int n, List<Integer> res) {\n// \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\nif (state == n)\nres.set(0, res.get(0) + 1);\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (Integer choice : choices) {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\nif (state + choice > n)\nbreak;\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nbacktrack(choices, state + choice, n, res);\n// \u56de\u9000\n}\n}\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\nList<Integer> choices = Arrays.asList(1, 2); // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u6216 2 \u9636\nint state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\nList<Integer> res = new ArrayList<>();\nres.add(0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\nbacktrack(choices, state, n, res);\nreturn res.get(0);\n}\n
    climbing_stairs_backtrack.cpp
    /* \u56de\u6eaf */\nvoid backtrack(vector<int> &choices, int state, int n, vector<int> &res) {\n// \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\nif (state == n)\nres[0]++;\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (auto &choice : choices) {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\nif (state + choice > n)\nbreak;\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nbacktrack(choices, state + choice, n, res);\n// \u56de\u9000\n}\n}\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\nvector<int> choices = {1, 2}; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u6216 2 \u9636\nint state = 0;                // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\nvector<int> res = {0};        // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\nbacktrack(choices, state, n, res);\nreturn res[0];\n}\n
    climbing_stairs_backtrack.py
    def backtrack(choices: list[int], state: int, n: int, res: list[int]) -> int:\n\"\"\"\u56de\u6eaf\"\"\"\n# \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\nif state == n:\nres[0] += 1\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nfor choice in choices:\n# \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\nif state + choice > n:\nbreak\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nbacktrack(choices, state + choice, n, res)\n# \u56de\u9000\ndef climbing_stairs_backtrack(n: int) -> int:\n\"\"\"\u722c\u697c\u68af\uff1a\u56de\u6eaf\"\"\"\nchoices = [1, 2]  # \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u6216 2 \u9636\nstate = 0  # \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\nres = [0]  # \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\nbacktrack(choices, state, n, res)\nreturn res[0]\n
    climbing_stairs_backtrack.go
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.js
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.ts
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.cs
    /* \u56de\u6eaf */\nvoid backtrack(List<int> choices, int state, int n, List<int> res) {\n// \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\nif (state == n)\nres[0]++;\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nforeach (int choice in choices) {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\nif (state + choice > n)\nbreak;\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nbacktrack(choices, state + choice, n, res);\n// \u56de\u9000\n}\n}\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\nList<int> choices = new List<int> { 1, 2 }; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u6216 2 \u9636\nint state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\nList<int> res = new List<int> { 0 }; // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\nbacktrack(choices, state, n, res);\nreturn res[0];\n}\n
    climbing_stairs_backtrack.swift
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1311","title":"13.1.1. \u00a0 \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u641c\u7d22","text":"

    \u56de\u6eaf\u7b97\u6cd5\u901a\u5e38\u5e76\u4e0d\u663e\u5f0f\u5730\u5bf9\u95ee\u9898\u8fdb\u884c\u62c6\u89e3\uff0c\u800c\u662f\u5c06\u95ee\u9898\u770b\u4f5c\u4e00\u7cfb\u5217\u51b3\u7b56\u6b65\u9aa4\uff0c\u901a\u8fc7\u8bd5\u63a2\u548c\u526a\u679d\uff0c\u641c\u7d22\u6240\u6709\u53ef\u80fd\u7684\u89e3\u3002

    \u5bf9\u4e8e\u672c\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u5c1d\u8bd5\u5c06\u95ee\u9898\u62c6\u89e3\u4e3a\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\u3002\u8bbe\u722c\u5230\u7b2c \\(i\\) \u9636\u5171\u6709 \\(dp[i]\\) \u79cd\u65b9\u6848\uff0c\u90a3\u4e48 \\(dp[i]\\) \u5c31\u662f\u539f\u95ee\u9898\uff0c\u5176\u5b50\u95ee\u9898\u5305\u62ec:

    \\[ dp[i-1] , dp[i-2] , \\cdots , dp[2] , dp[1] \\]

    \u7531\u4e8e\u6bcf\u8f6e\u53ea\u80fd\u4e0a \\(1\\) \u9636\u6216 \\(2\\) \u9636\uff0c\u56e0\u6b64\u5f53\u6211\u4eec\u7ad9\u5728\u7b2c \\(i\\) \u9636\u697c\u68af\u4e0a\u65f6\uff0c\u4e0a\u4e00\u8f6e\u53ea\u53ef\u80fd\u7ad9\u5728\u7b2c \\(i - 1\\) \u9636\u6216\u7b2c \\(i - 2\\) \u9636\u4e0a\uff0c\u6362\u53e5\u8bdd\u8bf4\uff0c\u6211\u4eec\u53ea\u80fd\u4ece\u7b2c \\(i -1\\) \u9636\u6216\u7b2c \\(i - 2\\) \u9636\u524d\u5f80\u7b2c \\(i\\) \u9636\u3002\u56e0\u6b64\uff0c\u722c\u5230\u7b2c \\(i - 1\\) \u9636\u7684\u65b9\u6848\u6570\u52a0\u4e0a\u722c\u5230\u7b2c \\(i - 2\\) \u9636\u7684\u65b9\u6848\u6570\u5c31\u7b49\u4e8e\u722c\u5230\u7b2c \\(i\\) \u9636\u7684\u65b9\u6848\u6570\uff0c\u5373\uff1a

    \\[ dp[i] = dp[i-1] + dp[i-2] \\]

    Fig. \u65b9\u6848\u6570\u91cf\u9012\u63a8\u5173\u7cfb

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u5728\u722c\u697c\u68af\u95ee\u9898\u4e2d\uff0c\u5404\u4e2a\u5b50\u95ee\u9898\u4e4b\u95f4\u4e0d\u662f\u76f8\u4e92\u72ec\u7acb\u7684\uff0c\u539f\u95ee\u9898\u7684\u89e3\u53ef\u4ee5\u7531\u5b50\u95ee\u9898\u7684\u89e3\u6784\u6210\u3002

    \u6211\u4eec\u53ef\u4ee5\u57fa\u4e8e\u6b64\u9012\u63a8\u516c\u5f0f\u5199\u51fa\u66b4\u529b\u641c\u7d22\u4ee3\u7801\uff1a\u4ee5 \\(dp[n]\\) \u4e3a\u8d77\u59cb\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u5730\u5c06\u4e00\u4e2a\u8f83\u5927\u95ee\u9898\u62c6\u89e3\u4e3a\u4e24\u4e2a\u8f83\u5c0f\u95ee\u9898\u7684\u548c\uff0c\u76f4\u81f3\u5230\u8fbe\u6700\u5c0f\u5b50\u95ee\u9898 \\(dp[1]\\) \u548c \\(dp[2]\\) \u65f6\u8fd4\u56de\u3002\u5176\u4e2d\uff0c\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3 \\(dp[1] = 1\\) , \\(dp[2] = 2\\) \u662f\u5df2\u77e5\u7684\uff0c\u4ee3\u8868\u722c\u5230\u7b2c \\(1\\) , \\(2\\) \u9636\u5206\u522b\u6709 \\(1\\) , \\(2\\) \u79cd\u65b9\u6848\u3002

    \u89c2\u5bdf\u4ee5\u4e0b\u4ee3\u7801\uff0c\u5b83\u548c\u6807\u51c6\u56de\u6eaf\u4ee3\u7801\u90fd\u5c5e\u4e8e\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\uff0c\u4f46\u66f4\u52a0\u7b80\u6d01\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_dfs.java
    /* \u641c\u7d22 */\nint dfs(int i) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1) + dfs(i - 2);\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\nreturn dfs(n);\n}\n
    climbing_stairs_dfs.cpp
    /* \u641c\u7d22 */\nint dfs(int i) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1) + dfs(i - 2);\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\nreturn dfs(n);\n}\n
    climbing_stairs_dfs.py
    def dfs(i: int) -> int:\n\"\"\"\u641c\u7d22\"\"\"\n# \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif i == 1 or i == 2:\nreturn i\n# dp[i] = dp[i-1] + dp[i-2]\ncount = dfs(i - 1) + dfs(i - 2)\nreturn count\ndef climbing_stairs_dfs(n: int) -> int:\n\"\"\"\u722c\u697c\u68af\uff1a\u641c\u7d22\"\"\"\nreturn dfs(n)\n
    climbing_stairs_dfs.go
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.js
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.ts
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.c
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.cs
    /* \u641c\u7d22 */\nint dfs(int i) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1) + dfs(i - 2);\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\nreturn dfs(n);\n}\n
    climbing_stairs_dfs.swift
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.zig
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.dart
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n

    \u4e0b\u56fe\u5c55\u793a\u4e86\u66b4\u529b\u641c\u7d22\u5f62\u6210\u7684\u9012\u5f52\u6811\u3002\u5bf9\u4e8e\u95ee\u9898 \\(dp[n]\\) \uff0c\u5176\u9012\u5f52\u6811\u7684\u6df1\u5ea6\u4e3a \\(n\\) \uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \u3002\u6307\u6570\u9636\u7684\u8fd0\u884c\u65f6\u95f4\u589e\u957f\u5730\u975e\u5e38\u5feb\uff0c\u5982\u679c\u6211\u4eec\u8f93\u5165\u4e00\u4e2a\u6bd4\u8f83\u5927\u7684 \\(n\\) \uff0c\u5219\u4f1a\u9677\u5165\u6f2b\u957f\u7684\u7b49\u5f85\u4e4b\u4e2d\u3002

    Fig. \u722c\u697c\u68af\u5bf9\u5e94\u9012\u5f52\u6811

    \u5b9e\u9645\u4e0a\uff0c\u6307\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f\u7531\u4e8e\u300c\u91cd\u53e0\u5b50\u95ee\u9898\u300d\u5bfc\u81f4\u7684\u3002\u4f8b\u5982\uff0c\u95ee\u9898 \\(dp[9]\\) \u88ab\u5206\u89e3\u4e3a\u5b50\u95ee\u9898 \\(dp[8]\\) \u548c \\(dp[7]\\) \uff0c\u95ee\u9898 \\(dp[8]\\) \u88ab\u5206\u89e3\u4e3a\u5b50\u95ee\u9898 \\(dp[7]\\) \u548c \\(dp[6]\\) \uff0c\u4e24\u8005\u90fd\u5305\u542b\u5b50\u95ee\u9898 \\(dp[7]\\) \uff0c\u800c\u5b50\u95ee\u9898\u4e2d\u53c8\u5305\u542b\u66f4\u5c0f\u7684\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u5b50\u5b50\u5b59\u5b59\u65e0\u7a77\u5c3d\u4e5f\uff0c\u7edd\u5927\u90e8\u5206\u8ba1\u7b97\u8d44\u6e90\u90fd\u6d6a\u8d39\u5728\u8fd9\u4e9b\u91cd\u53e0\u7684\u95ee\u9898\u4e0a\u3002

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1312","title":"13.1.2. \u00a0 \u65b9\u6cd5\u4e8c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22","text":"

    \u4e3a\u4e86\u63d0\u5347\u7b97\u6cd5\u6548\u7387\uff0c\u6211\u4eec\u5e0c\u671b\u6240\u6709\u7684\u91cd\u53e0\u5b50\u95ee\u9898\u90fd\u53ea\u88ab\u8ba1\u7b97\u4e00\u6b21\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u8003\u8651\u501f\u52a9\u4e00\u4e2a\u6570\u7ec4 mem \u6765\u8bb0\u5f55\u6bcf\u4e2a\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u5e76\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u8fd9\u6837\u505a\uff1a

    • \u5f53\u9996\u6b21\u8ba1\u7b97 \\(dp[i]\\) \u65f6\uff0c\u6211\u4eec\u5c06\u5176\u8bb0\u5f55\u81f3 mem[i] \uff0c\u4ee5\u4fbf\u4e4b\u540e\u4f7f\u7528\uff1b
    • \u5f53\u518d\u6b21\u9700\u8981\u8ba1\u7b97 \\(dp[i]\\) \u65f6\uff0c\u6211\u4eec\u4fbf\u53ef\u76f4\u63a5\u4ece mem[i] \u4e2d\u83b7\u53d6\u7ed3\u679c\uff0c\u4ece\u800c\u5c06\u91cd\u53e0\u5b50\u95ee\u9898\u526a\u679d\uff1b
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_dfs_mem.java
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nint dfs(int i, int[] mem) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\nif (mem[i] != -1)\nreturn mem[i];\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1, mem) + dfs(i - 2, mem);\n// \u8bb0\u5f55 dp[i]\nmem[i] = count;\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint climbingStairsDFSMem(int n) {\n// mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\nint[] mem = new int[n + 1];\nArrays.fill(mem, -1);\nreturn dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.cpp
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nint dfs(int i, vector<int> &mem) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\nif (mem[i] != -1)\nreturn mem[i];\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1, mem) + dfs(i - 2, mem);\n// \u8bb0\u5f55 dp[i]\nmem[i] = count;\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint climbingStairsDFSMem(int n) {\n// mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\nvector<int> mem(n + 1, -1);\nreturn dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.py
    def dfs(i: int, mem: list[int]) -> int:\n\"\"\"\u8bb0\u5fc6\u5316\u641c\u7d22\"\"\"\n# \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif i == 1 or i == 2:\nreturn i\n# \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\nif mem[i] != -1:\nreturn mem[i]\n# dp[i] = dp[i-1] + dp[i-2]\ncount = dfs(i - 1, mem) + dfs(i - 2, mem)\n# \u8bb0\u5f55 dp[i]\nmem[i] = count\nreturn count\ndef climbing_stairs_dfs_mem(n: int) -> int:\n\"\"\"\u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\"\"\"\n# mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\nmem = [-1] * (n + 1)\nreturn dfs(n, mem)\n
    climbing_stairs_dfs_mem.go
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.js
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.ts
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.c
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.cs
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nint dfs(int i, int[] mem) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\nif (mem[i] != -1)\nreturn mem[i];\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1, mem) + dfs(i - 2, mem);\n// \u8bb0\u5f55 dp[i]\nmem[i] = count;\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint climbingStairsDFSMem(int n) {\n// mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\nint[] mem = new int[n + 1];\nArray.Fill(mem, -1);\nreturn dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.swift
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.zig
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.dart
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n

    \u89c2\u5bdf\u4e0b\u56fe\uff0c\u7ecf\u8fc7\u8bb0\u5fc6\u5316\u5904\u7406\u540e\uff0c\u6240\u6709\u91cd\u53e0\u5b50\u95ee\u9898\u90fd\u53ea\u9700\u88ab\u8ba1\u7b97\u4e00\u6b21\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u88ab\u4f18\u5316\u81f3 \\(O(n)\\) \uff0c\u8fd9\u662f\u4e00\u4e2a\u5de8\u5927\u7684\u98de\u8dc3\u3002\u5b9e\u9645\u4e0a\uff0c\u5982\u679c\u4e0d\u8003\u8651\u9012\u5f52\u5e26\u6765\u7684\u989d\u5916\u5f00\u9500\uff0c\u8bb0\u5fc6\u5316\u641c\u7d22\u89e3\u6cd5\u5df2\u7ecf\u51e0\u4e4e\u7b49\u540c\u4e8e\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\u7684\u65f6\u95f4\u6548\u7387\u3002

    Fig. \u8bb0\u5fc6\u5316\u641c\u7d22\u5bf9\u5e94\u9012\u5f52\u6811

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1313","title":"13.1.3. \u00a0 \u65b9\u6cd5\u4e09\uff1a\u52a8\u6001\u89c4\u5212","text":"

    \u8bb0\u5fc6\u5316\u641c\u7d22\u662f\u4e00\u79cd\u201c\u4ece\u9876\u81f3\u5e95\u201d\u7684\u65b9\u6cd5\uff1a\u6211\u4eec\u4ece\u539f\u95ee\u9898\uff08\u6839\u8282\u70b9\uff09\u5f00\u59cb\uff0c\u9012\u5f52\u5730\u5c06\u8f83\u5927\u5b50\u95ee\u9898\u5206\u89e3\u4e3a\u8f83\u5c0f\u5b50\u95ee\u9898\uff0c\u76f4\u81f3\u89e3\u5df2\u77e5\u7684\u6700\u5c0f\u5b50\u95ee\u9898\uff08\u53f6\u8282\u70b9\uff09\uff1b\u6700\u7ec8\u901a\u8fc7\u56de\u6eaf\u5c06\u5b50\u95ee\u9898\u7684\u89e3\u9010\u5c42\u6536\u96c6\uff0c\u5f97\u5230\u539f\u95ee\u9898\u7684\u89e3\u3002

    \u6211\u4eec\u4e5f\u53ef\u4ee5\u76f4\u63a5\u201c\u4ece\u5e95\u81f3\u9876\u201d\u8fdb\u884c\u6c42\u89e3\uff0c\u5f97\u5230\u6807\u51c6\u7684\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\uff1a\u4ece\u6700\u5c0f\u5b50\u95ee\u9898\u5f00\u59cb\uff0c\u8fed\u4ee3\u5730\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\uff0c\u76f4\u81f3\u5f97\u5230\u539f\u95ee\u9898\u7684\u89e3\u3002

    \u7531\u4e8e\u52a8\u6001\u89c4\u5212\u4e0d\u5305\u542b\u56de\u6eaf\u8fc7\u7a0b\uff0c\u56e0\u6b64\u65e0\u9700\u4f7f\u7528\u9012\u5f52\uff0c\u800c\u53ef\u4ee5\u76f4\u63a5\u57fa\u4e8e\u9012\u63a8\u5b9e\u73b0\u3002\u6211\u4eec\u521d\u59cb\u5316\u4e00\u4e2a\u6570\u7ec4 dp \u6765\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u4ece\u6700\u5c0f\u5b50\u95ee\u9898\u5f00\u59cb\uff0c\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\u3002\u5728\u4ee5\u4e0b\u4ee3\u7801\u4e2d\uff0c\u6570\u7ec4 dp \u8d77\u5230\u4e86\u8bb0\u5fc6\u5316\u641c\u7d22\u4e2d\u6570\u7ec4 mem \u76f8\u540c\u7684\u8bb0\u5f55\u4f5c\u7528\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_dp.java
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\nif (n == 1 || n == 2)\nreturn n;\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[] dp = new int[n + 1];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = 1;\ndp[2] = 2;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = dp[i - 1] + dp[i - 2];\n}\nreturn dp[n];\n}\n
    climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\nif (n == 1 || n == 2)\nreturn n;\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nvector<int> dp(n + 1);\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = 1;\ndp[2] = 2;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = dp[i - 1] + dp[i - 2];\n}\nreturn dp[n];\n}\n
    climbing_stairs_dp.py
    def climbing_stairs_dp(n: int) -> int:\n\"\"\"\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nif n == 1 or n == 2:\nreturn n\n# \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\ndp = [0] * (n + 1)\n# \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1], dp[2] = 1, 2\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor i in range(3, n + 1):\ndp[i] = dp[i - 1] + dp[i - 2]\nreturn dp[n]\n
    climbing_stairs_dp.go
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.js
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.ts
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.c
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\nif (n == 1 || n == 2)\nreturn n;\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[] dp = new int[n + 1];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = 1;\ndp[2] = 2;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = dp[i - 1] + dp[i - 2];\n}\nreturn dp[n];\n}\n
    climbing_stairs_dp.swift
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.zig
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.dart
    [class]{}-[func]{climbingStairsDP}\n

    \u4e0e\u56de\u6eaf\u7b97\u6cd5\u4e00\u6837\uff0c\u52a8\u6001\u89c4\u5212\u4e5f\u4f7f\u7528\u201c\u72b6\u6001\u201d\u6982\u5ff5\u6765\u8868\u793a\u95ee\u9898\u6c42\u89e3\u7684\u67d0\u4e2a\u7279\u5b9a\u9636\u6bb5\uff0c\u6bcf\u4e2a\u72b6\u6001\u90fd\u5bf9\u5e94\u4e00\u4e2a\u5b50\u95ee\u9898\u4ee5\u53ca\u76f8\u5e94\u7684\u5c40\u90e8\u6700\u4f18\u89e3\u3002\u4f8b\u5982\u5bf9\u4e8e\u722c\u697c\u68af\u95ee\u9898\uff0c\u72b6\u6001\u5b9a\u4e49\u4e3a\u5f53\u524d\u6240\u5728\u697c\u68af\u9636\u6570 \\(i\\) \u3002\u52a8\u6001\u89c4\u5212\u7684\u5e38\u7528\u672f\u8bed\u5305\u62ec\uff1a

    • \u5c06\u6570\u7ec4 dp \u79f0\u4e3a\u300c\\(dp\\) \u8868\u300d\uff0c\\(dp[i]\\) \u8868\u793a\u72b6\u6001 \\(i\\) \u5bf9\u5e94\u5b50\u95ee\u9898\u7684\u89e3\uff1b
    • \u5c06\u6700\u5c0f\u5b50\u95ee\u9898\u5bf9\u5e94\u7684\u72b6\u6001\uff08\u5373\u7b2c \\(1\\) , \\(2\\) \u9636\u697c\u68af\uff09\u79f0\u4e3a\u300c\u521d\u59cb\u72b6\u6001\u300d\uff1b
    • \u5c06\u9012\u63a8\u516c\u5f0f \\(dp[i] = dp[i-1] + dp[i-2]\\) \u79f0\u4e3a\u300c\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u300d\uff1b

    Fig. \u722c\u697c\u68af\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \u7ec6\u5fc3\u7684\u4f60\u53ef\u80fd\u53d1\u73b0\uff0c\u7531\u4e8e \\(dp[i]\\) \u53ea\u4e0e \\(dp[i-1]\\) \u548c \\(dp[i-2]\\) \u6709\u5173\uff0c\u56e0\u6b64\u6211\u4eec\u65e0\u9700\u4f7f\u7528\u4e00\u4e2a\u6570\u7ec4 dp \u6765\u5b58\u50a8\u6240\u6709\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u800c\u53ea\u9700\u4e24\u4e2a\u53d8\u91cf\u6eda\u52a8\u524d\u8fdb\u5373\u53ef\u3002\u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u7531\u4e8e\u7701\u53bb\u4e86\u6570\u7ec4 dp \u5360\u7528\u7684\u7a7a\u95f4\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n)\\) \u964d\u4f4e\u81f3 \\(O(1)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_dp.java
    /* \u722c\u697c\u68af\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\nif (n == 1 || n == 2)\nreturn n;\nint a = 1, b = 2;\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = a + b;\na = tmp;\n}\nreturn b;\n}\n
    climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\nif (n == 1 || n == 2)\nreturn n;\nint a = 1, b = 2;\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = a + b;\na = tmp;\n}\nreturn b;\n}\n
    climbing_stairs_dp.py
    def climbing_stairs_dp_comp(n: int) -> int:\n\"\"\"\u722c\u697c\u68af\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\nif n == 1 or n == 2:\nreturn n\na, b = 1, 2\nfor _ in range(3, n + 1):\na, b = b, a + b\nreturn b\n
    climbing_stairs_dp.go
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.js
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.ts
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.c
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\nif (n == 1 || n == 2)\nreturn n;\nint a = 1, b = 2;\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = a + b;\na = tmp;\n}\nreturn b;\n}\n
    climbing_stairs_dp.swift
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.zig
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.dart
    [class]{}-[func]{climbingStairsDPComp}\n

    \u6211\u4eec\u5c06\u8fd9\u79cd\u7a7a\u95f4\u4f18\u5316\u6280\u5de7\u79f0\u4e3a\u300c\u72b6\u6001\u538b\u7f29\u300d\u3002\u5728\u8bb8\u591a\u52a8\u6001\u89c4\u5212\u95ee\u9898\u4e2d\uff0c\u5f53\u524d\u72b6\u6001\u4ec5\u4e0e\u524d\u9762\u6709\u9650\u4e2a\u72b6\u6001\u6709\u5173\uff0c\u4e0d\u5fc5\u4fdd\u5b58\u6240\u6709\u7684\u5386\u53f2\u72b6\u6001\uff0c\u8fd9\u65f6\u6211\u4eec\u53ef\u4ee5\u5e94\u7528\u72b6\u6001\u538b\u7f29\uff0c\u53ea\u4fdd\u7559\u5fc5\u8981\u7684\u72b6\u6001\uff0c\u901a\u8fc7\u201c\u964d\u7ef4\u201d\u6765\u8282\u7701\u5185\u5b58\u7a7a\u95f4\u3002

    \u603b\u7684\u770b\u6765\uff0c\u5b50\u95ee\u9898\u5206\u89e3\u662f\u4e00\u79cd\u901a\u7528\u7684\u7b97\u6cd5\u601d\u8def\uff0c\u5728\u5206\u6cbb\u7b97\u6cd5\u3001\u52a8\u6001\u89c4\u5212\u3001\u56de\u6eaf\u7b97\u6cd5\u4e2d\u5404\u6709\u7279\u70b9\uff1a

    • \u5206\u6cbb\u7b97\u6cd5\u5c06\u539f\u95ee\u9898\u5212\u5206\u4e3a\u51e0\u4e2a\u72ec\u7acb\u7684\u5b50\u95ee\u9898\uff0c\u7136\u540e\u9012\u5f52\u89e3\u51b3\u5b50\u95ee\u9898\uff0c\u6700\u540e\u5408\u5e76\u5b50\u95ee\u9898\u7684\u89e3\u5f97\u5230\u539f\u95ee\u9898\u7684\u89e3\u3002\u4f8b\u5982\uff0c\u5f52\u5e76\u6392\u5e8f\u5c06\u957f\u6570\u7ec4\u4e0d\u65ad\u5212\u5206\u4e3a\u4e24\u4e2a\u77ed\u5b50\u6570\u7ec4\uff0c\u518d\u5c06\u6392\u5e8f\u597d\u7684\u5b50\u6570\u7ec4\u5408\u5e76\u4e3a\u6392\u5e8f\u597d\u7684\u957f\u6570\u7ec4\u3002
    • \u52a8\u6001\u89c4\u5212\u4e5f\u662f\u5c06\u539f\u95ee\u9898\u5206\u89e3\u4e3a\u591a\u4e2a\u5b50\u95ee\u9898\uff0c\u4f46\u4e0e\u5206\u6cbb\u7b97\u6cd5\u7684\u4e3b\u8981\u533a\u522b\u662f\uff0c\u52a8\u6001\u89c4\u5212\u4e2d\u7684\u5b50\u95ee\u9898\u5f80\u5f80\u4e0d\u662f\u76f8\u4e92\u72ec\u7acb\u7684\uff0c\u539f\u95ee\u9898\u7684\u89e3\u4f9d\u8d56\u4e8e\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u800c\u5b50\u95ee\u9898\u7684\u89e3\u53c8\u4f9d\u8d56\u4e8e\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\u7684\u89e3\u3002\u56e0\u6b64\uff0c\u52a8\u6001\u89c4\u5212\u901a\u5e38\u4f1a\u5f15\u5165\u8bb0\u5fc6\u5316\uff0c\u4fdd\u5b58\u5df2\u7ecf\u89e3\u51b3\u7684\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u907f\u514d\u91cd\u590d\u8ba1\u7b97\u3002
    • \u56de\u6eaf\u7b97\u6cd5\u5728\u5c1d\u8bd5\u548c\u56de\u9000\u4e2d\u7a77\u4e3e\u6240\u6709\u53ef\u80fd\u7684\u89e3\uff0c\u5e76\u901a\u8fc7\u526a\u679d\u907f\u514d\u4e0d\u5fc5\u8981\u7684\u641c\u7d22\u5206\u652f\u3002\u539f\u95ee\u9898\u7684\u89e3\u7531\u4e00\u7cfb\u5217\u51b3\u7b56\u6b65\u9aa4\u6784\u6210\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6bcf\u4e2a\u51b3\u7b56\u6b65\u9aa4\u4e4b\u540e\u7684\u5269\u4f59\u95ee\u9898\u770b\u4f5c\u4e3a\u4e00\u4e2a\u5b50\u95ee\u9898\u3002
    "},{"location":"chapter_dynamic_programming/knapsack_problem/","title":"13.4. \u00a0 0-1 \u80cc\u5305\u95ee\u9898","text":"

    \u80cc\u5305\u95ee\u9898\u662f\u4e00\u4e2a\u975e\u5e38\u597d\u7684\u52a8\u6001\u89c4\u5212\u5165\u95e8\u9898\u76ee\uff0c\u662f\u52a8\u6001\u89c4\u5212\u4e2d\u6700\u5e38\u89c1\u7684\u95ee\u9898\u5f62\u5f0f\u3002\u5176\u5177\u6709\u5f88\u591a\u53d8\u79cd\uff0c\u4f8b\u5982 0-1 \u80cc\u5305\u95ee\u9898\u3001\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u3001\u591a\u91cd\u80cc\u5305\u95ee\u9898\u7b49\u3002

    \u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u5148\u6765\u5b66\u4e60\u57fa\u7840\u7684\u7684 0-1 \u80cc\u5305\u95ee\u9898\u3002

    Question

    \u7ed9\u5b9a \\(n\\) \u4e2a\u7269\u54c1\uff0c\u7b2c \\(i\\) \u4e2a\u7269\u54c1\u7684\u91cd\u91cf\u4e3a \\(wgt[i-1]\\) \u3001\u4ef7\u503c\u4e3a \\(val[i-1]\\) \uff0c\u73b0\u5728\u6709\u4e2a\u5bb9\u91cf\u4e3a \\(cap\\) \u7684\u80cc\u5305\uff0c\u6bcf\u4e2a\u7269\u54c1\u53ea\u80fd\u9009\u62e9\u4e00\u6b21\uff0c\u95ee\u5728\u4e0d\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\u4e0b\u80cc\u5305\u4e2d\u7269\u54c1\u7684\u6700\u5927\u4ef7\u503c\u3002

    \u8bf7\u6ce8\u610f\uff0c\u7269\u54c1\u7f16\u53f7 \\(i\\) \u4ece \\(1\\) \u5f00\u59cb\u8ba1\u6570\uff0c\u6570\u7ec4\u7d22\u5f15\u4ece \\(0\\) \u5f00\u59cb\u8ba1\u6570\uff0c\u56e0\u6b64\u7269\u54c1 \\(i\\) \u5bf9\u5e94\u91cd\u91cf \\(wgt[i-1]\\) \u548c\u4ef7\u503c \\(val[i-1]\\) \u3002

    \u4e0b\u56fe\u7ed9\u51fa\u4e86\u4e00\u4e2a 0-1 \u80cc\u5305\u7684\u793a\u4f8b\u6570\u636e\uff0c\u80cc\u5305\u5185\u7684\u6700\u5927\u4ef7\u503c\u4e3a \\(220\\) \u3002

    Fig. 0-1 \u80cc\u5305\u7684\u793a\u4f8b\u6570\u636e

    \u6211\u4eec\u53ef\u4ee5\u5c06 0-1 \u80cc\u5305\u95ee\u9898\u770b\u4f5c\u662f\u4e00\u4e2a\u7531 \\(n\\) \u8f6e\u51b3\u7b56\u7ec4\u6210\u7684\u8fc7\u7a0b\uff0c\u6bcf\u4e2a\u7269\u4f53\u90fd\u6709\u4e0d\u653e\u5165\u548c\u653e\u5165\u4e24\u79cd\u51b3\u7b56\uff0c\u56e0\u6b64\u8be5\u95ee\u9898\u662f\u6ee1\u8db3\u51b3\u7b56\u6811\u6a21\u578b\u7684\u3002\u6b64\u5916\uff0c\u8be5\u95ee\u9898\u7684\u76ee\u6807\u662f\u6c42\u89e3\u201c\u5728\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u7684\u6700\u5927\u4ef7\u503c\u201d\uff0c\u56e0\u6b64\u8f83\u5927\u6982\u7387\u662f\u4e2a\u52a8\u6001\u89c4\u5212\u95ee\u9898\u3002\u6211\u4eec\u63a5\u4e0b\u6765\u5c1d\u8bd5\u6c42\u89e3\u5b83\u3002

    \u7b2c\u4e00\u6b65\uff1a\u601d\u8003\u6bcf\u8f6e\u7684\u51b3\u7b56\uff0c\u5b9a\u4e49\u72b6\u6001\uff0c\u4ece\u800c\u5f97\u5230 \\(dp\\) \u8868

    \u5728 0-1 \u80cc\u5305\u95ee\u9898\u4e2d\uff0c\u4e0d\u653e\u5165\u80cc\u5305\uff0c\u80cc\u5305\u5bb9\u91cf\u4e0d\u53d8\uff1b\u653e\u5165\u80cc\u5305\uff0c\u80cc\u5305\u5bb9\u91cf\u51cf\u5c0f\u3002\u7531\u6b64\u53ef\u5f97\u72b6\u6001\u5b9a\u4e49\uff1a\u5f53\u524d\u7269\u54c1\u7f16\u53f7 \\(i\\) \u548c\u5269\u4f59\u80cc\u5305\u5bb9\u91cf \\(c\\) \uff0c\u8bb0\u4e3a \\([i, c]\\) \u3002

    \u72b6\u6001 \\([i, c]\\) \u5bf9\u5e94\u7684\u5b50\u95ee\u9898\u4e3a\uff1a\u524d \\(i\\) \u4e2a\u7269\u54c1\u5728\u5269\u4f59\u5bb9\u91cf\u4e3a \\(c\\) \u7684\u80cc\u5305\u4e2d\u7684\u6700\u5927\u4ef7\u503c\uff0c\u8bb0\u4e3a \\(dp[i, c]\\) \u3002

    \u81f3\u6b64\uff0c\u6211\u4eec\u5f97\u5230\u4e00\u4e2a\u5c3a\u5bf8\u4e3a \\(n \\times cap\\) \u7684\u4e8c\u7ef4 \\(dp\\) \u77e9\u9635\u3002

    \u7b2c\u4e8c\u6b65\uff1a\u627e\u51fa\u6700\u4f18\u5b50\u7ed3\u6784\uff0c\u8fdb\u800c\u63a8\u5bfc\u51fa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b

    \u5f53\u6211\u4eec\u505a\u51fa\u7269\u54c1 \\(i\\) \u7684\u51b3\u7b56\u540e\uff0c\u5269\u4f59\u7684\u662f\u524d \\(i-1\\) \u4e2a\u7269\u54c1\u7684\u51b3\u7b56\u3002\u56e0\u6b64\uff0c\u72b6\u6001\u8f6c\u79fb\u5206\u4e3a\u4e24\u79cd\u60c5\u51b5\uff1a

    • \u4e0d\u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u80cc\u5305\u5bb9\u91cf\u4e0d\u53d8\uff0c\u72b6\u6001\u8f6c\u79fb\u81f3 \\([i-1, c]\\) \uff1b
    • \u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u80cc\u5305\u5bb9\u91cf\u51cf\u5c0f \\(wgt[i-1]\\) \uff0c\u4ef7\u503c\u589e\u52a0 \\(val[i-1]\\) \uff0c\u72b6\u6001\u8f6c\u79fb\u81f3 \\([i-1, c-wgt[i-1]]\\) \uff1b

    \u4e0a\u8ff0\u7684\u72b6\u6001\u8f6c\u79fb\u5411\u6211\u4eec\u63ed\u793a\u4e86\u672c\u9898\u7684\u6700\u4f18\u5b50\u7ed3\u6784\uff1a\u6700\u5927\u4ef7\u503c \\(dp[i, c]\\) \u7b49\u4e8e\u4e0d\u653e\u5165\u7269\u54c1 \\(i\\) \u548c\u653e\u5165\u7269\u54c1 \\(i\\) \u4e24\u79cd\u65b9\u6848\u4e2d\u7684\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\u3002\u7531\u6b64\u53ef\u63a8\u51fa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff1a

    \\[ dp[i, c] = \\max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) \\]

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u82e5\u5f53\u524d\u7269\u54c1\u91cd\u91cf \\(wgt[i - 1]\\) \u8d85\u51fa\u5269\u4f59\u80cc\u5305\u5bb9\u91cf \\(c\\) \uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\u3002

    \u7b2c\u4e09\u6b65\uff1a\u786e\u5b9a\u8fb9\u754c\u6761\u4ef6\u548c\u72b6\u6001\u8f6c\u79fb\u987a\u5e8f

    \u5f53\u65e0\u7269\u54c1\u6216\u65e0\u5269\u4f59\u80cc\u5305\u5bb9\u91cf\u65f6\u6700\u5927\u4ef7\u503c\u4e3a \\(0\\) \uff0c\u5373\u6240\u6709 \\(dp[i, 0]\\) \u548c \\(dp[0, c]\\) \u90fd\u7b49\u4e8e \\(0\\) \u3002

    \u5f53\u524d\u72b6\u6001 \\([i, c]\\) \u4ece\u4e0a\u65b9\u7684\u72b6\u6001 \\([i-1, c]\\) \u548c\u5de6\u4e0a\u65b9\u7684\u72b6\u6001 \\([i-1, c-wgt[i-1]]\\) \u8f6c\u79fb\u800c\u6765\uff0c\u56e0\u6b64\u901a\u8fc7\u4e24\u5c42\u5faa\u73af\u6b63\u5e8f\u904d\u5386\u6574\u4e2a \\(dp\\) \u8868\u5373\u53ef\u3002

    "},{"location":"chapter_dynamic_programming/knapsack_problem/#1341","title":"13.4.1. \u00a0 \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u641c\u7d22","text":"

    \u641c\u7d22\u4ee3\u7801\u5305\u542b\u4ee5\u4e0b\u8981\u7d20\uff1a

    • \u9012\u5f52\u53c2\u6570\uff1a\u72b6\u6001 \\([i, c]\\) \uff1b\u8fd4\u56de\u503c\uff1a\u5b50\u95ee\u9898\u7684\u89e3 \\(dp[i, c]\\) \u3002
    • \u7ec8\u6b62\u6761\u4ef6\uff1a\u5f53\u7269\u54c1\u7f16\u53f7\u8d8a\u754c \\(i = 0\\) \u6216\u80cc\u5305\u5269\u4f59\u5bb9\u91cf\u4e3a \\(0\\) \u65f6\uff0c\u7ec8\u6b62\u9012\u5f52\u5e76\u8fd4\u56de\u4ef7\u503c \\(0\\) \u3002
    • \u526a\u679d\uff1a\u82e5\u5f53\u524d\u7269\u54c1\u91cd\u91cf\u8d85\u51fa\u80cc\u5305\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nint knapsackDFS(int[] wgt, int[] val, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (wgt[i - 1] > c) {\nreturn knapsackDFS(wgt, val, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFS(wgt, val, i - 1, c);\nint yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n// \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nreturn Math.max(no, yes);\n}\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nint knapsackDFS(vector<int> &wgt, vector<int> &val, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (wgt[i - 1] > c) {\nreturn knapsackDFS(wgt, val, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFS(wgt, val, i - 1, c);\nint yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n// \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nreturn max(no, yes);\n}\n
    knapsack.py
    def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -> int:\n\"\"\"0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22\"\"\"\n# \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif i == 0 or c == 0:\nreturn 0\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif wgt[i - 1] > c:\nreturn knapsack_dfs(wgt, val, i - 1, c)\n# \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nno = knapsack_dfs(wgt, val, i - 1, c)\nyes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n# \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nreturn max(no, yes)\n
    knapsack.go
    [class]{}-[func]{knapsackDFS}\n
    knapsack.js
    [class]{}-[func]{knapsackDFS}\n
    knapsack.ts
    [class]{}-[func]{knapsackDFS}\n
    knapsack.c
    [class]{}-[func]{knapsackDFS}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nint knapsackDFS(int[] weight, int[] val, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (weight[i - 1] > c) {\nreturn knapsackDFS(weight, val, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFS(weight, val, i - 1, c);\nint yes = knapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];\n// \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nreturn Math.Max(no, yes);\n}\n
    knapsack.swift
    [class]{}-[func]{knapsackDFS}\n
    knapsack.zig
    [class]{}-[func]{knapsackDFS}\n
    knapsack.dart
    [class]{}-[func]{knapsackDFS}\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u7531\u4e8e\u6bcf\u4e2a\u7269\u54c1\u90fd\u4f1a\u4ea7\u751f\u4e0d\u9009\u548c\u9009\u4e24\u6761\u641c\u7d22\u5206\u652f\uff0c\u56e0\u6b64\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \u3002

    \u89c2\u5bdf\u9012\u5f52\u6811\uff0c\u5bb9\u6613\u53d1\u73b0\u5176\u4e2d\u5b58\u5728\u4e00\u4e9b\u300c\u91cd\u53e0\u5b50\u95ee\u9898\u300d\uff0c\u4f8b\u5982 \\(dp[1, 10]\\) \u7b49\u3002\u800c\u5f53\u7269\u54c1\u8f83\u591a\u3001\u80cc\u5305\u5bb9\u91cf\u8f83\u5927\uff0c\u5c24\u5176\u662f\u5f53\u76f8\u540c\u91cd\u91cf\u7684\u7269\u54c1\u8f83\u591a\u65f6\uff0c\u91cd\u53e0\u5b50\u95ee\u9898\u7684\u6570\u91cf\u5c06\u4f1a\u5927\u5e45\u589e\u591a\u3002

    Fig. 0-1 \u80cc\u5305\u7684\u66b4\u529b\u641c\u7d22\u9012\u5f52\u6811

    "},{"location":"chapter_dynamic_programming/knapsack_problem/#1342","title":"13.4.2. \u00a0 \u65b9\u6cd5\u4e8c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22","text":"

    \u4e3a\u4e86\u9632\u6b62\u91cd\u590d\u6c42\u89e3\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u6211\u4eec\u501f\u52a9\u4e00\u4e2a\u8bb0\u5fc6\u5217\u8868 mem \u6765\u8bb0\u5f55\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u5176\u4e2d mem[i][c] \u5bf9\u5e94\u89e3 \\(dp[i, c]\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][c] != -1) {\nreturn mem[i][c];\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (wgt[i - 1] > c) {\nreturn knapsackDFSMem(wgt, val, mem, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFSMem(wgt, val, mem, i - 1, c);\nint yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nmem[i][c] = Math.max(no, yes);\nreturn mem[i][c];\n}\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint knapsackDFSMem(vector<int> &wgt, vector<int> &val, vector<vector<int>> &mem, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][c] != -1) {\nreturn mem[i][c];\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (wgt[i - 1] > c) {\nreturn knapsackDFSMem(wgt, val, mem, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFSMem(wgt, val, mem, i - 1, c);\nint yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nmem[i][c] = max(no, yes);\nreturn mem[i][c];\n}\n
    knapsack.py
    def knapsack_dfs_mem(\nwgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int\n) -> int:\n\"\"\"0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\"\"\"\n# \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif i == 0 or c == 0:\nreturn 0\n# \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif mem[i][c] != -1:\nreturn mem[i][c]\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif wgt[i - 1] > c:\nreturn knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n# \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nno = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\nyes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n# \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nmem[i][c] = max(no, yes)\nreturn mem[i][c]\n
    knapsack.go
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.js
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.ts
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.c
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint knapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][c] != -1) {\nreturn mem[i][c];\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (weight[i - 1] > c) {\nreturn knapsackDFSMem(weight, val, mem, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFSMem(weight, val, mem, i - 1, c);\nint yes = knapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nmem[i][c] = Math.Max(no, yes);\nreturn mem[i][c];\n}\n
    knapsack.swift
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.zig
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.dart
    [class]{}-[func]{knapsackDFSMem}\n

    \u5f15\u5165\u8bb0\u5fc6\u5316\u4e4b\u540e\uff0c\u6240\u6709\u5b50\u95ee\u9898\u90fd\u53ea\u88ab\u8ba1\u7b97\u4e00\u6b21\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u5b50\u95ee\u9898\u6570\u91cf\uff0c\u4e5f\u5c31\u662f \\(O(n \\times cap)\\) \u3002

    Fig. 0-1 \u80cc\u5305\u7684\u8bb0\u5fc6\u5316\u641c\u7d22\u9012\u5f52\u6811

    "},{"location":"chapter_dynamic_programming/knapsack_problem/#1343","title":"13.4.3. \u00a0 \u65b9\u6cd5\u4e09\uff1a\u52a8\u6001\u89c4\u5212","text":"

    \u52a8\u6001\u89c4\u5212\u89e3\u6cd5\u672c\u8d28\u4e0a\u5c31\u662f\u5728\u72b6\u6001\u8f6c\u79fb\u4e2d\u586b\u5145 dp \u77e9\u9635\u7684\u8fc7\u7a0b\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(int[] wgt, int[] val, int cap) {\nint n = wgt.length;\n// \u521d\u59cb\u5316 dp \u8868\nint[][] dp = new int[n + 1][cap + 1];\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int c = 1; c <= cap; c++) {\nif (wgt[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[i][c] = dp[i - 1][c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[n][cap];\n}\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(vector<int> &wgt, vector<int> &val, int cap) {\nint n = wgt.size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int c = 1; c <= cap; c++) {\nif (wgt[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[i][c] = dp[i - 1][c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[n][cap];\n}\n
    knapsack.py
    def knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:\n\"\"\"0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(wgt)\n# \u521d\u59cb\u5316 dp \u8868\ndp = [[0] * (cap + 1) for _ in range(n + 1)]\n# \u72b6\u6001\u8f6c\u79fb\nfor i in range(1, n + 1):\nfor c in range(1, cap + 1):\nif wgt[i - 1] > c:\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[i][c] = dp[i - 1][c]\nelse:\n# \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\nreturn dp[n][cap]\n
    knapsack.go
    [class]{}-[func]{knapsackDP}\n
    knapsack.js
    [class]{}-[func]{knapsackDP}\n
    knapsack.ts
    [class]{}-[func]{knapsackDP}\n
    knapsack.c
    [class]{}-[func]{knapsackDP}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(int[] weight, int[] val, int cap) {\nint n = weight.Length;\n// \u521d\u59cb\u5316 dp \u8868\nint[,] dp = new int[n + 1, cap + 1];\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int c = 1; c <= cap; c++) {\nif (weight[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[i, c] = dp[i - 1, c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n}\n}\n}\nreturn dp[n, cap];\n}\n
    knapsack.swift
    [class]{}-[func]{knapsackDP}\n
    knapsack.zig
    [class]{}-[func]{knapsackDP}\n
    knapsack.dart
    [class]{}-[func]{knapsackDP}\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u7531 dp \u77e9\u9635\u5927\u5c0f\u51b3\u5b9a\uff0c\u4e3a \\(O(n \\times cap)\\) \u3002

    <1><2><3><4><5><6><7><8><9><10><11><12><13><14>

    \u6700\u540e\u8003\u8651\u72b6\u6001\u538b\u7f29\u3002\u4ee5\u4e0a\u4ee3\u7801\u4e2d\u7684 dp \u77e9\u9635\u5360\u7528 \\(O(n \\times cap)\\) \u7a7a\u95f4\u3002\u7531\u4e8e\u6bcf\u4e2a\u72b6\u6001\u90fd\u53ea\u4e0e\u5176\u4e0a\u4e00\u884c\u7684\u72b6\u6001\u6709\u5173\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4e24\u4e2a\u6570\u7ec4\u6eda\u52a8\u524d\u8fdb\uff0c\u5c06\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n^2)\\) \u5c06\u4f4e\u81f3 \\(O(n)\\) \u3002\u4ee3\u7801\u7701\u7565\uff0c\u6709\u5174\u8da3\u7684\u540c\u5b66\u53ef\u4ee5\u81ea\u884c\u5b9e\u73b0\u3002

    \u90a3\u4e48\uff0c\u6211\u4eec\u662f\u5426\u53ef\u4ee5\u4ec5\u7528\u4e00\u4e2a\u6570\u7ec4\u5b9e\u73b0\u72b6\u6001\u538b\u7f29\u5462\uff1f\u89c2\u5bdf\u53ef\u77e5\uff0c\u6bcf\u4e2a\u72b6\u6001\u90fd\u662f\u7531\u5de6\u4e0a\u65b9\u6216\u6b63\u4e0a\u65b9\u7684\u683c\u5b50\u8f6c\u79fb\u8fc7\u6765\u7684\u3002\u5047\u8bbe\u53ea\u6709\u4e00\u4e2a\u6570\u7ec4\uff0c\u5f53\u904d\u5386\u5230\u7b2c \\(i\\) \u884c\u65f6\uff0c\u8be5\u6570\u7ec4\u5b58\u50a8\u7684\u4ecd\u7136\u662f\u7b2c \\(i-1\\) \u884c\u7684\u72b6\u6001\uff0c\u4e3a\u4e86\u907f\u514d\u5de6\u8fb9\u533a\u57df\u7684\u683c\u5b50\u5728\u72b6\u6001\u8f6c\u79fb\u4e2d\u88ab\u8986\u76d6\uff0c\u6211\u4eec\u5e94\u91c7\u53d6\u5012\u5e8f\u904d\u5386\u3002

    \u4ee5\u4e0b\u52a8\u753b\u5c55\u793a\u4e86\u5728\u5355\u4e2a\u6570\u7ec4\u4e0b\u4ece\u7b2c \\(i=1\\) \u884c\u8f6c\u6362\u81f3\u7b2c \\(i=2\\) \u884c\u7684\u8fc7\u7a0b\u3002\u5efa\u8bae\u4f60\u601d\u8003\u4e00\u4e0b\u6b63\u5e8f\u904d\u5386\u548c\u5012\u5e8f\u904d\u5386\u7684\u533a\u522b\u3002

    <1><2><3><4><5><6>

    \u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u6211\u4eec\u4ec5\u9700\u5c06 dp \u77e9\u9635\u7684\u7b2c\u4e00\u7ef4 \\(i\\) \u76f4\u63a5\u5220\u9664\uff0c\u5e76\u4e14\u5c06\u5185\u5faa\u73af\u4fee\u6539\u4e3a\u5012\u5e8f\u904d\u5386\u5373\u53ef\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\nint n = wgt.length;\n// \u521d\u59cb\u5316 dp \u8868\nint[] dp = new int[cap + 1];\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\n// \u5012\u5e8f\u904d\u5386\nfor (int c = cap; c >= 1; c--) {\nif (wgt[i - 1] <= c) {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[cap];\n}\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {\nint n = wgt.size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<int> dp(cap + 1, 0);\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\n// \u5012\u5e8f\u904d\u5386\nfor (int c = cap; c >= 1; c--) {\nif (wgt[i - 1] <= c) {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[cap];\n}\n
    knapsack.py
    def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:\n\"\"\"0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(wgt)\n# \u521d\u59cb\u5316 dp \u8868\ndp = [0] * (cap + 1)\n# \u72b6\u6001\u8f6c\u79fb\nfor i in range(1, n + 1):\n# \u5012\u5e8f\u904d\u5386\nfor c in range(cap, 0, -1):\nif wgt[i - 1] > c:\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[c] = dp[c]\nelse:\n# \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\nreturn dp[cap]\n
    knapsack.go
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.js
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.ts
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.c
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(int[] weight, int[] val, int cap) {\nint n = weight.Length;\n// \u521d\u59cb\u5316 dp \u8868\nint[] dp = new int[cap + 1];\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\n// \u5012\u5e8f\u904d\u5386\nfor (int c = cap; c > 0; c--) {\nif (weight[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[c] = dp[c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[cap];\n}\n
    knapsack.swift
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.zig
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.dart
    [class]{}-[func]{knapsackDPComp}\n
    "},{"location":"chapter_graph/","title":"9. \u00a0 \u56fe","text":""},{"location":"chapter_graph/graph/","title":"9.1. \u00a0 \u56fe","text":"

    \u300c\u56fe Graph\u300d\u662f\u4e00\u79cd\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u7531\u300c\u9876\u70b9 Vertex\u300d\u548c\u300c\u8fb9 Edge\u300d\u7ec4\u6210\u3002\u6211\u4eec\u53ef\u4ee5\u5c06\u56fe \\(G\\) \u62bd\u8c61\u5730\u8868\u793a\u4e3a\u4e00\u7ec4\u9876\u70b9 \\(V\\) \u548c\u4e00\u7ec4\u8fb9 \\(E\\) \u7684\u96c6\u5408\u3002\u4ee5\u4e0b\u793a\u4f8b\u5c55\u793a\u4e86\u4e00\u4e2a\u5305\u542b 5 \u4e2a\u9876\u70b9\u548c 7 \u6761\u8fb9\u7684\u56fe\u3002

    \\[ \\begin{aligned} V & = \\{ 1, 2, 3, 4, 5 \\} \\newline E & = \\{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \\} \\newline G & = \\{ V, E \\} \\newline \\end{aligned} \\]

    Fig. \u94fe\u8868\u3001\u6811\u3001\u56fe\u4e4b\u95f4\u7684\u5173\u7cfb

    \u90a3\u4e48\uff0c\u56fe\u4e0e\u5176\u4ed6\u6570\u636e\u7ed3\u6784\u7684\u5173\u7cfb\u662f\u4ec0\u4e48\uff1f\u5982\u679c\u6211\u4eec\u628a\u300c\u9876\u70b9\u300d\u770b\u4f5c\u8282\u70b9\uff0c\u628a\u300c\u8fb9\u300d\u770b\u4f5c\u8fde\u63a5\u5404\u4e2a\u8282\u70b9\u7684\u6307\u9488\uff0c\u5219\u53ef\u5c06\u300c\u56fe\u300d\u770b\u4f5c\u662f\u4e00\u79cd\u4ece\u300c\u94fe\u8868\u300d\u62d3\u5c55\u800c\u6765\u7684\u6570\u636e\u7ed3\u6784\u3002\u76f8\u8f83\u4e8e\u7ebf\u6027\u5173\u7cfb\uff08\u94fe\u8868\uff09\u548c\u5206\u6cbb\u5173\u7cfb\uff08\u6811\uff09\uff0c\u7f51\u7edc\u5173\u7cfb\uff08\u56fe\uff09\u7684\u81ea\u7531\u5ea6\u66f4\u9ad8\uff0c\u4ece\u800c\u66f4\u4e3a\u590d\u6742\u3002

    "},{"location":"chapter_graph/graph/#911","title":"9.1.1. \u00a0 \u56fe\u5e38\u89c1\u7c7b\u578b","text":"

    \u6839\u636e\u8fb9\u662f\u5426\u5177\u6709\u65b9\u5411\uff0c\u53ef\u5206\u4e3a\u300c\u65e0\u5411\u56fe Undirected Graph\u300d\u548c\u300c\u6709\u5411\u56fe Directed Graph\u300d\u3002

    • \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u8fb9\u8868\u793a\u4e24\u9876\u70b9\u4e4b\u95f4\u7684\u201c\u53cc\u5411\u201d\u8fde\u63a5\u5173\u7cfb\uff0c\u4f8b\u5982\u5fae\u4fe1\u6216 QQ \u4e2d\u7684\u201c\u597d\u53cb\u5173\u7cfb\u201d\uff1b
    • \u5728\u6709\u5411\u56fe\u4e2d\uff0c\u8fb9\u5177\u6709\u65b9\u5411\u6027\uff0c\u5373 \\(A \\rightarrow B\\) \u548c \\(A \\leftarrow B\\) \u4e24\u4e2a\u65b9\u5411\u7684\u8fb9\u662f\u76f8\u4e92\u72ec\u7acb\u7684\uff0c\u4f8b\u5982\u5fae\u535a\u6216\u6296\u97f3\u4e0a\u7684\u201c\u5173\u6ce8\u201d\u4e0e\u201c\u88ab\u5173\u6ce8\u201d\u5173\u7cfb\uff1b

    Fig. \u6709\u5411\u56fe\u4e0e\u65e0\u5411\u56fe

    \u6839\u636e\u6240\u6709\u9876\u70b9\u662f\u5426\u8fde\u901a\uff0c\u53ef\u5206\u4e3a\u300c\u8fde\u901a\u56fe Connected Graph\u300d\u548c\u300c\u975e\u8fde\u901a\u56fe Disconnected Graph\u300d\u3002

    • \u5bf9\u4e8e\u8fde\u901a\u56fe\uff0c\u4ece\u67d0\u4e2a\u9876\u70b9\u51fa\u53d1\uff0c\u53ef\u4ee5\u5230\u8fbe\u5176\u4f59\u4efb\u610f\u9876\u70b9\uff1b
    • \u5bf9\u4e8e\u975e\u8fde\u901a\u56fe\uff0c\u4ece\u67d0\u4e2a\u9876\u70b9\u51fa\u53d1\uff0c\u81f3\u5c11\u6709\u4e00\u4e2a\u9876\u70b9\u65e0\u6cd5\u5230\u8fbe\uff1b

    Fig. \u8fde\u901a\u56fe\u4e0e\u975e\u8fde\u901a\u56fe

    \u6211\u4eec\u8fd8\u53ef\u4ee5\u4e3a\u8fb9\u6dfb\u52a0\u201c\u6743\u91cd\u201d\u53d8\u91cf\uff0c\u4ece\u800c\u5f97\u5230\u300c\u6709\u6743\u56fe Weighted Graph\u300d\u3002\u4f8b\u5982\uff0c\u5728\u738b\u8005\u8363\u8000\u7b49\u624b\u6e38\u4e2d\uff0c\u7cfb\u7edf\u4f1a\u6839\u636e\u5171\u540c\u6e38\u620f\u65f6\u95f4\u6765\u8ba1\u7b97\u73a9\u5bb6\u4e4b\u95f4\u7684\u201c\u4eb2\u5bc6\u5ea6\u201d\uff0c\u8fd9\u79cd\u4eb2\u5bc6\u5ea6\u7f51\u7edc\u5c31\u53ef\u4ee5\u7528\u6709\u6743\u56fe\u6765\u8868\u793a\u3002

    Fig. \u6709\u6743\u56fe\u4e0e\u65e0\u6743\u56fe

    "},{"location":"chapter_graph/graph/#912","title":"9.1.2. \u00a0 \u56fe\u5e38\u7528\u672f\u8bed","text":"
    • \u300c\u90bb\u63a5 Adjacency\u300d\uff1a\u5f53\u4e24\u9876\u70b9\u4e4b\u95f4\u5b58\u5728\u8fb9\u76f8\u8fde\u65f6\uff0c\u79f0\u8fd9\u4e24\u9876\u70b9\u201c\u90bb\u63a5\u201d\u3002\u5728\u4e0a\u56fe\u4e2d\uff0c\u9876\u70b9 1 \u7684\u90bb\u63a5\u9876\u70b9\u4e3a\u9876\u70b9 2\u30013\u30015\u3002
    • \u300c\u8def\u5f84 Path\u300d\uff1a\u4ece\u9876\u70b9 A \u5230\u9876\u70b9 B \u7ecf\u8fc7\u7684\u8fb9\u6784\u6210\u7684\u5e8f\u5217\u88ab\u79f0\u4e3a\u4ece A \u5230 B \u7684\u201c\u8def\u5f84\u201d\u3002\u5728\u4e0a\u56fe\u4e2d\uff0c\u8fb9\u5e8f\u5217 1-5-2-4 \u662f\u9876\u70b9 1 \u5230\u9876\u70b9 4 \u7684\u4e00\u6761\u8def\u5f84\u3002
    • \u300c\u5ea6 Degree\u300d\u8868\u793a\u4e00\u4e2a\u9876\u70b9\u62e5\u6709\u7684\u8fb9\u6570\u3002\u5bf9\u4e8e\u6709\u5411\u56fe\uff0c\u300c\u5165\u5ea6 In-Degree\u300d\u8868\u793a\u6709\u591a\u5c11\u6761\u8fb9\u6307\u5411\u8be5\u9876\u70b9\uff0c\u300c\u51fa\u5ea6 Out-Degree\u300d\u8868\u793a\u6709\u591a\u5c11\u6761\u8fb9\u4ece\u8be5\u9876\u70b9\u6307\u51fa\u3002
    "},{"location":"chapter_graph/graph/#913","title":"9.1.3. \u00a0 \u56fe\u7684\u8868\u793a","text":"

    \u56fe\u7684\u5e38\u7528\u8868\u793a\u65b9\u6cd5\u5305\u62ec\u300c\u90bb\u63a5\u77e9\u9635\u300d\u548c\u300c\u90bb\u63a5\u8868\u300d\u3002\u4ee5\u4e0b\u4f7f\u7528\u65e0\u5411\u56fe\u8fdb\u884c\u4e3e\u4f8b\u3002

    "},{"location":"chapter_graph/graph/#_1","title":"\u90bb\u63a5\u77e9\u9635","text":"

    \u8bbe\u56fe\u7684\u9876\u70b9\u6570\u91cf\u4e3a \\(n\\) \uff0c\u300c\u90bb\u63a5\u77e9\u9635 Adjacency Matrix\u300d\u4f7f\u7528\u4e00\u4e2a \\(n \\times n\\) \u5927\u5c0f\u7684\u77e9\u9635\u6765\u8868\u793a\u56fe\uff0c\u6bcf\u4e00\u884c\uff08\u5217\uff09\u4ee3\u8868\u4e00\u4e2a\u9876\u70b9\uff0c\u77e9\u9635\u5143\u7d20\u4ee3\u8868\u8fb9\uff0c\u7528 \\(1\\) \u6216 \\(0\\) \u8868\u793a\u4e24\u4e2a\u9876\u70b9\u4e4b\u95f4\u662f\u5426\u5b58\u5728\u8fb9\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u8bbe\u90bb\u63a5\u77e9\u9635\u4e3a \\(M\\) \u3001\u9876\u70b9\u5217\u8868\u4e3a \\(V\\) \uff0c\u90a3\u4e48\u77e9\u9635\u5143\u7d20 \\(M[i][j] = 1\\) \u8868\u793a\u9876\u70b9 \\(V[i]\\) \u5230\u9876\u70b9 \\(V[j]\\) \u4e4b\u95f4\u5b58\u5728\u8fb9\uff0c\u53cd\u4e4b \\(M[i][j] = 0\\) \u8868\u793a\u4e24\u9876\u70b9\u4e4b\u95f4\u65e0\u8fb9\u3002

    Fig. \u56fe\u7684\u90bb\u63a5\u77e9\u9635\u8868\u793a

    \u90bb\u63a5\u77e9\u9635\u5177\u6709\u4ee5\u4e0b\u7279\u6027\uff1a

    • \u9876\u70b9\u4e0d\u80fd\u4e0e\u81ea\u8eab\u76f8\u8fde\uff0c\u56e0\u6b64\u90bb\u63a5\u77e9\u9635\u4e3b\u5bf9\u89d2\u7ebf\u5143\u7d20\u6ca1\u6709\u610f\u4e49\u3002
    • \u5bf9\u4e8e\u65e0\u5411\u56fe\uff0c\u4e24\u4e2a\u65b9\u5411\u7684\u8fb9\u7b49\u4ef7\uff0c\u6b64\u65f6\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\u3002
    • \u5c06\u90bb\u63a5\u77e9\u9635\u7684\u5143\u7d20\u4ece \\(1\\) , \\(0\\) \u66ff\u6362\u4e3a\u6743\u91cd\uff0c\u5219\u53ef\u8868\u793a\u6709\u6743\u56fe\u3002

    \u4f7f\u7528\u90bb\u63a5\u77e9\u9635\u8868\u793a\u56fe\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u8bbf\u95ee\u77e9\u9635\u5143\u7d20\u4ee5\u83b7\u53d6\u8fb9\uff0c\u56e0\u6b64\u589e\u5220\u67e5\u64cd\u4f5c\u7684\u6548\u7387\u5f88\u9ad8\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(1)\\) \u3002\u7136\u800c\uff0c\u77e9\u9635\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff0c\u5185\u5b58\u5360\u7528\u8f83\u591a\u3002

    "},{"location":"chapter_graph/graph/#_2","title":"\u90bb\u63a5\u8868","text":"

    \u300c\u90bb\u63a5\u8868 Adjacency List\u300d\u4f7f\u7528 \\(n\\) \u4e2a\u94fe\u8868\u6765\u8868\u793a\u56fe\uff0c\u94fe\u8868\u8282\u70b9\u8868\u793a\u9876\u70b9\u3002\u7b2c \\(i\\) \u6761\u94fe\u8868\u5bf9\u5e94\u9876\u70b9 \\(i\\) \uff0c\u5176\u4e2d\u5b58\u50a8\u4e86\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\uff08\u5373\u4e0e\u8be5\u9876\u70b9\u76f8\u8fde\u7684\u9876\u70b9\uff09\u3002

    Fig. \u56fe\u7684\u90bb\u63a5\u8868\u8868\u793a

    \u90bb\u63a5\u8868\u4ec5\u5b58\u50a8\u5b9e\u9645\u5b58\u5728\u7684\u8fb9\uff0c\u800c\u8fb9\u7684\u603b\u6570\u901a\u5e38\u8fdc\u5c0f\u4e8e \\(n^2\\) \uff0c\u56e0\u6b64\u5b83\u66f4\u52a0\u8282\u7701\u7a7a\u95f4\u3002\u7136\u800c\uff0c\u5728\u90bb\u63a5\u8868\u4e2d\u9700\u8981\u901a\u8fc7\u904d\u5386\u94fe\u8868\u6765\u67e5\u627e\u8fb9\uff0c\u56e0\u6b64\u5176\u65f6\u95f4\u6548\u7387\u4e0d\u5982\u90bb\u63a5\u77e9\u9635\u3002

    \u89c2\u5bdf\u4e0a\u56fe\u53ef\u53d1\u73b0\uff0c\u90bb\u63a5\u8868\u7ed3\u6784\u4e0e\u54c8\u5e0c\u8868\u4e2d\u7684\u300c\u94fe\u5730\u5740\u6cd5\u300d\u975e\u5e38\u76f8\u4f3c\uff0c\u56e0\u6b64\u6211\u4eec\u4e5f\u53ef\u4ee5\u91c7\u7528\u7c7b\u4f3c\u65b9\u6cd5\u6765\u4f18\u5316\u6548\u7387\u3002\u4f8b\u5982\uff0c\u5f53\u94fe\u8868\u8f83\u957f\u65f6\uff0c\u53ef\u4ee5\u5c06\u94fe\u8868\u8f6c\u5316\u4e3a AVL \u6811\u6216\u7ea2\u9ed1\u6811\uff0c\u4ece\u800c\u5c06\u65f6\u95f4\u6548\u7387\u4ece \\(O(n)\\) \u4f18\u5316\u81f3 \\(O(\\log n)\\) \uff0c\u8fd8\u53ef\u4ee5\u901a\u8fc7\u4e2d\u5e8f\u904d\u5386\u83b7\u53d6\u6709\u5e8f\u5e8f\u5217\uff1b\u6b64\u5916\uff0c\u8fd8\u53ef\u4ee5\u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u54c8\u5e0c\u8868\uff0c\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u964d\u4f4e\u81f3 \\(O(1)\\) \u3002

    "},{"location":"chapter_graph/graph/#914","title":"9.1.4. \u00a0 \u56fe\u5e38\u89c1\u5e94\u7528","text":"

    \u5b9e\u9645\u5e94\u7528\u4e2d\uff0c\u8bb8\u591a\u7cfb\u7edf\u90fd\u53ef\u4ee5\u7528\u56fe\u6765\u5efa\u6a21\uff0c\u76f8\u5e94\u7684\u5f85\u6c42\u89e3\u95ee\u9898\u4e5f\u53ef\u4ee5\u7ea6\u5316\u4e3a\u56fe\u8ba1\u7b97\u95ee\u9898\u3002

    \u9876\u70b9 \u8fb9 \u56fe\u8ba1\u7b97\u95ee\u9898 \u793e\u4ea4\u7f51\u7edc \u7528\u6237 \u597d\u53cb\u5173\u7cfb \u6f5c\u5728\u597d\u53cb\u63a8\u8350 \u5730\u94c1\u7ebf\u8def \u7ad9\u70b9 \u7ad9\u70b9\u95f4\u7684\u8fde\u901a\u6027 \u6700\u77ed\u8def\u7ebf\u63a8\u8350 \u592a\u9633\u7cfb \u661f\u4f53 \u661f\u4f53\u95f4\u7684\u4e07\u6709\u5f15\u529b\u4f5c\u7528 \u884c\u661f\u8f68\u9053\u8ba1\u7b97"},{"location":"chapter_graph/graph_operations/","title":"9.2. \u00a0 \u56fe\u57fa\u7840\u64cd\u4f5c","text":"

    \u56fe\u7684\u57fa\u7840\u64cd\u4f5c\u53ef\u5206\u4e3a\u5bf9\u300c\u8fb9\u300d\u7684\u64cd\u4f5c\u548c\u5bf9\u300c\u9876\u70b9\u300d\u7684\u64cd\u4f5c\u3002\u5728\u300c\u90bb\u63a5\u77e9\u9635\u300d\u548c\u300c\u90bb\u63a5\u8868\u300d\u4e24\u79cd\u8868\u793a\u65b9\u6cd5\u4e0b\uff0c\u5b9e\u73b0\u65b9\u5f0f\u6709\u6240\u4e0d\u540c\u3002

    "},{"location":"chapter_graph/graph_operations/#921","title":"9.2.1. \u00a0 \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u7684\u5b9e\u73b0","text":"

    \u7ed9\u5b9a\u4e00\u4e2a\u9876\u70b9\u6570\u91cf\u4e3a \\(n\\) \u7684\u65e0\u5411\u56fe\uff0c\u5219\u6709\uff1a

    • \u6dfb\u52a0\u6216\u5220\u9664\u8fb9\uff1a\u76f4\u63a5\u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u4fee\u6539\u6307\u5b9a\u7684\u8fb9\u5373\u53ef\uff0c\u4f7f\u7528 \\(O(1)\\) \u65f6\u95f4\u3002\u800c\u7531\u4e8e\u662f\u65e0\u5411\u56fe\uff0c\u56e0\u6b64\u9700\u8981\u540c\u65f6\u66f4\u65b0\u4e24\u4e2a\u65b9\u5411\u7684\u8fb9\u3002
    • \u6dfb\u52a0\u9876\u70b9\uff1a\u5728\u90bb\u63a5\u77e9\u9635\u7684\u5c3e\u90e8\u6dfb\u52a0\u4e00\u884c\u4e00\u5217\uff0c\u5e76\u5168\u90e8\u586b \\(0\\) \u5373\u53ef\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002
    • \u5220\u9664\u9876\u70b9\uff1a\u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u4e00\u884c\u4e00\u5217\u3002\u5f53\u5220\u9664\u9996\u884c\u9996\u5217\u65f6\u8fbe\u5230\u6700\u5dee\u60c5\u51b5\uff0c\u9700\u8981\u5c06 \\((n-1)^2\\) \u4e2a\u5143\u7d20\u201c\u5411\u5de6\u4e0a\u79fb\u52a8\u201d\uff0c\u4ece\u800c\u4f7f\u7528 \\(O(n^2)\\) \u65f6\u95f4\u3002
    • \u521d\u59cb\u5316\uff1a\u4f20\u5165 \\(n\\) \u4e2a\u9876\u70b9\uff0c\u521d\u59cb\u5316\u957f\u5ea6\u4e3a \\(n\\) \u7684\u9876\u70b9\u5217\u8868 vertices \uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\uff1b\u521d\u59cb\u5316 \\(n \\times n\\) \u5927\u5c0f\u7684\u90bb\u63a5\u77e9\u9635 adjMat \uff0c\u4f7f\u7528 \\(O(n^2)\\) \u65f6\u95f4\u3002
    \u521d\u59cb\u5316\u90bb\u63a5\u77e9\u9635\u6dfb\u52a0\u8fb9\u5220\u9664\u8fb9\u6dfb\u52a0\u9876\u70b9\u5220\u9664\u9876\u70b9

    \u4ee5\u4e0b\u662f\u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u8868\u793a\u56fe\u7684\u5b9e\u73b0\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart graph_adjacency_matrix.java
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nList<Integer> vertices; // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nList<List<Integer>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u65b9\u6cd5 */\npublic GraphAdjMat(int[] vertices, int[][] edges) {\nthis.vertices = new ArrayList<>();\nthis.adjMat = new ArrayList<>();\n// \u6dfb\u52a0\u9876\u70b9\nfor (int val : vertices) {\naddVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor (int[] e : edges) {\naddEdge(e[0], e[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\npublic int size() {\nreturn vertices.size();\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\npublic void addVertex(int val) {\nint n = size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nvertices.add(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nList<Integer> newRow = new ArrayList<>(n);\nfor (int j = 0; j < n; j++) {\nnewRow.add(0);\n}\nadjMat.add(newRow);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor (List<Integer> row : adjMat) {\nrow.add(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\npublic void removeVertex(int index) {\nif (index >= size())\nthrow new IndexOutOfBoundsException();\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nvertices.remove(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nadjMat.remove(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor (List<Integer> row : adjMat) {\nrow.remove(index);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\npublic void addEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\nthrow new IndexOutOfBoundsException();\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nadjMat.get(i).set(j, 1);\nadjMat.get(j).set(i, 1);\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\npublic void removeEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\nthrow new IndexOutOfBoundsException();\nadjMat.get(i).set(j, 0);\nadjMat.get(j).set(i, 0);\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\npublic void print() {\nSystem.out.print(\"\u9876\u70b9\u5217\u8868 = \");\nSystem.out.println(vertices);\nSystem.out.println(\"\u90bb\u63a5\u77e9\u9635 =\");\nPrintUtil.printMatrix(adjMat);\n}\n}\n
    graph_adjacency_matrix.cpp
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nvector<int> vertices;       // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nvector<vector<int>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nGraphAdjMat(const vector<int> &vertices, const vector<vector<int>> &edges) {\n// \u6dfb\u52a0\u9876\u70b9\nfor (int val : vertices) {\naddVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor (const vector<int> &edge : edges) {\naddEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nint size() const {\nreturn vertices.size();\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(int val) {\nint n = size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nvertices.push_back(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nadjMat.emplace_back(vector<int>(n, 0));\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor (vector<int> &row : adjMat) {\nrow.push_back(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(int index) {\nif (index >= size()) {\nthrow out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nvertices.erase(vertices.begin() + index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nadjMat.erase(adjMat.begin() + index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor (vector<int> &row : adjMat) {\nrow.erase(row.begin() + index);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid addEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\nthrow out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nadjMat[i][j] = 1;\nadjMat[j][i] = 1;\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid removeEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\nthrow out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n}\nadjMat[i][j] = 0;\nadjMat[j][i] = 0;\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nvoid print() {\ncout << \"\u9876\u70b9\u5217\u8868 = \";\nprintVector(vertices);\ncout << \"\u90bb\u63a5\u77e9\u9635 =\" << endl;\nprintVectorMatrix(adjMat);\n}\n};\n
    graph_adjacency_matrix.py
    class GraphAdjMat:\n\"\"\"\u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\"\"\"\n# \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nvertices: list[int] = []\n# \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\nadj_mat: list[list[int]] = []\ndef __init__(self, vertices: list[int], edges: list[list[int]]) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.vertices: list[int] = []\nself.adj_mat: list[list[int]] = []\n# \u6dfb\u52a0\u9876\u70b9\nfor val in vertices:\nself.add_vertex(val)\n# \u6dfb\u52a0\u8fb9\n# \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor e in edges:\nself.add_edge(e[0], e[1])\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u9876\u70b9\u6570\u91cf\"\"\"\nreturn len(self.vertices)\ndef add_vertex(self, val: int) -> None:\n\"\"\"\u6dfb\u52a0\u9876\u70b9\"\"\"\nn = self.size()\n# \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nself.vertices.append(val)\n# \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nnew_row = [0] * n\nself.adj_mat.append(new_row)\n# \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor row in self.adj_mat:\nrow.append(0)\ndef remove_vertex(self, index: int) -> None:\n\"\"\"\u5220\u9664\u9876\u70b9\"\"\"\nif index >= self.size():\nraise IndexError()\n# \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nself.vertices.pop(index)\n# \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nself.adj_mat.pop(index)\n# \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor row in self.adj_mat:\nrow.pop(index)\ndef add_edge(self, i: int, j: int) -> None:\n\"\"\"\u6dfb\u52a0\u8fb9\"\"\"\n# \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n# \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:\nraise IndexError()\n# \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nself.adj_mat[i][j] = 1\nself.adj_mat[j][i] = 1\ndef remove_edge(self, i: int, j: int) -> None:\n\"\"\"\u5220\u9664\u8fb9\"\"\"\n# \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n# \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:\nraise IndexError()\nself.adj_mat[i][j] = 0\nself.adj_mat[j][i] = 0\ndef print(self) -> None:\n\"\"\"\u6253\u5370\u90bb\u63a5\u77e9\u9635\"\"\"\nprint(\"\u9876\u70b9\u5217\u8868 =\", self.vertices)\nprint(\"\u90bb\u63a5\u77e9\u9635 =\")\nprint_matrix(self.adj_mat)\n
    graph_adjacency_matrix.go
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\ntype graphAdjMat struct {\n// \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nvertices []int\n// \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\nadjMat [][]int\n}\n/* \u6784\u9020\u51fd\u6570 */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n// \u6dfb\u52a0\u9876\u70b9\nn := len(vertices)\nadjMat := make([][]int, n)\nfor i := range adjMat {\nadjMat[i] = make([]int, n)\n}\n// \u521d\u59cb\u5316\u56fe\ng := &graphAdjMat{\nvertices: vertices,\nadjMat:   adjMat,\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor i := range edges {\ng.addEdge(edges[i][0], edges[i][1])\n}\nreturn g\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc (g *graphAdjMat) size() int {\nreturn len(g.vertices)\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc (g *graphAdjMat) addVertex(val int) {\nn := g.size()\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\ng.vertices = append(g.vertices, val)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nnewRow := make([]int, n)\ng.adjMat = append(g.adjMat, newRow)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor i := range g.adjMat {\ng.adjMat[i] = append(g.adjMat[i], 0)\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nfunc (g *graphAdjMat) removeVertex(index int) {\nif index >= g.size() {\nreturn\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\ng.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\ng.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor i := range g.adjMat {\ng.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfunc (g *graphAdjMat) addEdge(i, j int) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {\nfmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\ng.adjMat[i][j] = 1\ng.adjMat[j][i] = 1\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfunc (g *graphAdjMat) removeEdge(i, j int) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {\nfmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n}\ng.adjMat[i][j] = 0\ng.adjMat[j][i] = 0\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nfunc (g *graphAdjMat) print() {\nfmt.Printf(\"\\t\u9876\u70b9\u5217\u8868 = %v\\n\", g.vertices)\nfmt.Printf(\"\\t\u90bb\u63a5\u77e9\u9635 = \\n\")\nfor i := range g.adjMat {\nfmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n}\n}\n
    graph_adjacency_matrix.js
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nvertices; // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nadjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u51fd\u6570 */\nconstructor(vertices, edges) {\nthis.vertices = [];\nthis.adjMat = [];\n// \u6dfb\u52a0\u9876\u70b9\nfor (const val of vertices) {\nthis.addVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor (const e of edges) {\nthis.addEdge(e[0], e[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nsize() {\nreturn this.vertices.length;\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\naddVertex(val) {\nconst n = this.size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nthis.vertices.push(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nconst newRow = [];\nfor (let j = 0; j < n; j++) {\nnewRow.push(0);\n}\nthis.adjMat.push(newRow);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor (const row of this.adjMat) {\nrow.push(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nremoveVertex(index) {\nif (index >= this.size()) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nthis.vertices.splice(index, 1);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nthis.adjMat.splice(index, 1);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor (const row of this.adjMat) {\nrow.splice(index, 1);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\naddEdge(i, j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nthis.adjMat[i][j] = 1;\nthis.adjMat[j][i] = 1;\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nremoveEdge(i, j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\nthis.adjMat[i][j] = 0;\nthis.adjMat[j][i] = 0;\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nprint() {\nconsole.log('\u9876\u70b9\u5217\u8868 = ', this.vertices);\nconsole.log('\u90bb\u63a5\u77e9\u9635 =', this.adjMat);\n}\n}\n
    graph_adjacency_matrix.ts
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nvertices: number[]; // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nadjMat: number[][]; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u51fd\u6570 */\nconstructor(vertices: number[], edges: number[][]) {\nthis.vertices = [];\nthis.adjMat = [];\n// \u6dfb\u52a0\u9876\u70b9\nfor (const val of vertices) {\nthis.addVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor (const e of edges) {\nthis.addEdge(e[0], e[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nsize(): number {\nreturn this.vertices.length;\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\naddVertex(val: number): void {\nconst n: number = this.size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nthis.vertices.push(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nconst newRow: number[] = [];\nfor (let j: number = 0; j < n; j++) {\nnewRow.push(0);\n}\nthis.adjMat.push(newRow);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor (const row of this.adjMat) {\nrow.push(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nremoveVertex(index: number): void {\nif (index >= this.size()) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nthis.vertices.splice(index, 1);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nthis.adjMat.splice(index, 1);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor (const row of this.adjMat) {\nrow.splice(index, 1);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\naddEdge(i: number, j: number): void {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nthis.adjMat[i][j] = 1;\nthis.adjMat[j][i] = 1;\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nremoveEdge(i: number, j: number): void {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\nthis.adjMat[i][j] = 0;\nthis.adjMat[j][i] = 0;\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nprint(): void {\nconsole.log('\u9876\u70b9\u5217\u8868 = ', this.vertices);\nconsole.log('\u90bb\u63a5\u77e9\u9635 =', this.adjMat);\n}\n}\n
    graph_adjacency_matrix.c
    [class]{graphAdjMat}-[func]{}\n
    graph_adjacency_matrix.cs
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nList<int> vertices;     // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nList<List<int>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u51fd\u6570 */\npublic GraphAdjMat(int[] vertices, int[][] edges) {\nthis.vertices = new List<int>();\nthis.adjMat = new List<List<int>>();\n// \u6dfb\u52a0\u9876\u70b9\nforeach (int val in vertices) {\naddVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nforeach (int[] e in edges) {\naddEdge(e[0], e[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\npublic int size() {\nreturn vertices.Count;\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\npublic void addVertex(int val) {\nint n = size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nvertices.Add(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nList<int> newRow = new List<int>(n);\nfor (int j = 0; j < n; j++) {\nnewRow.Add(0);\n}\nadjMat.Add(newRow);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nforeach (List<int> row in adjMat) {\nrow.Add(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\npublic void removeVertex(int index) {\nif (index >= size())\nthrow new IndexOutOfRangeException();\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nvertices.RemoveAt(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nadjMat.RemoveAt(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nforeach (List<int> row in adjMat) {\nrow.RemoveAt(index);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\npublic void addEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\nthrow new IndexOutOfRangeException();\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nadjMat[i][j] = 1;\nadjMat[j][i] = 1;\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\npublic void removeEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\nthrow new IndexOutOfRangeException();\nadjMat[i][j] = 0;\nadjMat[j][i] = 0;\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\npublic void print() {\nConsole.Write(\"\u9876\u70b9\u5217\u8868 = \");\nPrintUtil.PrintList(vertices);\nConsole.WriteLine(\"\u90bb\u63a5\u77e9\u9635 =\");\nPrintUtil.PrintMatrix(adjMat);\n}\n}\n
    graph_adjacency_matrix.swift
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nprivate var vertices: [Int] // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nprivate var adjMat: [[Int]] // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u65b9\u6cd5 */\ninit(vertices: [Int], edges: [[Int]]) {\nself.vertices = []\nadjMat = []\n// \u6dfb\u52a0\u9876\u70b9\nfor val in vertices {\naddVertex(val: val)\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor e in edges {\naddEdge(i: e[0], j: e[1])\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc size() -> Int {\nvertices.count\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc addVertex(val: Int) {\nlet n = size()\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nvertices.append(val)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nlet newRow = Array(repeating: 0, count: n)\nadjMat.append(newRow)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor i in adjMat.indices {\nadjMat[i].append(0)\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nfunc removeVertex(index: Int) {\nif index >= size() {\nfatalError(\"\u8d8a\u754c\")\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nvertices.remove(at: index)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nadjMat.remove(at: index)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor i in adjMat.indices {\nadjMat[i].remove(at: index)\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfunc addEdge(i: Int, j: Int) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 || j < 0 || i >= size() || j >= size() || i == j {\nfatalError(\"\u8d8a\u754c\")\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nadjMat[i][j] = 1\nadjMat[j][i] = 1\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfunc removeEdge(i: Int, j: Int) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 || j < 0 || i >= size() || j >= size() || i == j {\nfatalError(\"\u8d8a\u754c\")\n}\nadjMat[i][j] = 0\nadjMat[j][i] = 0\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nfunc print() {\nSwift.print(\"\u9876\u70b9\u5217\u8868 = \", terminator: \"\")\nSwift.print(vertices)\nSwift.print(\"\u90bb\u63a5\u77e9\u9635 =\")\nPrintUtil.printMatrix(matrix: adjMat)\n}\n}\n
    graph_adjacency_matrix.zig
    \n
    graph_adjacency_matrix.dart
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nList<int> vertices = []; // \u9876\u70b9\u5143\u7d20\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nList<List<int>> adjMat = []; //\u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u65b9\u6cd5 */\nGraphAdjMat(List<int> vertices, List<List<int>> edges) {\nthis.vertices = [];\nthis.adjMat = [];\n// \u6dfb\u52a0\u9876\u70b9\nfor (int val in vertices) {\naddVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor (List<int> e in edges) {\naddEdge(e[0], e[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nint size() {\nreturn vertices.length;\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(int val) {\nint n = size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nvertices.add(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nList<int> newRow = List.filled(n, 0, growable: true);\nadjMat.add(newRow);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor (List<int> row in adjMat) {\nrow.add(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(int index) {\nif (index >= size()) {\nthrow IndexError;\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nvertices.removeAt(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nadjMat.removeAt(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor (List<int> row in adjMat) {\nrow.removeAt(index);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid addEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\nthrow IndexError;\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nadjMat[i][j] = 1;\nadjMat[j][i] = 1;\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid removeEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\nthrow IndexError;\n}\nadjMat[i][j] = 0;\nadjMat[j][i] = 0;\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nvoid printAdjMat() {\nprint(\"\u9876\u70b9\u5217\u8868 = $vertices\");\nprint(\"\u90bb\u63a5\u77e9\u9635 = \");\nprintMatrix(adjMat);\n}\n}\n
    "},{"location":"chapter_graph/graph_operations/#922","title":"9.2.2. \u00a0 \u57fa\u4e8e\u90bb\u63a5\u8868\u7684\u5b9e\u73b0","text":"

    \u8bbe\u65e0\u5411\u56fe\u7684\u9876\u70b9\u603b\u6570\u4e3a \\(n\\) \u3001\u8fb9\u603b\u6570\u4e3a \\(m\\) \uff0c\u5219\u6709\uff1a

    • \u6dfb\u52a0\u8fb9\uff1a\u5728\u9876\u70b9\u5bf9\u5e94\u94fe\u8868\u7684\u672b\u5c3e\u6dfb\u52a0\u8fb9\u5373\u53ef\uff0c\u4f7f\u7528 \\(O(1)\\) \u65f6\u95f4\u3002\u56e0\u4e3a\u662f\u65e0\u5411\u56fe\uff0c\u6240\u4ee5\u9700\u8981\u540c\u65f6\u6dfb\u52a0\u4e24\u4e2a\u65b9\u5411\u7684\u8fb9\u3002
    • \u5220\u9664\u8fb9\uff1a\u5728\u9876\u70b9\u5bf9\u5e94\u94fe\u8868\u4e2d\u67e5\u627e\u5e76\u5220\u9664\u6307\u5b9a\u8fb9\uff0c\u4f7f\u7528 \\(O(m)\\) \u65f6\u95f4\u3002\u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u9700\u8981\u540c\u65f6\u5220\u9664\u4e24\u4e2a\u65b9\u5411\u7684\u8fb9\u3002
    • \u6dfb\u52a0\u9876\u70b9\uff1a\u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u94fe\u8868\uff0c\u5e76\u5c06\u65b0\u589e\u9876\u70b9\u4f5c\u4e3a\u94fe\u8868\u5934\u8282\u70b9\uff0c\u4f7f\u7528 \\(O(1)\\) \u65f6\u95f4\u3002
    • \u5220\u9664\u9876\u70b9\uff1a\u9700\u904d\u5386\u6574\u4e2a\u90bb\u63a5\u8868\uff0c\u5220\u9664\u5305\u542b\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u8fb9\uff0c\u4f7f\u7528 \\(O(n + m)\\) \u65f6\u95f4\u3002
    • \u521d\u59cb\u5316\uff1a\u5728\u90bb\u63a5\u8868\u4e2d\u521b\u5efa \\(n\\) \u4e2a\u9876\u70b9\u548c \\(2m\\) \u6761\u8fb9\uff0c\u4f7f\u7528 \\(O(n + m)\\) \u65f6\u95f4\u3002
    \u521d\u59cb\u5316\u90bb\u63a5\u8868\u6dfb\u52a0\u8fb9\u5220\u9664\u8fb9\u6dfb\u52a0\u9876\u70b9\u5220\u9664\u9876\u70b9

    \u4ee5\u4e0b\u662f\u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u56fe\u7684\u4ee3\u7801\u793a\u4f8b\u3002\u7ec6\u5fc3\u7684\u540c\u5b66\u53ef\u80fd\u6ce8\u610f\u5230\uff0c\u6211\u4eec\u5728\u90bb\u63a5\u8868\u4e2d\u4f7f\u7528 Vertex \u8282\u70b9\u7c7b\u6765\u8868\u793a\u9876\u70b9\uff0c\u8fd9\u6837\u505a\u7684\u539f\u56e0\u6709\uff1a

    • \u5982\u679c\u6211\u4eec\u9009\u62e9\u901a\u8fc7\u9876\u70b9\u503c\u6765\u533a\u5206\u4e0d\u540c\u9876\u70b9\uff0c\u90a3\u4e48\u503c\u91cd\u590d\u7684\u9876\u70b9\u5c06\u65e0\u6cd5\u88ab\u533a\u5206\u3002
    • \u5982\u679c\u7c7b\u4f3c\u90bb\u63a5\u77e9\u9635\u90a3\u6837\uff0c\u4f7f\u7528\u9876\u70b9\u5217\u8868\u7d22\u5f15\u6765\u533a\u5206\u4e0d\u540c\u9876\u70b9\u3002\u90a3\u4e48\uff0c\u5047\u8bbe\u6211\u4eec\u60f3\u8981\u5220\u9664\u7d22\u5f15\u4e3a \\(i\\) \u7684\u9876\u70b9\uff0c\u5219\u9700\u8981\u904d\u5386\u6574\u4e2a\u90bb\u63a5\u8868\uff0c\u5c06\u5176\u4e2d \\(> i\\) \u7684\u7d22\u5f15\u5168\u90e8\u51cf \\(1\\) \uff0c\u8fd9\u6837\u64cd\u4f5c\u6548\u7387\u8f83\u4f4e\u3002
    • \u56e0\u6b64\u6211\u4eec\u8003\u8651\u5f15\u5165\u9876\u70b9\u7c7b Vertex \uff0c\u4f7f\u5f97\u6bcf\u4e2a\u9876\u70b9\u90fd\u662f\u552f\u4e00\u7684\u5bf9\u8c61\uff0c\u6b64\u65f6\u5220\u9664\u9876\u70b9\u65f6\u5c31\u65e0\u9700\u6539\u52a8\u5176\u4f59\u9876\u70b9\u4e86\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart graph_adjacency_list.java
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nMap<Vertex, List<Vertex>> adjList;\n/* \u6784\u9020\u65b9\u6cd5 */\npublic GraphAdjList(Vertex[][] edges) {\nthis.adjList = new HashMap<>();\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor (Vertex[] edge : edges) {\naddVertex(edge[0]);\naddVertex(edge[1]);\naddEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\npublic int size() {\nreturn adjList.size();\n}\n/* \u6dfb\u52a0\u8fb9 */\npublic void addEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\nthrow new IllegalArgumentException();\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nadjList.get(vet1).add(vet2);\nadjList.get(vet2).add(vet1);\n}\n/* \u5220\u9664\u8fb9 */\npublic void removeEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\nthrow new IllegalArgumentException();\n// \u5220\u9664\u8fb9 vet1 - vet2\nadjList.get(vet1).remove(vet2);\nadjList.get(vet2).remove(vet1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\npublic void addVertex(Vertex vet) {\nif (adjList.containsKey(vet))\nreturn;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nadjList.put(vet, new ArrayList<>());\n}\n/* \u5220\u9664\u9876\u70b9 */\npublic void removeVertex(Vertex vet) {\nif (!adjList.containsKey(vet))\nthrow new IllegalArgumentException();\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nadjList.remove(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor (List<Vertex> list : adjList.values()) {\nlist.remove(vet);\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\npublic void print() {\nSystem.out.println(\"\u90bb\u63a5\u8868 =\");\nfor (Map.Entry<Vertex, List<Vertex>> pair : adjList.entrySet()) {\nList<Integer> tmp = new ArrayList<>();\nfor (Vertex vertex : pair.getValue())\ntmp.add(vertex.val);\nSystem.out.println(pair.getKey().val + \": \" + tmp + \",\");\n}\n}\n}\n
    graph_adjacency_list.cpp
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\npublic:\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nunordered_map<Vertex *, vector<Vertex *>> adjList;\n/* \u5728 vector \u4e2d\u5220\u9664\u6307\u5b9a\u8282\u70b9 */\nvoid remove(vector<Vertex *> &vec, Vertex *vet) {\nfor (int i = 0; i < vec.size(); i++) {\nif (vec[i] == vet) {\nvec.erase(vec.begin() + i);\nbreak;\n}\n}\n}\n/* \u6784\u9020\u65b9\u6cd5 */\nGraphAdjList(const vector<vector<Vertex *>> &edges) {\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor (const vector<Vertex *> &edge : edges) {\naddVertex(edge[0]);\naddVertex(edge[1]);\naddEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nint size() {\nreturn adjList.size();\n}\n/* \u6dfb\u52a0\u8fb9 */\nvoid addEdge(Vertex *vet1, Vertex *vet2) {\nif (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\nthrow invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nadjList[vet1].push_back(vet2);\nadjList[vet2].push_back(vet1);\n}\n/* \u5220\u9664\u8fb9 */\nvoid removeEdge(Vertex *vet1, Vertex *vet2) {\nif (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\nthrow invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n// \u5220\u9664\u8fb9 vet1 - vet2\nremove(adjList[vet1], vet2);\nremove(adjList[vet2], vet1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(Vertex *vet) {\nif (adjList.count(vet))\nreturn;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nadjList[vet] = vector<Vertex *>();\n}\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(Vertex *vet) {\nif (!adjList.count(vet))\nthrow invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nadjList.erase(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor (auto &adj : adjList) {\nremove(adj.second, vet);\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nvoid print() {\ncout << \"\u90bb\u63a5\u8868 =\" << endl;\nfor (auto &adj : adjList) {\nconst auto &key = adj.first;\nconst auto &vec = adj.second;\ncout << key->val << \": \";\nprintVector(vetsToVals(vec));\n}\n}\n};\n
    graph_adjacency_list.py
    class GraphAdjList:\n\"\"\"\u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\"\"\"\ndef __init__(self, edges: list[list[Vertex]]) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n# \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nself.adj_list = dict[Vertex, Vertex]()\n# \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor edge in edges:\nself.add_vertex(edge[0])\nself.add_vertex(edge[1])\nself.add_edge(edge[0], edge[1])\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u9876\u70b9\u6570\u91cf\"\"\"\nreturn len(self.adj_list)\ndef add_edge(self, vet1: Vertex, vet2: Vertex) -> None:\n\"\"\"\u6dfb\u52a0\u8fb9\"\"\"\nif vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\nraise ValueError()\n# \u6dfb\u52a0\u8fb9 vet1 - vet2\nself.adj_list[vet1].append(vet2)\nself.adj_list[vet2].append(vet1)\ndef remove_edge(self, vet1: Vertex, vet2: Vertex) -> None:\n\"\"\"\u5220\u9664\u8fb9\"\"\"\nif vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\nraise ValueError()\n# \u5220\u9664\u8fb9 vet1 - vet2\nself.adj_list[vet1].remove(vet2)\nself.adj_list[vet2].remove(vet1)\ndef add_vertex(self, vet: Vertex) -> None:\n\"\"\"\u6dfb\u52a0\u9876\u70b9\"\"\"\nif vet in self.adj_list:\nreturn\n# \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nself.adj_list[vet] = []\ndef remove_vertex(self, vet: Vertex) -> None:\n\"\"\"\u5220\u9664\u9876\u70b9\"\"\"\nif vet not in self.adj_list:\nraise ValueError()\n# \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nself.adj_list.pop(vet)\n# \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor vertex in self.adj_list:\nif vet in self.adj_list[vertex]:\nself.adj_list[vertex].remove(vet)\ndef print(self) -> None:\n\"\"\"\u6253\u5370\u90bb\u63a5\u8868\"\"\"\nprint(\"\u90bb\u63a5\u8868 =\")\nfor vertex in self.adj_list:\ntmp = [v.val for v in self.adj_list[vertex]]\nprint(f\"{vertex.val}: {tmp},\")\n
    graph_adjacency_list.go
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\ntype graphAdjList struct {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nadjList map[Vertex][]Vertex\n}\n/* \u6784\u9020\u51fd\u6570 */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\ng := &graphAdjList{\nadjList: make(map[Vertex][]Vertex),\n}\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor _, edge := range edges {\ng.addVertex(edge[0])\ng.addVertex(edge[1])\ng.addEdge(edge[0], edge[1])\n}\nreturn g\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc (g *graphAdjList) size() int {\nreturn len(g.adjList)\n}\n/* \u6dfb\u52a0\u8fb9 */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n_, ok1 := g.adjList[vet1]\n_, ok2 := g.adjList[vet2]\nif !ok1 || !ok2 || vet1 == vet2 {\npanic(\"error\")\n}\n// \u6dfb\u52a0\u8fb9 vet1 - vet2, \u6dfb\u52a0\u533f\u540d struct{},\ng.adjList[vet1] = append(g.adjList[vet1], vet2)\ng.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n/* \u5220\u9664\u8fb9 */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n_, ok1 := g.adjList[vet1]\n_, ok2 := g.adjList[vet2]\nif !ok1 || !ok2 || vet1 == vet2 {\npanic(\"error\")\n}\n// \u5220\u9664\u8fb9 vet1 - vet2\ng.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\ng.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n_, ok := g.adjList[vet]\nif ok {\nreturn\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\ng.adjList[vet] = make([]Vertex, 0)\n}\n/* \u5220\u9664\u9876\u70b9 */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n_, ok := g.adjList[vet]\nif !ok {\npanic(\"error\")\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\ndelete(g.adjList, vet)\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor v, list := range g.adjList {\ng.adjList[v] = DeleteSliceElms(list, vet)\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nfunc (g *graphAdjList) print() {\nvar builder strings.Builder\nfmt.Printf(\"\u90bb\u63a5\u8868 = \\n\")\nfor k, v := range g.adjList {\nbuilder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\nfor _, vet := range v {\nbuilder.WriteString(strconv.Itoa(vet.Val) + \" \")\n}\nfmt.Println(builder.String())\nbuilder.Reset()\n}\n}\n
    graph_adjacency_list.js
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nadjList;\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor(edges) {\nthis.adjList = new Map();\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor (const edge of edges) {\nthis.addVertex(edge[0]);\nthis.addVertex(edge[1]);\nthis.addEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nsize() {\nreturn this.adjList.size;\n}\n/* \u6dfb\u52a0\u8fb9 */\naddEdge(vet1, vet2) {\nif (\n!this.adjList.has(vet1) ||\n!this.adjList.has(vet2) ||\nvet1 === vet2\n) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nthis.adjList.get(vet1).push(vet2);\nthis.adjList.get(vet2).push(vet1);\n}\n/* \u5220\u9664\u8fb9 */\nremoveEdge(vet1, vet2) {\nif (\n!this.adjList.has(vet1) ||\n!this.adjList.has(vet2) ||\nvet1 === vet2\n) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u5220\u9664\u8fb9 vet1 - vet2\nthis.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\nthis.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\naddVertex(vet) {\nif (this.adjList.has(vet)) return;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nthis.adjList.set(vet, []);\n}\n/* \u5220\u9664\u9876\u70b9 */\nremoveVertex(vet) {\nif (!this.adjList.has(vet)) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nthis.adjList.delete(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor (let set of this.adjList.values()) {\nconst index = set.indexOf(vet);\nif (index > -1) {\nset.splice(index, 1);\n}\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nprint() {\nconsole.log('\u90bb\u63a5\u8868 =');\nfor (const [key, value] of this.adjList) {\nconst tmp = [];\nfor (const vertex of value) {\ntmp.push(vertex.val);\n}\nconsole.log(key.val + ': ' + tmp.join());\n}\n}\n}\n
    graph_adjacency_list.ts
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nadjList: Map<Vertex, Vertex[]>;\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor(edges: Vertex[][]) {\nthis.adjList = new Map();\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor (const edge of edges) {\nthis.addVertex(edge[0]);\nthis.addVertex(edge[1]);\nthis.addEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nsize(): number {\nreturn this.adjList.size;\n}\n/* \u6dfb\u52a0\u8fb9 */\naddEdge(vet1: Vertex, vet2: Vertex): void {\nif (\n!this.adjList.has(vet1) ||\n!this.adjList.has(vet2) ||\nvet1 === vet2\n) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nthis.adjList.get(vet1).push(vet2);\nthis.adjList.get(vet2).push(vet1);\n}\n/* \u5220\u9664\u8fb9 */\nremoveEdge(vet1: Vertex, vet2: Vertex): void {\nif (\n!this.adjList.has(vet1) ||\n!this.adjList.has(vet2) ||\nvet1 === vet2\n) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u5220\u9664\u8fb9 vet1 - vet2\nthis.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\nthis.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\naddVertex(vet: Vertex): void {\nif (this.adjList.has(vet)) return;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nthis.adjList.set(vet, []);\n}\n/* \u5220\u9664\u9876\u70b9 */\nremoveVertex(vet: Vertex): void {\nif (!this.adjList.has(vet)) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nthis.adjList.delete(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor (let set of this.adjList.values()) {\nconst index: number = set.indexOf(vet);\nif (index > -1) {\nset.splice(index, 1);\n}\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nprint(): void {\nconsole.log('\u90bb\u63a5\u8868 =');\nfor (const [key, value] of this.adjList.entries()) {\nconst tmp = [];\nfor (const vertex of value) {\ntmp.push(vertex.val);\n}\nconsole.log(key.val + ': ' + tmp.join());\n}\n}\n}\n
    graph_adjacency_list.c
    [class]{graphAdjList}-[func]{}\n
    graph_adjacency_list.cs
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\npublic Dictionary<Vertex, List<Vertex>> adjList;\n/* \u6784\u9020\u51fd\u6570 */\npublic GraphAdjList(Vertex[][] edges) {\nthis.adjList = new Dictionary<Vertex, List<Vertex>>();\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nforeach (Vertex[] edge in edges) {\naddVertex(edge[0]);\naddVertex(edge[1]);\naddEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\npublic int size() {\nreturn adjList.Count;\n}\n/* \u6dfb\u52a0\u8fb9 */\npublic void addEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\nthrow new InvalidOperationException();\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nadjList[vet1].Add(vet2);\nadjList[vet2].Add(vet1);\n}\n/* \u5220\u9664\u8fb9 */\npublic void removeEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\nthrow new InvalidOperationException();\n// \u5220\u9664\u8fb9 vet1 - vet2\nadjList[vet1].Remove(vet2);\nadjList[vet2].Remove(vet1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\npublic void addVertex(Vertex vet) {\nif (adjList.ContainsKey(vet))\nreturn;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nadjList.Add(vet, new List<Vertex>());\n}\n/* \u5220\u9664\u9876\u70b9 */\npublic void removeVertex(Vertex vet) {\nif (!adjList.ContainsKey(vet))\nthrow new InvalidOperationException();\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nadjList.Remove(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nforeach (List<Vertex> list in adjList.Values) {\nlist.Remove(vet);\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\npublic void print() {\nConsole.WriteLine(\"\u90bb\u63a5\u8868 =\");\nforeach (KeyValuePair<Vertex, List<Vertex>> pair in adjList) {\nList<int> tmp = new List<int>();\nforeach (Vertex vertex in pair.Value)\ntmp.Add(vertex.val);\nConsole.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n}\n}\n}\n
    graph_adjacency_list.swift
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\npublic private(set) var adjList: [Vertex: [Vertex]]\n/* \u6784\u9020\u65b9\u6cd5 */\npublic init(edges: [[Vertex]]) {\nadjList = [:]\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor edge in edges {\naddVertex(vet: edge[0])\naddVertex(vet: edge[1])\naddEdge(vet1: edge[0], vet2: edge[1])\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\npublic func size() -> Int {\nadjList.count\n}\n/* \u6dfb\u52a0\u8fb9 */\npublic func addEdge(vet1: Vertex, vet2: Vertex) {\nif adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\nfatalError(\"\u53c2\u6570\u9519\u8bef\")\n}\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nadjList[vet1]?.append(vet2)\nadjList[vet2]?.append(vet1)\n}\n/* \u5220\u9664\u8fb9 */\npublic func removeEdge(vet1: Vertex, vet2: Vertex) {\nif adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\nfatalError(\"\u53c2\u6570\u9519\u8bef\")\n}\n// \u5220\u9664\u8fb9 vet1 - vet2\nadjList[vet1]?.removeAll(where: { $0 == vet2 })\nadjList[vet2]?.removeAll(where: { $0 == vet1 })\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\npublic func addVertex(vet: Vertex) {\nif adjList[vet] != nil {\nreturn\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nadjList[vet] = []\n}\n/* \u5220\u9664\u9876\u70b9 */\npublic func removeVertex(vet: Vertex) {\nif adjList[vet] == nil {\nfatalError(\"\u53c2\u6570\u9519\u8bef\")\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nadjList.removeValue(forKey: vet)\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor key in adjList.keys {\nadjList[key]?.removeAll(where: { $0 == vet })\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\npublic func print() {\nSwift.print(\"\u90bb\u63a5\u8868 =\")\nfor pair in adjList {\nvar tmp: [Int] = []\nfor vertex in pair.value {\ntmp.append(vertex.val)\n}\nSwift.print(\"\\(pair.key.val): \\(tmp),\")\n}\n}\n}\n
    graph_adjacency_list.zig
    [class]{GraphAdjList}-[func]{}\n
    graph_adjacency_list.dart
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nMap<Vertex, List<Vertex>> adjList = {};\n/* \u6784\u9020\u65b9\u6cd5 */\nGraphAdjList(List<List<Vertex>> edges) {\nfor (List<Vertex> edge in edges) {\naddVertex(edge[0]);\naddVertex(edge[1]);\naddEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nint size() {\nreturn adjList.length;\n}\n/* \u6dfb\u52a0\u8fb9 */\nvoid addEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.containsKey(vet1) ||\n!adjList.containsKey(vet2) ||\nvet1 == vet2) {\nthrow ArgumentError;\n}\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nadjList[vet1]!.add(vet2);\nadjList[vet2]!.add(vet1);\n}\n/* \u5220\u9664\u8fb9 */\nvoid removeEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.containsKey(vet1) ||\n!adjList.containsKey(vet2) ||\nvet1 == vet2) {\nthrow ArgumentError;\n}\n// \u5220\u9664\u8fb9 vet1 - vet2\nadjList[vet1]!.remove(vet2);\nadjList[vet2]!.remove(vet1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(Vertex vet) {\nif (adjList.containsKey(vet)) return;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nadjList[vet] = [];\n}\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(Vertex vet) {\nif (!adjList.containsKey(vet)) {\nthrow ArgumentError;\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nadjList.remove(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nadjList.forEach((key, value) {\nvalue.remove(vet);\n});\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nvoid printAdjList() {\nprint(\"\u90bb\u63a5\u8868 =\");\nadjList.forEach((key, value) {\nList<int> tmp = [];\nfor (Vertex vertex in value) {\ntmp.add(vertex.val);\n}\nprint(\"${key.val}: $tmp,\");\n});\n}\n}\n
    "},{"location":"chapter_graph/graph_operations/#923","title":"9.2.3. \u00a0 \u6548\u7387\u5bf9\u6bd4","text":"

    \u8bbe\u56fe\u4e2d\u5171\u6709 \\(n\\) \u4e2a\u9876\u70b9\u548c \\(m\\) \u6761\u8fb9\uff0c\u4e0b\u8868\u4e3a\u90bb\u63a5\u77e9\u9635\u548c\u90bb\u63a5\u8868\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u6548\u7387\u5bf9\u6bd4\u3002

    \u90bb\u63a5\u77e9\u9635 \u90bb\u63a5\u8868\uff08\u94fe\u8868\uff09 \u90bb\u63a5\u8868\uff08\u54c8\u5e0c\u8868\uff09 \u5224\u65ad\u662f\u5426\u90bb\u63a5 \\(O(1)\\) \\(O(m)\\) \\(O(1)\\) \u6dfb\u52a0\u8fb9 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) \u5220\u9664\u8fb9 \\(O(1)\\) \\(O(m)\\) \\(O(1)\\) \u6dfb\u52a0\u9876\u70b9 \\(O(n)\\) \\(O(1)\\) \\(O(1)\\) \u5220\u9664\u9876\u70b9 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n)\\) \u5185\u5b58\u7a7a\u95f4\u5360\u7528 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n + m)\\)

    \u89c2\u5bdf\u4e0a\u8868\uff0c\u4f3c\u4e4e\u90bb\u63a5\u8868\uff08\u54c8\u5e0c\u8868\uff09\u7684\u65f6\u95f4\u4e0e\u7a7a\u95f4\u6548\u7387\u6700\u4f18\u3002\u4f46\u5b9e\u9645\u4e0a\uff0c\u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u64cd\u4f5c\u8fb9\u7684\u6548\u7387\u66f4\u9ad8\uff0c\u53ea\u9700\u8981\u4e00\u6b21\u6570\u7ec4\u8bbf\u95ee\u6216\u8d4b\u503c\u64cd\u4f5c\u5373\u53ef\u3002\u7efc\u5408\u6765\u770b\uff0c\u90bb\u63a5\u77e9\u9635\u4f53\u73b0\u4e86\u201c\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u201d\u7684\u539f\u5219\uff0c\u800c\u90bb\u63a5\u8868\u4f53\u73b0\u4e86\u201c\u4ee5\u65f6\u95f4\u6362\u7a7a\u95f4\u201d\u7684\u539f\u5219\u3002

    "},{"location":"chapter_graph/graph_traversal/","title":"9.3. \u00a0 \u56fe\u7684\u904d\u5386","text":"

    \u56fe\u4e0e\u6811\u7684\u5173\u7cfb

    \u6811\u4ee3\u8868\u7684\u662f\u201c\u4e00\u5bf9\u591a\u201d\u7684\u5173\u7cfb\uff0c\u800c\u56fe\u5219\u5177\u6709\u66f4\u9ad8\u7684\u81ea\u7531\u5ea6\uff0c\u53ef\u4ee5\u8868\u793a\u4efb\u610f\u7684\u201c\u591a\u5bf9\u591a\u201d\u5173\u7cfb\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u628a\u6811\u770b\u4f5c\u662f\u56fe\u7684\u4e00\u79cd\u7279\u4f8b\u3002\u663e\u7136\uff0c\u6811\u7684\u904d\u5386\u64cd\u4f5c\u4e5f\u662f\u56fe\u7684\u904d\u5386\u64cd\u4f5c\u7684\u4e00\u79cd\u7279\u4f8b\uff0c\u5efa\u8bae\u4f60\u5728\u5b66\u4e60\u672c\u7ae0\u8282\u65f6\u878d\u4f1a\u8d2f\u901a\u4e24\u8005\u7684\u6982\u5ff5\u4e0e\u5b9e\u73b0\u65b9\u6cd5\u3002

    \u300c\u56fe\u300d\u548c\u300c\u6811\u300d\u90fd\u662f\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u90fd\u9700\u8981\u4f7f\u7528\u300c\u641c\u7d22\u7b97\u6cd5\u300d\u6765\u5b9e\u73b0\u904d\u5386\u64cd\u4f5c\u3002

    \u4e0e\u6811\u7c7b\u4f3c\uff0c\u56fe\u7684\u904d\u5386\u65b9\u5f0f\u4e5f\u53ef\u5206\u4e3a\u4e24\u79cd\uff0c\u5373\u300c\u5e7f\u5ea6\u4f18\u5148\u904d\u5386 Breadth-First Traversal\u300d\u548c\u300c\u6df1\u5ea6\u4f18\u5148\u904d\u5386 Depth-First Traversal\u300d\uff0c\u4e5f\u79f0\u4e3a\u300c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22 Breadth-First Search\u300d\u548c\u300c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22 Depth-First Search\u300d\uff0c\u7b80\u79f0 BFS \u548c DFS\u3002

    "},{"location":"chapter_graph/graph_traversal/#931","title":"9.3.1. \u00a0 \u5e7f\u5ea6\u4f18\u5148\u904d\u5386","text":"

    \u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u662f\u4e00\u79cd\u7531\u8fd1\u53ca\u8fdc\u7684\u904d\u5386\u65b9\u5f0f\uff0c\u4ece\u8ddd\u79bb\u6700\u8fd1\u7684\u9876\u70b9\u5f00\u59cb\u8bbf\u95ee\uff0c\u5e76\u4e00\u5c42\u5c42\u5411\u5916\u6269\u5f20\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u4ece\u67d0\u4e2a\u9876\u70b9\u51fa\u53d1\uff0c\u5148\u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\uff0c\u7136\u540e\u904d\u5386\u4e0b\u4e00\u4e2a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\uff0c\u4ee5\u6b64\u7c7b\u63a8\uff0c\u76f4\u81f3\u6240\u6709\u9876\u70b9\u8bbf\u95ee\u5b8c\u6bd5\u3002

    Fig. \u56fe\u7684\u5e7f\u5ea6\u4f18\u5148\u904d\u5386

    "},{"location":"chapter_graph/graph_traversal/#_1","title":"\u7b97\u6cd5\u5b9e\u73b0","text":"

    BFS \u901a\u5e38\u501f\u52a9\u300c\u961f\u5217\u300d\u6765\u5b9e\u73b0\u3002\u961f\u5217\u5177\u6709\u201c\u5148\u5165\u5148\u51fa\u201d\u7684\u6027\u8d28\uff0c\u8fd9\u4e0e BFS \u7684\u201c\u7531\u8fd1\u53ca\u8fdc\u201d\u7684\u601d\u60f3\u5f02\u66f2\u540c\u5de5\u3002

    1. \u5c06\u904d\u5386\u8d77\u59cb\u9876\u70b9 startVet \u52a0\u5165\u961f\u5217\uff0c\u5e76\u5f00\u542f\u5faa\u73af\uff1b
    2. \u5728\u5faa\u73af\u7684\u6bcf\u8f6e\u8fed\u4ee3\u4e2d\uff0c\u5f39\u51fa\u961f\u9996\u9876\u70b9\u5e76\u8bb0\u5f55\u8bbf\u95ee\uff0c\u7136\u540e\u5c06\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\u52a0\u5165\u5230\u961f\u5217\u5c3e\u90e8\uff1b
    3. \u5faa\u73af\u6b65\u9aa4 2. \uff0c\u76f4\u5230\u6240\u6709\u9876\u70b9\u88ab\u8bbf\u95ee\u5b8c\u6210\u540e\u7ed3\u675f\uff1b

    \u4e3a\u4e86\u9632\u6b62\u91cd\u590d\u904d\u5386\u9876\u70b9\uff0c\u6211\u4eec\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868 visited \u6765\u8bb0\u5f55\u54ea\u4e9b\u8282\u70b9\u5df2\u88ab\u8bbf\u95ee\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart graph_bfs.java
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nList<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = new ArrayList<>();\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nSet<Vertex> visited = new HashSet<>() {{ add(startVet); }};\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nQueue<Vertex> que = new LinkedList<>() {{ offer(startVet); }};\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (!que.isEmpty()) {\nVertex vet = que.poll(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.add(vet);            // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (Vertex adjVet : graph.adjList.get(vet)) {\nif (visited.contains(adjVet))\ncontinue;        // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nque.offer(adjVet);   // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n
    graph_bfs.cpp
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nvector<Vertex *> graphBFS(GraphAdjList &graph, Vertex *startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nvector<Vertex *> res;\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nunordered_set<Vertex *> visited = {startVet};\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nqueue<Vertex *> que;\nque.push(startVet);\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (!que.empty()) {\nVertex *vet = que.front();\nque.pop();          // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.push_back(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (auto adjVet : graph.adjList[vet]) {\nif (visited.count(adjVet))\ncontinue;            // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nque.push(adjVet);        // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.emplace(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n
    graph_bfs.py
    def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:\n\"\"\"\u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS\"\"\"\n# \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n# \u9876\u70b9\u904d\u5386\u5e8f\u5217\nres = []\n# \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvisited = set[Vertex]([start_vet])\n# \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nque = deque[Vertex]([start_vet])\n# \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile len(que) > 0:\nvet = que.popleft()  # \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.append(vet)  # \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n# \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor adj_vet in graph.adj_list[vet]:\nif adj_vet in visited:\ncontinue  # \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nque.append(adj_vet)  # \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.add(adj_vet)  # \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n# \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res\n
    graph_bfs.go
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunc graphBFS(g *graphAdjList, startVet Vertex) []Vertex {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nres := make([]Vertex, 0)\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvisited := make(map[Vertex]struct{})\nvisited[startVet] = struct{}{}\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS, \u4f7f\u7528\u5207\u7247\u6a21\u62df\u961f\u5217\nqueue := make([]Vertex, 0)\nqueue = append(queue, startVet)\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nfor len(queue) > 0 {\n// \u961f\u9996\u9876\u70b9\u51fa\u961f\nvet := queue[0]\nqueue = queue[1:]\n// \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nres = append(res, vet)\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor _, adjVet := range g.adjList[vet] {\n_, isExist := visited[adjVet]\n// \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nif !isExist {\nqueue = append(queue, adjVet)\nvisited[adjVet] = struct{}{}\n}\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res\n}\n
    graph_bfs.js
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunction graphBFS(graph, startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nconst res = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nconst visited = new Set();\nvisited.add(startVet);\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nconst que = [startVet];\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (que.length) {\nconst vet = que.shift(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (const adjVet of graph.adjList.get(vet) ?? []) {\nif (visited.has(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\nque.push(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n
    graph_bfs.ts
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunction graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nconst res: Vertex[] = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nconst visited: Set<Vertex> = new Set();\nvisited.add(startVet);\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nconst que = [startVet];\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (que.length) {\nconst vet = que.shift(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (const adjVet of graph.adjList.get(vet) ?? []) {\nif (visited.has(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\nque.push(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\nvisited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n
    graph_bfs.c
    [class]{}-[func]{graphBFS}\n
    graph_bfs.cs
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nList<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = new List<Vertex>();\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nHashSet<Vertex> visited = new HashSet<Vertex>() { startVet };\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nQueue<Vertex> que = new Queue<Vertex>();\nque.Enqueue(startVet);\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (que.Count > 0) {\nVertex vet = que.Dequeue(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.Add(vet);               // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nforeach (Vertex adjVet in graph.adjList[vet]) {\nif (visited.Contains(adjVet)) {\ncontinue;          // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\nque.Enqueue(adjVet);   // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.Add(adjVet);   // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n
    graph_bfs.swift
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunc graphBFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nvar res: [Vertex] = []\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvar visited: Set<Vertex> = [startVet]\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nvar que: [Vertex] = [startVet]\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile !que.isEmpty {\nlet vet = que.removeFirst() // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.append(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor adjVet in graph.adjList[vet] ?? [] {\nif visited.contains(adjVet) {\ncontinue // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\nque.append(adjVet) // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.insert(adjVet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res\n}\n
    graph_bfs.zig
    [class]{}-[func]{graphBFS}\n
    graph_bfs.dart
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\nList<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nSet<Vertex> visited = {};\nvisited.add(startVet);\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nQueue<Vertex> que = Queue();\nque.add(startVet);\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (que.isNotEmpty) {\nVertex vet = que.removeFirst(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.add(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (Vertex adjVet in graph.adjList[vet]!) {\nif (visited.contains(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\nque.add(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n

    \u4ee3\u7801\u76f8\u5bf9\u62bd\u8c61\uff0c\u5efa\u8bae\u5bf9\u7167\u4ee5\u4e0b\u52a8\u753b\u56fe\u793a\u6765\u52a0\u6df1\u7406\u89e3\u3002

    <1><2><3><4><5><6><7><8><9><10><11>

    \u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u7684\u5e8f\u5217\u662f\u5426\u552f\u4e00\uff1f

    \u4e0d\u552f\u4e00\u3002\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u53ea\u8981\u6c42\u6309\u201c\u7531\u8fd1\u53ca\u8fdc\u201d\u7684\u987a\u5e8f\u904d\u5386\uff0c\u800c\u591a\u4e2a\u76f8\u540c\u8ddd\u79bb\u7684\u9876\u70b9\u7684\u904d\u5386\u987a\u5e8f\u662f\u5141\u8bb8\u88ab\u4efb\u610f\u6253\u4e71\u7684\u3002\u4ee5\u4e0a\u56fe\u4e3a\u4f8b\uff0c\u9876\u70b9 \\(1\\) , \\(3\\) \u7684\u8bbf\u95ee\u987a\u5e8f\u53ef\u4ee5\u4ea4\u6362\u3001\u9876\u70b9 \\(2\\) , \\(4\\) , \\(6\\) \u7684\u8bbf\u95ee\u987a\u5e8f\u4e5f\u53ef\u4ee5\u4efb\u610f\u4ea4\u6362\u3002

    "},{"location":"chapter_graph/graph_traversal/#_2","title":"\u590d\u6742\u5ea6\u5206\u6790","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\uff1a \u6240\u6709\u9876\u70b9\u90fd\u4f1a\u5165\u961f\u5e76\u51fa\u961f\u4e00\u6b21\uff0c\u4f7f\u7528 \\(O(|V|)\\) \u65f6\u95f4\uff1b\u5728\u904d\u5386\u90bb\u63a5\u9876\u70b9\u7684\u8fc7\u7a0b\u4e2d\uff0c\u7531\u4e8e\u662f\u65e0\u5411\u56fe\uff0c\u56e0\u6b64\u6240\u6709\u8fb9\u90fd\u4f1a\u88ab\u8bbf\u95ee \\(2\\) \u6b21\uff0c\u4f7f\u7528 \\(O(2|E|)\\) \u65f6\u95f4\uff1b\u603b\u4f53\u4f7f\u7528 \\(O(|V| + |E|)\\) \u65f6\u95f4\u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\uff1a \u5217\u8868 res \uff0c\u54c8\u5e0c\u8868 visited \uff0c\u961f\u5217 que \u4e2d\u7684\u9876\u70b9\u6570\u91cf\u6700\u591a\u4e3a \\(|V|\\) \uff0c\u4f7f\u7528 \\(O(|V|)\\) \u7a7a\u95f4\u3002

    "},{"location":"chapter_graph/graph_traversal/#932","title":"9.3.2. \u00a0 \u6df1\u5ea6\u4f18\u5148\u904d\u5386","text":"

    \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u662f\u4e00\u79cd\u4f18\u5148\u8d70\u5230\u5e95\u3001\u65e0\u8def\u53ef\u8d70\u518d\u56de\u5934\u7684\u904d\u5386\u65b9\u5f0f\u3002\u5177\u4f53\u5730\uff0c\u4ece\u67d0\u4e2a\u9876\u70b9\u51fa\u53d1\uff0c\u8bbf\u95ee\u5f53\u524d\u9876\u70b9\u7684\u67d0\u4e2a\u90bb\u63a5\u9876\u70b9\uff0c\u76f4\u5230\u8d70\u5230\u5c3d\u5934\u65f6\u8fd4\u56de\uff0c\u518d\u7ee7\u7eed\u8d70\u5230\u5c3d\u5934\u5e76\u8fd4\u56de\uff0c\u4ee5\u6b64\u7c7b\u63a8\uff0c\u76f4\u81f3\u6240\u6709\u9876\u70b9\u904d\u5386\u5b8c\u6210\u3002

    Fig. \u56fe\u7684\u6df1\u5ea6\u4f18\u5148\u904d\u5386

    "},{"location":"chapter_graph/graph_traversal/#_3","title":"\u7b97\u6cd5\u5b9e\u73b0","text":"

    \u8fd9\u79cd\u201c\u8d70\u5230\u5c3d\u5934 + \u56de\u6eaf\u201d\u7684\u7b97\u6cd5\u5f62\u5f0f\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u6765\u5b9e\u73b0\u3002\u4e0e BFS \u7c7b\u4f3c\uff0c\u5728 DFS \u4e2d\u6211\u4eec\u4e5f\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868 visited \u6765\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\uff0c\u4ee5\u907f\u514d\u91cd\u590d\u8bbf\u95ee\u9876\u70b9\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart graph_dfs.java
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {\nres.add(vet);     // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (Vertex adjVet : graph.adjList.get(vet)) {\nif (visited.contains(adjVet))\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nList<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = new ArrayList<>();\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nSet<Vertex> visited = new HashSet<>();\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n
    graph_dfs.cpp
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *> &res, Vertex *vet) {\nres.push_back(vet);   // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.emplace(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (Vertex *adjVet : graph.adjList[vet]) {\nif (visited.count(adjVet))\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nvector<Vertex *> graphDFS(GraphAdjList &graph, Vertex *startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nvector<Vertex *> res;\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nunordered_set<Vertex *> visited;\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n
    graph_dfs.py
    def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n\"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570\"\"\"\nres.append(vet)  # \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.add(vet)  # \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n# \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor adjVet in graph.adj_list[vet]:\nif adjVet in visited:\ncontinue  # \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n# \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet)\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:\n\"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS\"\"\"\n# \u9876\u70b9\u904d\u5386\u5e8f\u5217\nres = []\n# \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvisited = set[Vertex]()\ndfs(graph, visited, res, start_vet)\nreturn res\n
    graph_dfs.go
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nfunc dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {\n// append \u64cd\u4f5c\u4f1a\u8fd4\u56de\u65b0\u7684\u7684\u5f15\u7528\uff0c\u5fc5\u987b\u8ba9\u539f\u5f15\u7528\u91cd\u65b0\u8d4b\u503c\u4e3a\u65b0slice\u7684\u5f15\u7528\n*res = append(*res, vet)\nvisited[vet] = struct{}{}\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor _, adjVet := range g.adjList[vet] {\n_, isExist := visited[adjVet]\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\nif !isExist {\ndfs(g, visited, res, adjVet)\n}\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunc graphDFS(g *graphAdjList, startVet Vertex) []Vertex {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nres := make([]Vertex, 0)\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvisited := make(map[Vertex]struct{})\ndfs(g, visited, &res, startVet)\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res\n}\n
    graph_dfs.js
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunction dfs(graph, visited, res, vet) {\nres.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (const adjVet of graph.adjList.get(vet)) {\nif (visited.has(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunction graphDFS(graph, startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nconst res = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nconst visited = new Set();\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n
    graph_dfs.ts
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nfunction dfs(\ngraph: GraphAdjList,\nvisited: Set<Vertex>,\nres: Vertex[],\nvet: Vertex\n): void {\nres.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (const adjVet of graph.adjList.get(vet)) {\nif (visited.has(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunction graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nconst res: Vertex[] = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nconst visited: Set<Vertex> = new Set();\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n
    graph_dfs.c
    [class]{}-[func]{dfs}\n[class]{}-[func]{graphDFS}\n
    graph_dfs.cs
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet) {\nres.Add(vet);     // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.Add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nforeach (Vertex adjVet in graph.adjList[vet]) {\nif (visited.Contains(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9                             \n}\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nList<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = new List<Vertex>();\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nHashSet<Vertex> visited = new HashSet<Vertex>();\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n
    graph_dfs.swift
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nfunc dfs(graph: GraphAdjList, visited: inout Set<Vertex>, res: inout [Vertex], vet: Vertex) {\nres.append(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.insert(vet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor adjVet in graph.adjList[vet] ?? [] {\nif visited.contains(adjVet) {\ncontinue // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph: graph, visited: &visited, res: &res, vet: adjVet)\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunc graphDFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nvar res: [Vertex] = []\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvar visited: Set<Vertex> = []\ndfs(graph: graph, visited: &visited, res: &res, vet: startVet)\nreturn res\n}\n
    graph_dfs.zig
    [class]{}-[func]{dfs}\n[class]{}-[func]{graphDFS}\n
    graph_dfs.dart
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nvoid dfs(\nGraphAdjList graph,\nSet<Vertex> visited,\nList<Vertex> res,\nVertex vet,\n) {\nres.add(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (Vertex adjVet in graph.adjList[vet]!) {\nif (visited.contains(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\nList<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nSet<Vertex> visited = {};\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n

    \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u7684\u7b97\u6cd5\u6d41\u7a0b\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5176\u4e2d\uff1a

    • \u76f4\u865a\u7ebf\u4ee3\u8868\u5411\u4e0b\u9012\u63a8\uff0c\u8868\u793a\u5f00\u542f\u4e86\u4e00\u4e2a\u65b0\u7684\u9012\u5f52\u65b9\u6cd5\u6765\u8bbf\u95ee\u65b0\u9876\u70b9\uff1b
    • \u66f2\u865a\u7ebf\u4ee3\u8868\u5411\u4e0a\u56de\u6eaf\uff0c\u8868\u793a\u6b64\u9012\u5f52\u65b9\u6cd5\u5df2\u7ecf\u8fd4\u56de\uff0c\u56de\u6eaf\u5230\u4e86\u5f00\u542f\u6b64\u9012\u5f52\u65b9\u6cd5\u7684\u4f4d\u7f6e\uff1b

    \u4e3a\u4e86\u52a0\u6df1\u7406\u89e3\uff0c\u5efa\u8bae\u5c06\u56fe\u793a\u4e0e\u4ee3\u7801\u7ed3\u5408\u8d77\u6765\uff0c\u5728\u8111\u4e2d\uff08\u6216\u8005\u7528\u7b14\u753b\u4e0b\u6765\uff09\u6a21\u62df\u6574\u4e2a DFS \u8fc7\u7a0b\uff0c\u5305\u62ec\u6bcf\u4e2a\u9012\u5f52\u65b9\u6cd5\u4f55\u65f6\u5f00\u542f\u3001\u4f55\u65f6\u8fd4\u56de\u3002

    <1><2><3><4><5><6><7><8><9><10><11>

    \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u7684\u5e8f\u5217\u662f\u5426\u552f\u4e00\uff1f

    \u4e0e\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u7c7b\u4f3c\uff0c\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u5e8f\u5217\u7684\u987a\u5e8f\u4e5f\u4e0d\u662f\u552f\u4e00\u7684\u3002\u7ed9\u5b9a\u67d0\u9876\u70b9\uff0c\u5148\u5f80\u54ea\u4e2a\u65b9\u5411\u63a2\u7d22\u90fd\u53ef\u4ee5\uff0c\u5373\u90bb\u63a5\u9876\u70b9\u7684\u987a\u5e8f\u53ef\u4ee5\u4efb\u610f\u6253\u4e71\uff0c\u90fd\u662f\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u3002

    \u4ee5\u6811\u7684\u904d\u5386\u4e3a\u4f8b\uff0c\u201c\u6839 \\(\\rightarrow\\) \u5de6 \\(\\rightarrow\\) \u53f3\u201d\u3001\u201c\u5de6 \\(\\rightarrow\\) \u6839 \\(\\rightarrow\\) \u53f3\u201d\u3001\u201c\u5de6 \\(\\rightarrow\\) \u53f3 \\(\\rightarrow\\) \u6839\u201d\u5206\u522b\u5bf9\u5e94\u524d\u5e8f\u3001\u4e2d\u5e8f\u3001\u540e\u5e8f\u904d\u5386\uff0c\u5b83\u4eec\u5c55\u793a\u4e86\u4e09\u79cd\u4e0d\u540c\u7684\u904d\u5386\u4f18\u5148\u7ea7\uff0c\u7136\u800c\u8fd9\u4e09\u8005\u90fd\u5c5e\u4e8e\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u3002

    "},{"location":"chapter_graph/graph_traversal/#_4","title":"\u590d\u6742\u5ea6\u5206\u6790","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\uff1a \u6240\u6709\u9876\u70b9\u90fd\u4f1a\u88ab\u8bbf\u95ee \\(1\\) \u6b21\uff0c\u4f7f\u7528 \\(O(|V|)\\) \u65f6\u95f4\uff1b\u6240\u6709\u8fb9\u90fd\u4f1a\u88ab\u8bbf\u95ee \\(2\\) \u6b21\uff0c\u4f7f\u7528 \\(O(2|E|)\\) \u65f6\u95f4\uff1b\u603b\u4f53\u4f7f\u7528 \\(O(|V| + |E|)\\) \u65f6\u95f4\u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\uff1a \u5217\u8868 res \uff0c\u54c8\u5e0c\u8868 visited \u9876\u70b9\u6570\u91cf\u6700\u591a\u4e3a \\(|V|\\) \uff0c\u9012\u5f52\u6df1\u5ea6\u6700\u5927\u4e3a \\(|V|\\) \uff0c\u56e0\u6b64\u4f7f\u7528 \\(O(|V|)\\) \u7a7a\u95f4\u3002

    "},{"location":"chapter_graph/summary/","title":"9.4. \u00a0 \u5c0f\u7ed3","text":"
    • \u56fe\u7531\u9876\u70b9\u548c\u8fb9\u7ec4\u6210\uff0c\u53ef\u4ee5\u88ab\u8868\u793a\u4e3a\u4e00\u7ec4\u9876\u70b9\u548c\u4e00\u7ec4\u8fb9\u6784\u6210\u7684\u96c6\u5408\u3002
    • \u76f8\u8f83\u4e8e\u7ebf\u6027\u5173\u7cfb\uff08\u94fe\u8868\uff09\u548c\u5206\u6cbb\u5173\u7cfb\uff08\u6811\uff09\uff0c\u7f51\u7edc\u5173\u7cfb\uff08\u56fe\uff09\u5177\u6709\u66f4\u9ad8\u7684\u81ea\u7531\u5ea6\uff0c\u56e0\u800c\u66f4\u4e3a\u590d\u6742\u3002
    • \u6709\u5411\u56fe\u7684\u8fb9\u5177\u6709\u65b9\u5411\u6027\uff0c\u8fde\u901a\u56fe\u4e2d\u7684\u4efb\u610f\u9876\u70b9\u5747\u53ef\u8fbe\uff0c\u6709\u6743\u56fe\u7684\u6bcf\u6761\u8fb9\u90fd\u5305\u542b\u6743\u91cd\u53d8\u91cf\u3002
    • \u90bb\u63a5\u77e9\u9635\u5229\u7528\u77e9\u9635\u6765\u8868\u793a\u56fe\uff0c\u6bcf\u4e00\u884c\uff08\u5217\uff09\u4ee3\u8868\u4e00\u4e2a\u9876\u70b9\uff0c\u77e9\u9635\u5143\u7d20\u4ee3\u8868\u8fb9\uff0c\u7528 \\(1\\) \u6216 \\(0\\) \u8868\u793a\u4e24\u4e2a\u9876\u70b9\u4e4b\u95f4\u6709\u8fb9\u6216\u65e0\u8fb9\u3002\u90bb\u63a5\u77e9\u9635\u5728\u589e\u5220\u67e5\u64cd\u4f5c\u4e0a\u6548\u7387\u5f88\u9ad8\uff0c\u4f46\u7a7a\u95f4\u5360\u7528\u8f83\u591a\u3002
    • \u90bb\u63a5\u8868\u4f7f\u7528\u591a\u4e2a\u94fe\u8868\u6765\u8868\u793a\u56fe\uff0c\u7b2c \\(i\\) \u6761\u94fe\u8868\u5bf9\u5e94\u9876\u70b9 \\(i\\) \uff0c\u5176\u4e2d\u5b58\u50a8\u4e86\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\u3002\u90bb\u63a5\u8868\u76f8\u5bf9\u4e8e\u90bb\u63a5\u77e9\u9635\u66f4\u52a0\u8282\u7701\u7a7a\u95f4\uff0c\u4f46\u7531\u4e8e\u9700\u8981\u904d\u5386\u94fe\u8868\u6765\u67e5\u627e\u8fb9\uff0c\u65f6\u95f4\u6548\u7387\u8f83\u4f4e\u3002
    • \u5f53\u90bb\u63a5\u8868\u4e2d\u7684\u94fe\u8868\u8fc7\u957f\u65f6\uff0c\u53ef\u4ee5\u5c06\u5176\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811\u6216\u54c8\u5e0c\u8868\uff0c\u4ece\u800c\u63d0\u5347\u67e5\u8be2\u6548\u7387\u3002
    • \u4ece\u7b97\u6cd5\u601d\u60f3\u89d2\u5ea6\u5206\u6790\uff0c\u90bb\u63a5\u77e9\u9635\u4f53\u73b0\u201c\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u201d\uff0c\u90bb\u63a5\u8868\u4f53\u73b0\u201c\u4ee5\u65f6\u95f4\u6362\u7a7a\u95f4\u201d\u3002
    • \u56fe\u53ef\u7528\u4e8e\u5efa\u6a21\u5404\u7c7b\u73b0\u5b9e\u7cfb\u7edf\uff0c\u5982\u793e\u4ea4\u7f51\u7edc\u3001\u5730\u94c1\u7ebf\u8def\u7b49\u3002
    • \u6811\u662f\u56fe\u7684\u4e00\u79cd\u7279\u4f8b\uff0c\u6811\u7684\u904d\u5386\u4e5f\u662f\u56fe\u7684\u904d\u5386\u7684\u4e00\u79cd\u7279\u4f8b\u3002
    • \u56fe\u7684\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u662f\u4e00\u79cd\u7531\u8fd1\u53ca\u8fdc\u3001\u5c42\u5c42\u6269\u5f20\u7684\u641c\u7d22\u65b9\u5f0f\uff0c\u901a\u5e38\u501f\u52a9\u961f\u5217\u5b9e\u73b0\u3002
    • \u56fe\u7684\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u662f\u4e00\u79cd\u4f18\u5148\u8d70\u5230\u5e95\u3001\u65e0\u8def\u53ef\u8d70\u65f6\u518d\u56de\u6eaf\u7684\u641c\u7d22\u65b9\u5f0f\uff0c\u5e38\u57fa\u4e8e\u9012\u5f52\u6765\u5b9e\u73b0\u3002
    "},{"location":"chapter_graph/summary/#941-q-a","title":"9.4.1. \u00a0 Q & A","text":"

    \u8def\u5f84\u7684\u5b9a\u4e49\u662f\u9876\u70b9\u5e8f\u5217\u8fd8\u662f\u8fb9\u5e8f\u5217\uff1f

    \u7ef4\u57fa\u767e\u79d1\u4e0a\u4e0d\u540c\u8bed\u8a00\u7248\u672c\u7684\u5b9a\u4e49\u4e0d\u4e00\u81f4\uff1a\u82f1\u6587\u7248\u662f\u201c\u8def\u5f84\u662f\u4e00\u4e2a\u8fb9\u5e8f\u5217\u201d\uff0c\u800c\u4e2d\u6587\u7248\u662f\u201c\u8def\u5f84\u662f\u4e00\u4e2a\u9876\u70b9\u5e8f\u5217\u201d\u3002\u4ee5\u4e0b\u662f\u82f1\u6587\u7248\u539f\u6587\uff1aIn graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices. \u5728\u672c\u6587\u4e2d\uff0c\u8def\u5f84\u88ab\u8ba4\u4e3a\u662f\u4e00\u4e2a\u8fb9\u5e8f\u5217\uff0c\u800c\u4e0d\u662f\u4e00\u4e2a\u9876\u70b9\u5e8f\u5217\u3002\u8fd9\u662f\u56e0\u4e3a\u4e24\u4e2a\u9876\u70b9\u4e4b\u95f4\u53ef\u80fd\u5b58\u5728\u591a\u6761\u8fb9\u8fde\u63a5\uff0c\u6b64\u65f6\u6bcf\u6761\u8fb9\u90fd\u5bf9\u5e94\u4e00\u6761\u8def\u5f84\u3002

    \u975e\u8fde\u901a\u56fe\u4e2d\uff0c\u662f\u5426\u4f1a\u6709\u65e0\u6cd5\u904d\u5386\u5230\u7684\u70b9\uff1f

    \u5728\u975e\u8fde\u901a\u56fe\u4e2d\uff0c\u4ece\u67d0\u4e2a\u9876\u70b9\u51fa\u53d1\uff0c\u81f3\u5c11\u6709\u4e00\u4e2a\u9876\u70b9\u65e0\u6cd5\u5230\u8fbe\u3002\u904d\u5386\u975e\u8fde\u901a\u56fe\u9700\u8981\u8bbe\u7f6e\u591a\u4e2a\u8d77\u70b9\uff0c\u4ee5\u904d\u5386\u5230\u56fe\u7684\u6240\u6709\u8fde\u901a\u5206\u91cf\u3002

    \u5728\u90bb\u63a5\u8868\u4e2d\uff0c\u201c\u4e0e\u8be5\u9876\u70b9\u76f8\u8fde\u7684\u6240\u6709\u9876\u70b9\u201d\u7684\u9876\u70b9\u987a\u5e8f\u662f\u5426\u6709\u8981\u6c42\uff1f

    \u53ef\u4ee5\u662f\u4efb\u610f\u987a\u5e8f\u3002\u4f46\u5728\u5b9e\u9645\u5e94\u7528\u4e2d\uff0c\u53ef\u80fd\u4f1a\u9700\u8981\u6309\u7167\u6307\u5b9a\u89c4\u5219\u6765\u6392\u5e8f\uff0c\u6bd4\u5982\u6309\u7167\u9876\u70b9\u6dfb\u52a0\u7684\u6b21\u5e8f\u3001\u6216\u8005\u6309\u7167\u9876\u70b9\u503c\u5927\u5c0f\u7684\u987a\u5e8f\u7b49\u7b49\uff0c\u8fd9\u6837\u53ef\u4ee5\u6709\u52a9\u4e8e\u5feb\u901f\u67e5\u627e\u201c\u5e26\u6709\u67d0\u79cd\u6781\u503c\u201d\u7684\u9876\u70b9\u3002

    "},{"location":"chapter_hashing/","title":"6. \u00a0 \u6563\u5217\u8868","text":""},{"location":"chapter_hashing/hash_algorithm/","title":"6.3. \u00a0 \u54c8\u5e0c\u7b97\u6cd5","text":"

    \u5728\u4e0a\u4e24\u8282\u4e2d\uff0c\u6211\u4eec\u4e86\u89e3\u4e86\u54c8\u5e0c\u8868\u7684\u5de5\u4f5c\u539f\u7406\uff0c\u4ee5\u53ca\u54c8\u5e0c\u51b2\u7a81\u7684\u5904\u7406\u65b9\u6cd5\u3002\u7136\u800c\uff0c\u65e0\u8bba\u662f\u5f00\u653e\u5bfb\u5740\u8fd8\u662f\u94fe\u5730\u5740\u6cd5\uff0c\u5b83\u4eec\u53ea\u80fd\u4fdd\u8bc1\u54c8\u5e0c\u8868\u53ef\u4ee5\u5728\u53d1\u751f\u51b2\u7a81\u65f6\u6b63\u5e38\u5de5\u4f5c\uff0c\u4f46\u65e0\u6cd5\u51cf\u5c11\u54c8\u5e0c\u51b2\u7a81\u7684\u53d1\u751f\u3002

    \u5982\u679c\u54c8\u5e0c\u51b2\u7a81\u8fc7\u4e8e\u9891\u7e41\uff0c\u54c8\u5e0c\u8868\u7684\u6027\u80fd\u5219\u4f1a\u6025\u5267\u52a3\u5316\u3002\u4f8b\u5982\u5bf9\u4e8e\u94fe\u5730\u5740\u54c8\u5e0c\u8868\uff0c\u7406\u60f3\u60c5\u51b5\u4e0b\u952e\u503c\u5bf9\u5e73\u5747\u5206\u5e03\u5728\u5404\u4e2a\u6876\u4e2d\uff0c\u8fbe\u5230\u6700\u597d\u7684\u67e5\u8be2\u6548\u7387\uff1b\u6700\u5dee\u60c5\u51b5\u4e0b\u5168\u90e8\u952e\u503c\u90fd\u88ab\u5b58\u50a8\u5230\u540c\u4e00\u4e2a\u6876\u4e2d\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u9000\u5316\u81f3 \\(O(n)\\) \u3002

    Fig. \u54c8\u5e0c\u51b2\u7a81\u7684\u6700\u4f73\u4e0e\u6700\u5dee\u60c5\u51b5

    \u952e\u503c\u5bf9\u7684\u5206\u5e03\u60c5\u51b5\u662f\u7531\u54c8\u5e0c\u51fd\u6570\u51b3\u5b9a\u7684\u3002\u56de\u5fc6\u54c8\u5e0c\u51fd\u6570\u7684\u8ba1\u7b97\u6b65\u9aa4\uff0c\u5148\u8ba1\u7b97\u54c8\u5e0c\u503c\uff0c\u518d\u5bf9\u6570\u7ec4\u957f\u5ea6\u53d6\u6a21\uff1a

    index = hash(key) % capacity\n

    \u89c2\u5bdf\u4ee5\u4e0a\u516c\u5f0f\uff0c\u5f53\u54c8\u5e0c\u8868\u5bb9\u91cf capacity \u56fa\u5b9a\u65f6\uff0c\u54c8\u5e0c\u7b97\u6cd5 hash() \u51b3\u5b9a\u4e86\u8f93\u51fa\u503c\uff0c\u8fdb\u800c\u51b3\u5b9a\u4e86\u952e\u503c\u5bf9\u5728\u54c8\u5e0c\u8868\u4e2d\u7684\u5206\u5e03\u3002\u56e0\u6b64\uff0c\u4e3a\u4e86\u51cf\u5c0f\u54c8\u5e0c\u51b2\u7a81\u7684\u53d1\u751f\u6982\u7387\uff0c\u6211\u4eec\u9700\u8981\u5c06\u6ce8\u610f\u529b\u96c6\u4e2d\u5728\u54c8\u5e0c\u7b97\u6cd5 hash() \u7684\u8bbe\u8ba1\u4e0a\u3002

    "},{"location":"chapter_hashing/hash_algorithm/#631","title":"6.3.1. \u00a0 \u54c8\u5e0c\u7b97\u6cd5\u7684\u76ee\u6807","text":"

    \u4e3a\u4e86\u5728\u7f16\u7a0b\u8bed\u8a00\u4e2d\u5b9e\u73b0\u201c\u65e2\u5feb\u53c8\u7a33\u201d\u7684\u54c8\u5e0c\u8868\u6570\u636e\u7ed3\u6784\uff0c\u54c8\u5e0c\u7b97\u6cd5\u5e94\u5305\u542b\u4ee5\u4e0b\u7279\u70b9\uff1a

    • \u786e\u5b9a\u6027\uff1a\u5bf9\u4e8e\u76f8\u540c\u7684\u8f93\u5165\uff0c\u54c8\u5e0c\u7b97\u6cd5\u5e94\u59cb\u7ec8\u4ea7\u751f\u76f8\u540c\u7684\u8f93\u51fa\u3002\u8fd9\u6837\u624d\u80fd\u786e\u4fdd\u54c8\u5e0c\u8868\u662f\u53ef\u9760\u7684\u3002
    • \u6548\u7387\u9ad8\uff1a\u8ba1\u7b97\u54c8\u5e0c\u503c\u7684\u8fc7\u7a0b\u5e94\u8be5\u8db3\u591f\u5feb\u3002\u8ba1\u7b97\u5f00\u9500\u8d8a\u5c0f\uff0c\u54c8\u5e0c\u8868\u7684\u5b9e\u7528\u6027\u8d8a\u9ad8\u3002
    • \u5747\u5300\u5206\u5e03\uff1a\u54c8\u5e0c\u7b97\u6cd5\u5e94\u4f7f\u5f97\u952e\u503c\u5bf9\u5e73\u5747\u5206\u5e03\u5728\u54c8\u5e0c\u8868\u4e2d\u3002\u5206\u5e03\u8d8a\u5e73\u5747\uff0c\u54c8\u5e0c\u51b2\u7a81\u7684\u6982\u7387\u5c31\u8d8a\u4f4e\u3002

    \u5b9e\u9645\u4e0a\uff0c\u54c8\u5e0c\u7b97\u6cd5\u9664\u4e86\u53ef\u4ee5\u7528\u4e8e\u5b9e\u73b0\u54c8\u5e0c\u8868\uff0c\u8fd8\u5e7f\u6cdb\u5e94\u7528\u4e8e\u5176\u4ed6\u9886\u57df\u4e2d\uff0c\u5305\u62ec\uff1a

    • \u5bc6\u7801\u5b58\u50a8\uff1a\u4e3a\u4e86\u4fdd\u62a4\u7528\u6237\u5bc6\u7801\u7684\u5b89\u5168\uff0c\u7cfb\u7edf\u901a\u5e38\u4e0d\u4f1a\u76f4\u63a5\u5b58\u50a8\u7528\u6237\u7684\u660e\u6587\u5bc6\u7801\uff0c\u800c\u662f\u5b58\u50a8\u5bc6\u7801\u7684\u54c8\u5e0c\u503c\u3002\u5f53\u7528\u6237\u8f93\u5165\u5bc6\u7801\u65f6\uff0c\u7cfb\u7edf\u4f1a\u5bf9\u8f93\u5165\u7684\u5bc6\u7801\u8ba1\u7b97\u54c8\u5e0c\u503c\uff0c\u7136\u540e\u4e0e\u5b58\u50a8\u7684\u54c8\u5e0c\u503c\u8fdb\u884c\u6bd4\u8f83\u3002\u5982\u679c\u4e24\u8005\u5339\u914d\uff0c\u90a3\u4e48\u5bc6\u7801\u5c31\u88ab\u89c6\u4e3a\u6b63\u786e\u3002
    • \u6570\u636e\u5b8c\u6574\u6027\u68c0\u67e5\uff1a\u6570\u636e\u53d1\u9001\u65b9\u53ef\u4ee5\u8ba1\u7b97\u6570\u636e\u7684\u54c8\u5e0c\u503c\u5e76\u5c06\u5176\u4e00\u540c\u53d1\u9001\uff1b\u63a5\u6536\u65b9\u53ef\u4ee5\u91cd\u65b0\u8ba1\u7b97\u63a5\u6536\u5230\u7684\u6570\u636e\u7684\u54c8\u5e0c\u503c\uff0c\u5e76\u4e0e\u63a5\u6536\u5230\u7684\u54c8\u5e0c\u503c\u8fdb\u884c\u6bd4\u8f83\u3002\u5982\u679c\u4e24\u8005\u5339\u914d\uff0c\u90a3\u4e48\u6570\u636e\u5c31\u88ab\u89c6\u4e3a\u5b8c\u6574\u7684\u3002

    \u5bf9\u4e8e\u5bc6\u7801\u5b66\u7684\u76f8\u5173\u5e94\u7528\uff0c\u54c8\u5e0c\u7b97\u6cd5\u9700\u8981\u6ee1\u8db3\u66f4\u9ad8\u7684\u5b89\u5168\u6807\u51c6\uff0c\u4ee5\u9632\u6b62\u4ece\u54c8\u5e0c\u503c\u63a8\u5bfc\u51fa\u539f\u59cb\u5bc6\u7801\u7b49\u9006\u5411\u5de5\u7a0b\uff0c\u5305\u62ec\uff1a

    • \u6297\u78b0\u649e\u6027\uff1a\u5e94\u5f53\u6781\u5176\u56f0\u96be\u627e\u5230\u4e24\u4e2a\u4e0d\u540c\u7684\u8f93\u5165\uff0c\u4f7f\u5f97\u5b83\u4eec\u7684\u54c8\u5e0c\u503c\u76f8\u540c\u3002
    • \u96ea\u5d29\u6548\u5e94\uff1a\u8f93\u5165\u7684\u5fae\u5c0f\u53d8\u5316\u5e94\u5f53\u5bfc\u81f4\u8f93\u51fa\u7684\u663e\u8457\u4e14\u4e0d\u53ef\u9884\u6d4b\u7684\u53d8\u5316\u3002

    \u6ce8\u610f\uff0c\u201c\u5747\u5300\u5206\u5e03\u201d\u4e0e\u201c\u6297\u78b0\u649e\u6027\u201d\u662f\u4e24\u4e2a\u72ec\u7acb\u7684\u6982\u5ff5\uff0c\u6ee1\u8db3\u5747\u5300\u5206\u5e03\u4e0d\u4e00\u5b9a\u6ee1\u8db3\u6297\u78b0\u649e\u6027\u3002\u4f8b\u5982\uff0c\u5728\u968f\u673a\u8f93\u5165 key \u4e0b\uff0c\u54c8\u5e0c\u51fd\u6570 key % 100 \u53ef\u4ee5\u4ea7\u751f\u5747\u5300\u5206\u5e03\u7684\u8f93\u51fa\u3002\u7136\u800c\uff0c\u8be5\u54c8\u5e0c\u7b97\u6cd5\u8fc7\u4e8e\u7b80\u5355\uff0c\u6240\u6709\u540e\u4e24\u4f4d\u76f8\u7b49\u7684 key \u7684\u8f93\u51fa\u90fd\u76f8\u540c\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u5f88\u5bb9\u6613\u5730\u4ece\u54c8\u5e0c\u503c\u53cd\u63a8\u51fa\u53ef\u7528\u7684 key \uff0c\u4ece\u800c\u7834\u89e3\u5bc6\u7801\u3002

    "},{"location":"chapter_hashing/hash_algorithm/#632","title":"6.3.2. \u00a0 \u54c8\u5e0c\u7b97\u6cd5\u7684\u8bbe\u8ba1","text":"

    \u54c8\u5e0c\u7b97\u6cd5\u7684\u8bbe\u8ba1\u662f\u4e00\u4e2a\u590d\u6742\u4e14\u9700\u8981\u8003\u8651\u8bb8\u591a\u56e0\u7d20\u7684\u95ee\u9898\u3002\u7136\u800c\uff0c\u5bf9\u4e8e\u4e00\u4e9b\u7b80\u5355\u573a\u666f\uff0c\u6211\u4eec\u4e5f\u80fd\u8bbe\u8ba1\u4e00\u4e9b\u7b80\u5355\u7684\u54c8\u5e0c\u7b97\u6cd5\uff0c\u4ee5\u5b57\u7b26\u4e32\u54c8\u5e0c\u4e3a\u4f8b\uff1a

    • \u52a0\u6cd5\u54c8\u5e0c\uff1a\u5bf9\u8f93\u5165\u7684\u6bcf\u4e2a\u5b57\u7b26\u7684 ASCII \u7801\u8fdb\u884c\u76f8\u52a0\uff0c\u5c06\u5f97\u5230\u7684\u603b\u548c\u4f5c\u4e3a\u54c8\u5e0c\u503c\u3002
    • \u4e58\u6cd5\u54c8\u5e0c\uff1a\u5229\u7528\u4e86\u4e58\u6cd5\u7684\u4e0d\u76f8\u5173\u6027\uff0c\u6bcf\u8f6e\u4e58\u4ee5\u4e00\u4e2a\u5e38\u6570\uff0c\u5c06\u5404\u4e2a\u5b57\u7b26\u7684 ASCII \u7801\u7d2f\u79ef\u5230\u54c8\u5e0c\u503c\u4e2d\u3002
    • \u5f02\u6216\u54c8\u5e0c\uff1a\u5c06\u8f93\u5165\u6570\u636e\u7684\u6bcf\u4e2a\u5143\u7d20\u901a\u8fc7\u5f02\u6216\u64cd\u4f5c\u7d2f\u79ef\u5230\u4e00\u4e2a\u54c8\u5e0c\u503c\u4e2d\u3002
    • \u65cb\u8f6c\u54c8\u5e0c\uff1a\u5c06\u6bcf\u4e2a\u5b57\u7b26\u7684 ASCII \u7801\u7d2f\u79ef\u5230\u4e00\u4e2a\u54c8\u5e0c\u503c\u4e2d\uff0c\u6bcf\u6b21\u7d2f\u79ef\u4e4b\u524d\u90fd\u4f1a\u5bf9\u54c8\u5e0c\u503c\u8fdb\u884c\u65cb\u8f6c\u64cd\u4f5c\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart simple_hash.java
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(String key) {\nlong hash = 0;\nfinal int MODULUS = 1000000007;\nfor (char c : key.toCharArray()) {\nhash = (hash + (int) c) % MODULUS;\n}\nreturn (int) hash;\n}\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(String key) {\nlong hash = 0;\nfinal int MODULUS = 1000000007;\nfor (char c : key.toCharArray()) {\nhash = (31 * hash + (int) c) % MODULUS;\n}\nreturn (int) hash;\n}\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(String key) {\nint hash = 0;\nfinal int MODULUS = 1000000007;\nfor (char c : key.toCharArray()) {\nhash ^= (int) c;\n}\nreturn hash & MODULUS;\n}\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(String key) {\nlong hash = 0;\nfinal int MODULUS = 1000000007;\nfor (char c : key.toCharArray()) {\nhash = ((hash << 4) ^ (hash >> 28) ^ (int) c) % MODULUS;\n}\nreturn (int) hash;\n}\n
    simple_hash.cpp
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(string key) {\nlong long hash = 0;\nconst int MODULUS = 1000000007;\nfor (unsigned char c : key) {\nhash = (hash + (int)c) % MODULUS;\n}\nreturn (int)hash;\n}\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(string key) {\nlong long hash = 0;\nconst int MODULUS = 1000000007;\nfor (unsigned char c : key) {\nhash = (31 * hash + (int)c) % MODULUS;\n}\nreturn (int)hash;\n}\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(string key) {\nint hash = 0;\nconst int MODULUS = 1000000007;\nfor (unsigned char c : key) {\ncout<<(int)c<<endl;\nhash ^= (int)c;\n}\nreturn hash & MODULUS;\n}\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(string key) {\nlong long hash = 0;\nconst int MODULUS = 1000000007;\nfor (unsigned char c : key) {\nhash = ((hash << 4) ^ (hash >> 28) ^ (int)c) % MODULUS;\n}\nreturn (int)hash;\n}\n
    simple_hash.py
    def add_hash(key: str) -> int:\n\"\"\"\u52a0\u6cd5\u54c8\u5e0c\"\"\"\nhash = 0\nmodulus = 1000000007\nfor c in key:\nhash += ord(c)\nreturn hash % modulus\ndef mul_hash(key: str) -> int:\n\"\"\"\u4e58\u6cd5\u54c8\u5e0c\"\"\"\nhash = 0\nmodulus = 1000000007\nfor c in key:\nhash = 31 * hash + ord(c)\nreturn hash % modulus\ndef xor_hash(key: str) -> int:\n\"\"\"\u5f02\u6216\u54c8\u5e0c\"\"\"\nhash = 0\nmodulus = 1000000007\nfor c in key:\nhash ^= ord(c)\nreturn hash % modulus\ndef rot_hash(key: str) -> int:\n\"\"\"\u65cb\u8f6c\u54c8\u5e0c\"\"\"\nhash = 0\nmodulus = 1000000007\nfor c in key:\nhash = (hash << 4) ^ (hash >> 28) ^ ord(c)\nreturn hash % modulus\n
    simple_hash.go
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key string) int {\nvar hash int64\nvar modulus int64\nmodulus = 1000000007\nfor _, b := range []byte(key) {\nhash = (hash + int64(b)) % modulus\n}\nreturn int(hash)\n}\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key string) int {\nvar hash int64\nvar modulus int64\nmodulus = 1000000007\nfor _, b := range []byte(key) {\nhash = (31*hash + int64(b)) % modulus\n}\nreturn int(hash)\n}\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key string) int {\nhash := 0\nmodulus := 1000000007\nfor _, b := range []byte(key) {\nfmt.Println(int(b))\nhash ^= int(b)\nhash = (31*hash + int(b)) % modulus\n}\nreturn hash & modulus\n}\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key string) int {\nvar hash int64\nvar modulus int64\nmodulus = 1000000007\nfor _, b := range []byte(key) {\nhash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus\n}\nreturn int(hash)\n}\n
    simple_hash.js
    [class]{}-[func]{addHash}\n[class]{}-[func]{mulHash}\n[class]{}-[func]{xorHash}\n[class]{}-[func]{rotHash}\n
    simple_hash.ts
    [class]{}-[func]{addHash}\n[class]{}-[func]{mulHash}\n[class]{}-[func]{xorHash}\n[class]{}-[func]{rotHash}\n
    simple_hash.c
    [class]{}-[func]{addHash}\n[class]{}-[func]{mulHash}\n[class]{}-[func]{xorHash}\n[class]{}-[func]{rotHash}\n
    simple_hash.cs
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(string key) {\nlong hash = 0;\nconst int MODULUS = 1000000007;\nforeach (char c in key) {\nhash = (hash + c) % MODULUS;\n}\nreturn (int)hash;\n}\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(string key) {\nlong hash = 0;\nconst int MODULUS = 1000000007;\nforeach (char c in key) {\nhash = (31 * hash + c) % MODULUS;\n}\nreturn (int)hash;\n}\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(string key) {\nint hash = 0;\nconst int MODULUS = 1000000007;\nforeach (char c in key) {\nhash ^= c;\n}\nreturn hash & MODULUS;\n}\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(string key) {\nlong hash = 0;\nconst int MODULUS = 1000000007;\nforeach (char c in key) {\nhash = ((hash << 4) ^ (hash >> 28) ^ c) % MODULUS;\n}\nreturn (int)hash;\n}\n
    simple_hash.swift
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key: String) -> Int {\nvar hash = 0\nlet MODULUS = 1_000_000_007\nfor c in key {\nfor scalar in c.unicodeScalars {\nhash = (hash + Int(scalar.value)) % MODULUS\n}\n}\nreturn hash\n}\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key: String) -> Int {\nvar hash = 0\nlet MODULUS = 1_000_000_007\nfor c in key {\nfor scalar in c.unicodeScalars {\nhash = (31 * hash + Int(scalar.value)) % MODULUS\n}\n}\nreturn hash\n}\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key: String) -> Int {\nvar hash = 0\nlet MODULUS = 1_000_000_007\nfor c in key {\nfor scalar in c.unicodeScalars {\nhash ^= Int(scalar.value)\n}\n}\nreturn hash & MODULUS\n}\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key: String) -> Int {\nvar hash = 0\nlet MODULUS = 1_000_000_007\nfor c in key {\nfor scalar in c.unicodeScalars {\nhash = ((hash << 4) ^ (hash >> 28) ^ Int(scalar.value)) % MODULUS\n}\n}\nreturn hash\n}\n
    simple_hash.zig
    [class]{}-[func]{addHash}\n[class]{}-[func]{mulHash}\n[class]{}-[func]{xorHash}\n[class]{}-[func]{rotHash}\n
    simple_hash.dart
    [class]{}-[func]{add_hash}\n[class]{}-[func]{mul_hash}\n[class]{}-[func]{xor_hash}\n[class]{}-[func]{rot_hash}\n

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u6bcf\u79cd\u54c8\u5e0c\u7b97\u6cd5\u7684\u6700\u540e\u4e00\u6b65\u90fd\u662f\u5bf9\u5927\u8d28\u6570 \\(1000000007\\) \u53d6\u6a21\uff0c\u4ee5\u786e\u4fdd\u54c8\u5e0c\u503c\u5728\u5408\u9002\u7684\u8303\u56f4\u5185\u3002\u503c\u5f97\u601d\u8003\u7684\u662f\uff0c\u4e3a\u4ec0\u4e48\u8981\u5f3a\u8c03\u5bf9\u8d28\u6570\u53d6\u6a21\uff0c\u5bf9\u5408\u6570\u53d6\u6a21\u7684\u5f0a\u7aef\u662f\u4ec0\u4e48\uff1f\u8fd9\u662f\u4e00\u4e2a\u6709\u8da3\u7684\u95ee\u9898\u3002

    \u5148\u629b\u51fa\u7ed3\u8bba\uff1a\u5f53\u6211\u4eec\u4f7f\u7528\u5927\u8d28\u6570\u4f5c\u4e3a\u6a21\u6570\u65f6\uff0c\u53ef\u4ee5\u6700\u5927\u5316\u5730\u4fdd\u8bc1\u54c8\u5e0c\u503c\u7684\u5747\u5300\u5206\u5e03\u3002\u56e0\u4e3a\u8d28\u6570\u4e0d\u4f1a\u4e0e\u5176\u4ed6\u6570\u5b57\u5b58\u5728\u516c\u7ea6\u6570\uff0c\u53ef\u4ee5\u51cf\u5c11\u56e0\u53d6\u6a21\u64cd\u4f5c\u800c\u4ea7\u751f\u7684\u5468\u671f\u6027\u6a21\u5f0f\uff0c\u4ece\u800c\u907f\u514d\u54c8\u5e0c\u51b2\u7a81\u3002

    \u4e3e\u4e2a\u4f8b\u5b50\uff0c\u5047\u8bbe\u6211\u4eec\u9009\u62e9\u5408\u6570 \\(9\\) \u4f5c\u4e3a\u6a21\u6570\uff0c\u5b83\u53ef\u4ee5\u88ab \\(3\\) \u6574\u9664\u3002\u90a3\u4e48\u6240\u6709\u53ef\u4ee5\u88ab \\(3\\) \u6574\u9664\u7684 key \u90fd\u4f1a\u88ab\u6620\u5c04\u5230 \\(0\\) , \\(3\\) , \\(6\\) \u8fd9\u4e09\u4e2a\u54c8\u5e0c\u503c\u3002

    \\[ \\begin{aligned} \\text{modulus} & = 9 \\newline \\text{key} & = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\cdots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\cdots \\} \\end{aligned} \\]

    \u5982\u679c\u8f93\u5165 key \u6070\u597d\u6ee1\u8db3\u8fd9\u79cd\u7b49\u5dee\u6570\u5217\u7684\u6570\u636e\u5206\u5e03\uff0c\u90a3\u4e48\u54c8\u5e0c\u503c\u5c31\u4f1a\u51fa\u73b0\u805a\u5806\uff0c\u4ece\u800c\u52a0\u91cd\u54c8\u5e0c\u51b2\u7a81\u3002\u73b0\u5728\uff0c\u5047\u8bbe\u5c06 modulus \u66ff\u6362\u4e3a\u8d28\u6570 \\(13\\) \uff0c\u7531\u4e8e key \u548c modulus \u4e4b\u95f4\u4e0d\u5b58\u5728\u516c\u7ea6\u6570\uff0c\u8f93\u51fa\u7684\u54c8\u5e0c\u503c\u7684\u5747\u5300\u6027\u4f1a\u660e\u663e\u63d0\u5347\u3002

    \\[ \\begin{aligned} \\text{modulus} & = 13 \\newline \\text{key} & = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\cdots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\cdots \\} \\end{aligned} \\]

    \u503c\u5f97\u5f3a\u8c03\u7684\u662f\uff0c\u5982\u679c\u80fd\u591f\u4fdd\u8bc1 key \u662f\u968f\u673a\u5747\u5300\u5206\u5e03\u7684\uff0c\u90a3\u4e48\u9009\u62e9\u8d28\u6570\u6216\u8005\u5408\u6570\u4f5c\u4e3a\u6a21\u6570\u90fd\u662f\u53ef\u4ee5\u7684\uff0c\u5b83\u4eec\u90fd\u80fd\u8f93\u51fa\u5747\u5300\u5206\u5e03\u7684\u54c8\u5e0c\u503c\u3002\u800c\u5f53 key \u7684\u5206\u5e03\u5b58\u5728\u67d0\u79cd\u5468\u671f\u6027\u65f6\uff0c\u5bf9\u5408\u6570\u53d6\u6a21\u66f4\u5bb9\u6613\u51fa\u73b0\u805a\u96c6\u73b0\u8c61\u3002

    \u603b\u800c\u8a00\u4e4b\uff0c\u6211\u4eec\u901a\u5e38\u9009\u53d6\u8d28\u6570\u4f5c\u4e3a\u6a21\u6570\uff0c\u5e76\u4e14\u8fd9\u4e2a\u8d28\u6570\u6700\u597d\u5927\u4e00\u4e9b\uff0c\u4ee5\u63d0\u5347\u54c8\u5e0c\u7b97\u6cd5\u7684\u7a33\u5065\u6027\u3002

    "},{"location":"chapter_hashing/hash_algorithm/#633","title":"6.3.3. \u00a0 \u5e38\u89c1\u54c8\u5e0c\u7b97\u6cd5","text":"

    \u4e0d\u96be\u53d1\u73b0\uff0c\u4ee5\u4e0a\u4ecb\u7ecd\u7684\u7b80\u5355\u54c8\u5e0c\u7b97\u6cd5\u90fd\u6bd4\u8f83\u201c\u8106\u5f31\u201d\uff0c\u8fdc\u8fdc\u6ca1\u6709\u8fbe\u5230\u54c8\u5e0c\u7b97\u6cd5\u7684\u8bbe\u8ba1\u76ee\u6807\u3002\u4f8b\u5982\uff0c\u7531\u4e8e\u52a0\u6cd5\u548c\u5f02\u6216\u6ee1\u8db3\u4ea4\u6362\u5f8b\uff0c\u56e0\u6b64\u52a0\u6cd5\u54c8\u5e0c\u548c\u5f02\u6216\u54c8\u5e0c\u65e0\u6cd5\u533a\u5206\u5185\u5bb9\u76f8\u540c\u4f46\u987a\u5e8f\u4e0d\u540c\u7684\u5b57\u7b26\u4e32\uff0c\u8fd9\u53ef\u80fd\u4f1a\u52a0\u5267\u54c8\u5e0c\u51b2\u7a81\uff0c\u5e76\u5f15\u8d77\u4e00\u4e9b\u5b89\u5168\u95ee\u9898\u3002

    \u5728\u5b9e\u9645\u4e2d\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u7528\u4e00\u4e9b\u6807\u51c6\u54c8\u5e0c\u7b97\u6cd5\uff0c\u4f8b\u5982 MD5, SHA-1, SHA-2, SHA3 \u7b49\u3002\u5b83\u4eec\u53ef\u4ee5\u5c06\u4efb\u610f\u957f\u5ea6\u7684\u8f93\u5165\u6570\u636e\u6620\u5c04\u5230\u6052\u5b9a\u957f\u5ea6\u7684\u54c8\u5e0c\u503c\u3002\u8fd1\u4e00\u4e2a\u4e16\u7eaa\u4ee5\u6765\uff0c\u54c8\u5e0c\u7b97\u6cd5\u5904\u5728\u4e0d\u65ad\u5347\u7ea7\u4e0e\u4f18\u5316\u7684\u8fc7\u7a0b\u4e2d\u3002\u4e00\u90e8\u5206\u7814\u7a76\u4eba\u5458\u52aa\u529b\u63d0\u5347\u54c8\u5e0c\u7b97\u6cd5\u7684\u6027\u80fd\uff0c\u53e6\u4e00\u90e8\u5206\u7814\u7a76\u4eba\u5458\u548c\u9ed1\u5ba2\u5219\u81f4\u529b\u4e8e\u5bfb\u627e\u54c8\u5e0c\u7b97\u6cd5\u7684\u5b89\u5168\u6027\u95ee\u9898\u3002

    \u76f4\u81f3\u76ee\u524d\uff0cMD5 \u548c SHA-1 \u5df2\u591a\u6b21\u88ab\u6210\u529f\u653b\u51fb\uff0c\u56e0\u6b64\u5b83\u4eec\u88ab\u5404\u7c7b\u5b89\u5168\u5e94\u7528\u5f03\u7528\u3002SHA-2 \u7cfb\u5217\u4e2d\u7684 SHA-256 \u662f\u6700\u5b89\u5168\u7684\u54c8\u5e0c\u7b97\u6cd5\u4e4b\u4e00\uff0c\u4ecd\u672a\u51fa\u73b0\u6210\u529f\u7684\u653b\u51fb\u6848\u4f8b\uff0c\u56e0\u6b64\u5e38\u88ab\u7528\u5728\u5404\u7c7b\u5b89\u5168\u5e94\u7528\u4e0e\u534f\u8bae\u4e2d\u3002SHA-3 \u76f8\u8f83 SHA-2 \u7684\u5b9e\u73b0\u5f00\u9500\u66f4\u4f4e\u3001\u8ba1\u7b97\u6548\u7387\u66f4\u9ad8\uff0c\u4f46\u76ee\u524d\u4f7f\u7528\u8986\u76d6\u5ea6\u4e0d\u5982 SHA-2 \u7cfb\u5217\u3002

    MD5 SHA-1 SHA-2 SHA-3 \u63a8\u51fa\u65f6\u95f4 1992 1995 2002 2008 \u8f93\u51fa\u957f\u5ea6 128 bits 160 bits 256 / 512 bits 224/256/384/512 bits \u54c8\u5e0c\u51b2\u7a81 \u8f83\u591a \u8f83\u591a \u5f88\u5c11 \u5f88\u5c11 \u5b89\u5168\u7b49\u7ea7 \u4f4e\uff0c\u5df2\u88ab\u6210\u529f\u653b\u51fb \u4f4e\uff0c\u5df2\u88ab\u6210\u529f\u653b\u51fb \u9ad8 \u9ad8 \u5e94\u7528 \u5df2\u88ab\u5f03\u7528\uff0c\u4ecd\u7528\u4e8e\u6570\u636e\u5b8c\u6574\u6027\u68c0\u67e5 \u5df2\u88ab\u5f03\u7528 \u52a0\u5bc6\u8d27\u5e01\u4ea4\u6613\u9a8c\u8bc1\u3001\u6570\u5b57\u7b7e\u540d\u7b49 \u53ef\u7528\u4e8e\u66ff\u4ee3 SHA-2"},{"location":"chapter_hashing/hash_algorithm/#634","title":"6.3.4. \u00a0 \u6570\u636e\u7ed3\u6784\u7684\u54c8\u5e0c\u503c","text":"

    \u6211\u4eec\u77e5\u9053\uff0c\u54c8\u5e0c\u8868\u7684 key \u53ef\u4ee5\u662f\u6574\u6570\u3001\u5c0f\u6570\u6216\u5b57\u7b26\u4e32\u7b49\u6570\u636e\u7c7b\u578b\u3002\u7f16\u7a0b\u8bed\u8a00\u901a\u5e38\u4f1a\u4e3a\u8fd9\u4e9b\u6570\u636e\u7c7b\u578b\u63d0\u4f9b\u5185\u7f6e\u7684\u54c8\u5e0c\u7b97\u6cd5\uff0c\u7528\u4e8e\u8ba1\u7b97\u54c8\u5e0c\u8868\u4e2d\u7684\u6876\u7d22\u5f15\u3002\u4ee5 Python \u4e3a\u4f8b\uff0c\u6211\u4eec\u53ef\u4ee5\u8c03\u7528 hash() \u51fd\u6570\u6765\u8ba1\u7b97\u5404\u79cd\u6570\u636e\u7c7b\u578b\u7684\u54c8\u5e0c\u503c\uff0c\u5305\u62ec\uff1a

    • \u6574\u6570\u548c\u5e03\u5c14\u91cf\u7684\u54c8\u5e0c\u503c\u5c31\u662f\u5176\u672c\u8eab\u3002
    • \u6d6e\u70b9\u6570\u548c\u5b57\u7b26\u4e32\u7684\u54c8\u5e0c\u503c\u8ba1\u7b97\u8f83\u4e3a\u590d\u6742\uff0c\u6709\u5174\u8da3\u7684\u540c\u5b66\u8bf7\u81ea\u884c\u5b66\u4e60\u3002
    • \u5143\u7ec4\u7684\u54c8\u5e0c\u503c\u662f\u5bf9\u5176\u4e2d\u6bcf\u4e00\u4e2a\u5143\u7d20\u8fdb\u884c\u54c8\u5e0c\uff0c\u7136\u540e\u5c06\u8fd9\u4e9b\u54c8\u5e0c\u503c\u7ec4\u5408\u8d77\u6765\uff0c\u5f97\u5230\u5355\u4e00\u7684\u54c8\u5e0c\u503c\u3002
    • \u5bf9\u8c61\u7684\u54c8\u5e0c\u503c\u57fa\u4e8e\u5176\u5185\u5b58\u5730\u5740\u751f\u6210\u3002\u901a\u8fc7\u91cd\u5199\u5bf9\u8c61\u7684\u54c8\u5e0c\u65b9\u6cd5\uff0c\u53ef\u5b9e\u73b0\u57fa\u4e8e\u5185\u5bb9\u751f\u6210\u54c8\u5e0c\u503c\u3002

    Tip

    \u8bf7\u6ce8\u610f\uff0c\u4e0d\u540c\u7f16\u7a0b\u8bed\u8a00\u7684\u5185\u7f6e\u54c8\u5e0c\u503c\u8ba1\u7b97\u51fd\u6570\u7684\u5b9a\u4e49\u548c\u65b9\u6cd5\u4e0d\u540c\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart built_in_hash.java
    int num = 3;\nint hashNum = Integer.hashCode(num);\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 1231\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -1340954729\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode();\n// \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a -727081396\nObject[] arr = { 12836, \"\u5c0f\u54c8\" };\nint hashTup = Arrays.hashCode(arr);\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 1151158\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// \u8282\u70b9\u5bf9\u8c61 utils.ListNode@7dc5e7b4 \u7684\u54c8\u5e0c\u503c\u4e3a 2110121908\n
    built_in_hash.cpp
    int num = 3;\nsize_t hashNum = hash<int>()(num);\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\nbool bol = true;\nsize_t hashBol = hash<bool>()(bol);\n// \u5e03\u5c14\u91cf 1 \u7684\u54c8\u5e0c\u503c\u4e3a 1\ndouble dec = 3.14159;\nsize_t hashDec = hash<double>()(dec);\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 4614256650576692846\nstring str = \"Hello \u7b97\u6cd5\";\nsize_t hashStr = hash<string>()(str);\n// \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a 15466937326284535026\n// \u5728 C++ \u4e2d\uff0c\u5185\u7f6e std:hash() \u4ec5\u63d0\u4f9b\u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u54c8\u5e0c\u503c\u8ba1\u7b97\n// \u6570\u7ec4\u3001\u5bf9\u8c61\u7684\u54c8\u5e0c\u503c\u8ba1\u7b97\u9700\u8981\u81ea\u884c\u5b9e\u73b0\n
    built_in_hash.py
    num = 3\nhash_num = hash(num)\n# \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\nbol = True\nhash_bol = hash(bol)\n# \u5e03\u5c14\u91cf True \u7684\u54c8\u5e0c\u503c\u4e3a 1\ndec = 3.14159\nhash_dec = hash(dec) \n# \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 326484311674566659\nstr = \"Hello \u7b97\u6cd5\"\nhash_str = hash(str)\n# \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a 4617003410720528961\ntup = (12836, \"\u5c0f\u54c8\")\nhash_tup = hash(tup)\n# \u5143\u7ec4 (12836, '\u5c0f\u54c8') \u7684\u54c8\u5e0c\u503c\u4e3a 1029005403108185979\nobj = ListNode(0)\nhash_obj = hash(obj)\n# \u8282\u70b9\u5bf9\u8c61 <ListNode object at 0x1058fd810> \u7684\u54c8\u5e0c\u503c\u4e3a 274267521\n
    built_in_hash.go
    \n
    built_in_hash.js
    \n
    built_in_hash.ts
    \n
    built_in_hash.c
    \n
    built_in_hash.cs
    int num = 3;\nint hashNum = num.GetHashCode();\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3;\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 1;\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -1340954729;\nstring str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.GetHashCode();\n// \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a -586107568;\nobject[] arr = { 12836, \"\u5c0f\u54c8\" };\nint hashTup = arr.GetHashCode();\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 42931033;\nListNode obj = new ListNode(0);\nint hashObj = obj.GetHashCode();\n// \u8282\u70b9\u5bf9\u8c61 0 \u7684\u54c8\u5e0c\u503c\u4e3a 39053774;\n
    built_in_hash.swift
    let num = 3\nlet hashNum = num.hashValue\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 9047044699613009734\nlet bol = true\nlet hashBol = bol.hashValue\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a -4431640247352757451\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -2465384235396674631\nlet str = \"Hello \u7b97\u6cd5\"\nlet hashStr = str.hashValue\n// \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a -7850626797806988787\nlet arr = [AnyHashable(12836), AnyHashable(\"\u5c0f\u54c8\")]\nlet hashTup = arr.hashValue\n// \u6570\u7ec4 [AnyHashable(12836), AnyHashable(\"\u5c0f\u54c8\")] \u7684\u54c8\u5e0c\u503c\u4e3a -2308633508154532996\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// \u8282\u70b9\u5bf9\u8c61 utils.ListNode \u7684\u54c8\u5e0c\u503c\u4e3a -2434780518035996159\n
    built_in_hash.zig
    \n
    built_in_hash.dart
    int num = 3;\nint hashNum = num.hashCode;\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 34803\nbool bol = true;\nint hashBol = bol.hashCode;\n// \u5e03\u5c14\u503c true \u7684\u54c8\u5e0c\u503c\u4e3a 1231\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 2570631074981783\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode;\n// \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a 468167534\nList arr = [12836, \"\u5c0f\u54c8\"];\nint hashArr = arr.hashCode;\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 976512528\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// \u8282\u70b9\u5bf9\u8c61 Instance of 'ListNode' \u7684\u54c8\u5e0c\u503c\u4e3a 1033450432\n

    \u5728\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u53ea\u6709\u4e0d\u53ef\u53d8\u5bf9\u8c61\u624d\u53ef\u4f5c\u4e3a\u54c8\u5e0c\u8868\u7684 key \u3002\u5047\u5982\u6211\u4eec\u5c06\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\u4f5c\u4e3a key \uff0c\u5f53\u5217\u8868\u7684\u5185\u5bb9\u53d1\u751f\u53d8\u5316\u65f6\uff0c\u5b83\u7684\u54c8\u5e0c\u503c\u4e5f\u968f\u4e4b\u6539\u53d8\uff0c\u6211\u4eec\u5c31\u65e0\u6cd5\u5728\u54c8\u5e0c\u8868\u4e2d\u67e5\u8be2\u5230\u539f\u5148\u7684 value \u4e86\u3002

    \u867d\u7136\u81ea\u5b9a\u4e49\u5bf9\u8c61\uff08\u4f8b\u5982\u94fe\u8868\u8282\u70b9\uff09\u7684\u6210\u5458\u53d8\u91cf\u662f\u53ef\u53d8\u7684\uff0c\u4f46\u5b83\u662f\u53ef\u54c8\u5e0c\u7684\uff0c\u8fd9\u662f\u56e0\u4e3a\u5bf9\u8c61\u7684\u54c8\u5e0c\u503c\u9ed8\u8ba4\u57fa\u4e8e\u5185\u5b58\u5730\u5740\u751f\u6210\u3002\u5373\u4f7f\u5bf9\u8c61\u7684\u5185\u5bb9\u53d1\u751f\u4e86\u53d8\u5316\uff0c\u4f46\u5b83\u7684\u5185\u5b58\u5730\u5740\u4e0d\u53d8\uff0c\u54c8\u5e0c\u503c\u4ecd\u7136\u662f\u4e0d\u53d8\u7684\u3002

    \u5411\u54c8\u5e0c\u51fd\u6570\u52a0\u76d0

    Python \u89e3\u91ca\u5668\u5728\u6bcf\u6b21\u542f\u52a8\u65f6\uff0c\u90fd\u4f1a\u4e3a\u5b57\u7b26\u4e32\u54c8\u5e0c\u51fd\u6570\u52a0\u5165\u4e00\u4e2a\u968f\u673a\u7684\u76d0\uff08Salt\uff09\u503c\u3002\u56e0\u6b64\u5728\u4e0d\u540c\u7684 Python \u8fd0\u884c\u5b9e\u4f8b\u4e2d\uff0c\u540c\u4e00\u5b57\u7b26\u4e32\u7684\u54c8\u5e0c\u503c\u901a\u5e38\u662f\u4e0d\u540c\u7684\u3002\u6b64\u505a\u6cd5\u53ef\u4ee5\u6709\u6548\u9632\u6b62 HashDoS \u653b\u51fb\uff0c\u63d0\u5347\u54c8\u5e0c\u7b97\u6cd5\u7684\u5b89\u5168\u6027\u3002

    "},{"location":"chapter_hashing/hash_collision/","title":"6.2. \u00a0 \u54c8\u5e0c\u51b2\u7a81","text":"

    \u4e0a\u8282\u63d0\u5230\uff0c\u901a\u5e38\u60c5\u51b5\u4e0b\u54c8\u5e0c\u51fd\u6570\u7684\u8f93\u5165\u7a7a\u95f4\u8fdc\u5927\u4e8e\u8f93\u51fa\u7a7a\u95f4\uff0c\u56e0\u6b64\u54c8\u5e0c\u51b2\u7a81\u662f\u4e0d\u53ef\u907f\u514d\u7684\u3002\u4f8b\u5982\uff0c\u8f93\u5165\u7a7a\u95f4\u4e3a\u5168\u4f53\u6574\u6570\uff0c\u8f93\u51fa\u7a7a\u95f4\u4e3a\u6570\u7ec4\u5bb9\u91cf\u5927\u5c0f\uff0c\u5219\u5fc5\u7136\u6709\u591a\u4e2a\u6574\u6570\u6620\u5c04\u81f3\u540c\u4e00\u6570\u7ec4\u7d22\u5f15\u3002

    \u54c8\u5e0c\u51b2\u7a81\u4f1a\u5bfc\u81f4\u67e5\u8be2\u7ed3\u679c\u9519\u8bef\uff0c\u4e25\u91cd\u5f71\u54cd\u54c8\u5e0c\u8868\u7684\u53ef\u7528\u6027\u3002\u4e3a\u89e3\u51b3\u8be5\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u6bcf\u5f53\u9047\u5230\u54c8\u5e0c\u51b2\u7a81\u65f6\u5c31\u8fdb\u884c\u54c8\u5e0c\u8868\u6269\u5bb9\uff0c\u76f4\u81f3\u51b2\u7a81\u6d88\u5931\u4e3a\u6b62\u3002\u6b64\u65b9\u6cd5\u7b80\u5355\u7c97\u66b4\u4e14\u6709\u6548\uff0c\u4f46\u6548\u7387\u592a\u4f4e\uff0c\u56e0\u4e3a\u54c8\u5e0c\u8868\u6269\u5bb9\u9700\u8981\u8fdb\u884c\u5927\u91cf\u7684\u6570\u636e\u642c\u8fd0\u4e0e\u54c8\u5e0c\u503c\u8ba1\u7b97\u3002\u4e3a\u4e86\u63d0\u5347\u6548\u7387\uff0c\u6211\u4eec\u6362\u4e00\u79cd\u601d\u8def\uff1a

    1. \u6539\u826f\u54c8\u5e0c\u8868\u6570\u636e\u7ed3\u6784\uff0c\u4f7f\u5f97\u54c8\u5e0c\u8868\u53ef\u4ee5\u5728\u5b58\u5728\u54c8\u5e0c\u51b2\u7a81\u65f6\u6b63\u5e38\u5de5\u4f5c\u3002
    2. \u4ec5\u5728\u5fc5\u8981\u65f6\uff0c\u5373\u5f53\u54c8\u5e0c\u51b2\u7a81\u6bd4\u8f83\u4e25\u91cd\u65f6\uff0c\u6267\u884c\u6269\u5bb9\u64cd\u4f5c\u3002

    \u54c8\u5e0c\u8868\u7684\u7ed3\u6784\u6539\u826f\u65b9\u6cd5\u4e3b\u8981\u5305\u62ec\u94fe\u5f0f\u5730\u5740\u548c\u5f00\u653e\u5bfb\u5740\u3002

    "},{"location":"chapter_hashing/hash_collision/#621","title":"6.2.1. \u00a0 \u94fe\u5f0f\u5730\u5740","text":"

    \u5728\u539f\u59cb\u54c8\u5e0c\u8868\u4e2d\uff0c\u6bcf\u4e2a\u6876\u4ec5\u80fd\u5b58\u50a8\u4e00\u4e2a\u952e\u503c\u5bf9\u3002\u300c\u94fe\u5f0f\u5730\u5740 Separate Chaining\u300d\u5c06\u5355\u4e2a\u5143\u7d20\u8f6c\u6362\u4e3a\u94fe\u8868\uff0c\u5c06\u952e\u503c\u5bf9\u4f5c\u4e3a\u94fe\u8868\u8282\u70b9\uff0c\u5c06\u6240\u6709\u53d1\u751f\u51b2\u7a81\u7684\u952e\u503c\u5bf9\u90fd\u5b58\u50a8\u5728\u540c\u4e00\u94fe\u8868\u4e2d\u3002

    Fig. \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868

    \u94fe\u5f0f\u5730\u5740\u4e0b\uff0c\u54c8\u5e0c\u8868\u7684\u64cd\u4f5c\u65b9\u6cd5\u5305\u62ec\uff1a

    • \u67e5\u8be2\u5143\u7d20\uff1a\u8f93\u5165 key \uff0c\u7ecf\u8fc7\u54c8\u5e0c\u51fd\u6570\u5f97\u5230\u6570\u7ec4\u7d22\u5f15\uff0c\u5373\u53ef\u8bbf\u95ee\u94fe\u8868\u5934\u8282\u70b9\uff0c\u7136\u540e\u904d\u5386\u94fe\u8868\u5e76\u5bf9\u6bd4 key \u4ee5\u67e5\u627e\u76ee\u6807\u952e\u503c\u5bf9\u3002
    • \u6dfb\u52a0\u5143\u7d20\uff1a\u5148\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u8bbf\u95ee\u94fe\u8868\u5934\u8282\u70b9\uff0c\u7136\u540e\u5c06\u8282\u70b9\uff08\u5373\u952e\u503c\u5bf9\uff09\u6dfb\u52a0\u5230\u94fe\u8868\u4e2d\u3002
    • \u5220\u9664\u5143\u7d20\uff1a\u6839\u636e\u54c8\u5e0c\u51fd\u6570\u7684\u7ed3\u679c\u8bbf\u95ee\u94fe\u8868\u5934\u90e8\uff0c\u63a5\u7740\u904d\u5386\u94fe\u8868\u4ee5\u67e5\u627e\u76ee\u6807\u8282\u70b9\uff0c\u5e76\u5c06\u5176\u5220\u9664\u3002

    \u8be5\u65b9\u6cd5\u5b58\u5728\u4e00\u4e9b\u5c40\u9650\u6027\uff0c\u5305\u62ec\uff1a

    • \u5360\u7528\u7a7a\u95f4\u589e\u5927\uff0c\u7531\u4e8e\u94fe\u8868\u6216\u4e8c\u53c9\u6811\u5305\u542b\u8282\u70b9\u6307\u9488\uff0c\u76f8\u6bd4\u6570\u7ec4\u66f4\u52a0\u8017\u8d39\u5185\u5b58\u7a7a\u95f4\uff1b
    • \u67e5\u8be2\u6548\u7387\u964d\u4f4e\uff0c\u56e0\u4e3a\u9700\u8981\u7ebf\u6027\u904d\u5386\u94fe\u8868\u6765\u67e5\u627e\u5bf9\u5e94\u5143\u7d20\uff1b

    \u4ee5\u4e0b\u7ed9\u51fa\u4e86\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\u7684\u7b80\u5355\u5b9e\u73b0\uff0c\u9700\u8981\u6ce8\u610f\uff1a

    • \u4e3a\u4e86\u4f7f\u5f97\u4ee3\u7801\u5c3d\u91cf\u7b80\u77ed\uff0c\u6211\u4eec\u4f7f\u7528\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\u4ee3\u66ff\u94fe\u8868\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u54c8\u5e0c\u8868\uff08\u6570\u7ec4\uff09\u5305\u542b\u591a\u4e2a\u6876\uff0c\u6bcf\u4e2a\u6876\u90fd\u662f\u4e00\u4e2a\u5217\u8868\u3002
    • \u4ee5\u4e0b\u4ee3\u7801\u5b9e\u73b0\u4e86\u54c8\u5e0c\u8868\u6269\u5bb9\u65b9\u6cd5\u3002\u5177\u4f53\u6765\u770b\uff0c\u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7 \\(0.75\\) \u65f6\uff0c\u6211\u4eec\u5c06\u54c8\u5e0c\u8868\u6269\u5bb9\u81f3 \\(2\\) \u500d\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart hash_map_chaining.java
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\nint size; // \u952e\u503c\u5bf9\u6570\u91cf\nint capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\ndouble loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nint extendRatio; // \u6269\u5bb9\u500d\u6570\nList<List<Pair>> buckets; // \u6876\u6570\u7ec4\n/* \u6784\u9020\u65b9\u6cd5 */\npublic HashMapChaining() {\nsize = 0;\ncapacity = 4;\nloadThres = 2 / 3.0;\nextendRatio = 2;\nbuckets = new ArrayList<>(capacity);\nfor (int i = 0; i < capacity; i++) {\nbuckets.add(new ArrayList<>());\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor() {\nreturn (double) size / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nString get(int key) {\nint index = hashFunc(key);\nList<Pair> bucket = buckets.get(index);\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor (Pair pair : bucket) {\nif (pair.key == key) {\nreturn pair.val;\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de null\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, String val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\nList<Pair> bucket = buckets.get(index);\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor (Pair pair : bucket) {\nif (pair.key == key) {\npair.val = val;\nreturn;\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\nPair pair = new Pair(key, val);\nbucket.add(pair);\nsize++;\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\nList<Pair> bucket = buckets.get(index);\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nfor (Pair pair : bucket) {\nif (pair.key == key)\nbucket.remove(pair);\n}\nsize--;\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nList<List<Pair>> bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = new ArrayList<>(capacity);\nfor (int i = 0; i < capacity; i++) {\nbuckets.add(new ArrayList<>());\n}\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (List<Pair> bucket : bucketsTmp) {\nfor (Pair pair : bucket) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print() {\nfor (List<Pair> bucket : buckets) {\nList<String> res = new ArrayList<>();\nfor (Pair pair : bucket) {\nres.add(pair.key + \" -> \" + pair.val);\n}\nSystem.out.println(res);\n}\n}\n}\n
    hash_map_chaining.cpp
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\nprivate:\nint size;                       // \u952e\u503c\u5bf9\u6570\u91cf\nint capacity;                   // \u54c8\u5e0c\u8868\u5bb9\u91cf\ndouble loadThres;               // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nint extendRatio;                // \u6269\u5bb9\u500d\u6570\nvector<vector<Pair *>> buckets; // \u6876\u6570\u7ec4\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nHashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3), extendRatio(2) {\nbuckets.resize(capacity);\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor() {\nreturn (double)size / (double)capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nstring get(int key) {\nint index = hashFunc(key);\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor (Pair *pair : buckets[index]) {\nif (pair->key == key) {\nreturn pair->val;\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de nullptr\nreturn nullptr;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, string val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor (Pair *pair : buckets[index]) {\nif (pair->key == key) {\npair->val = val;\nreturn;\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\nbuckets[index].push_back(new Pair(key, val));\nsize++;\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\nauto &bucket = buckets[index];\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nfor (int i = 0; i < bucket.size(); i++) {\nif (bucket[i]->key == key) {\nPair *tmp = bucket[i];\nbucket.erase(bucket.begin() + i); // \u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\ndelete tmp;                       // \u91ca\u653e\u5185\u5b58\nsize--;\nreturn;\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nvector<vector<Pair *>> bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets.clear();\nbuckets.resize(capacity);\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (auto &bucket : bucketsTmp) {\nfor (Pair *pair : bucket) {\nput(pair->key, pair->val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print() {\nfor (auto &bucket : buckets) {\ncout << \"[\";\nfor (Pair *pair : bucket) {\ncout << pair->key << \" -> \" << pair->val << \", \";\n}\ncout << \"]\\n\";\n}\n}\n};\n
    hash_map_chaining.py
    class HashMapChaining:\n\"\"\"\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\nself.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\nself.load_thres = 2 / 3  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nself.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\nself.buckets = [[] for _ in range(self.capacity)]  # \u6876\u6570\u7ec4\ndef hash_func(self, key: int) -> int:\n\"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\nreturn key % self.capacity\ndef load_factor(self) -> float:\n\"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\nreturn self.size / self.capacity\ndef get(self, key: int) -> str:\n\"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\nindex = self.hash_func(key)\nbucket = self.buckets[index]\n# \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor pair in bucket:\nif pair.key == key:\nreturn pair.val\n# \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de None\nreturn None\ndef put(self, key: int, val: str):\n\"\"\"\u6dfb\u52a0\u64cd\u4f5c\"\"\"\n# \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif self.load_factor() > self.load_thres:\nself.extend()\nindex = self.hash_func(key)\nbucket = self.buckets[index]\n# \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor pair in bucket:\nif pair.key == key:\npair.val = val\nreturn\n# \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\npair = Pair(key, val)\nbucket.append(pair)\nself.size += 1\ndef remove(self, key: int):\n\"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\nindex = self.hash_func(key)\nbucket = self.buckets[index]\n# \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nfor pair in bucket:\nif pair.key == key:\nbucket.remove(pair)\nself.size -= 1\nreturn\ndef extend(self):\n\"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n# \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nbuckets = self.buckets\n# \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\nself.capacity *= self.extend_ratio\nself.buckets = [[] for _ in range(self.capacity)]\nself.size = 0\n# \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor bucket in buckets:\nfor pair in bucket:\nself.put(pair.key, pair.val)\ndef print(self):\n\"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\nfor bucket in self.buckets:\nres = []\nfor pair in bucket:\nres.append(str(pair.key) + \" -> \" + pair.val)\nprint(res)\n
    hash_map_chaining.go
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntype hashMapChaining struct {\nsize        int      // \u952e\u503c\u5bf9\u6570\u91cf\ncapacity    int      // \u54c8\u5e0c\u8868\u5bb9\u91cf\nloadThres   float64  // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nextendRatio int      // \u6269\u5bb9\u500d\u6570\nbuckets     [][]pair // \u6876\u6570\u7ec4\n}\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapChaining() *hashMapChaining {\nbuckets := make([][]pair, 4)\nfor i := 0; i < 4; i++ {\nbuckets[i] = make([]pair, 0)\n}\nreturn &hashMapChaining{\nsize:        0,\ncapacity:    4,\nloadThres:   2 / 3.0,\nextendRatio: 2,\nbuckets:     buckets,\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (m *hashMapChaining) hashFunc(key int) int {\nreturn key % m.capacity\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (m *hashMapChaining) loadFactor() float64 {\nreturn float64(m.size / m.capacity)\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (m *hashMapChaining) get(key int) string {\nidx := m.hashFunc(key)\nbucket := m.buckets[idx]\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor _, p := range bucket {\nif p.key == key {\nreturn p.val\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\nreturn \"\"\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (m *hashMapChaining) put(key int, val string) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif m.loadFactor() > m.loadThres {\nm.extend()\n}\nidx := m.hashFunc(key)\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor _, p := range m.buckets[idx] {\nif p.key == key {\np.val = val\nreturn\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\np := pair{\nkey: key,\nval: val,\n}\nm.buckets[idx] = append(m.buckets[idx], p)\nm.size += 1\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (m *hashMapChaining) remove(key int) {\nidx := m.hashFunc(key)\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nfor i, p := range m.buckets[idx] {\nif p.key == key {\n// \u5207\u7247\u5220\u9664\nm.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\nbreak\n}\n}\nm.size -= 1\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\ntmpBuckets := make([][]pair, len(m.buckets))\nfor i := 0; i < len(m.buckets); i++ {\ntmpBuckets[i] = make([]pair, len(m.buckets[i]))\ncopy(tmpBuckets[i], m.buckets[i])\n}\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\nm.capacity *= m.extendRatio\nm.buckets = make([][]pair, m.capacity)\nfor i := 0; i < m.capacity; i++ {\nm.buckets[i] = make([]pair, 0)\n}\nm.size = 0\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor _, bucket := range tmpBuckets {\nfor _, p := range bucket {\nm.put(p.key, p.val)\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) print() {\nvar builder strings.Builder\nfor _, bucket := range m.buckets {\nbuilder.WriteString(\"[\")\nfor _, p := range bucket {\nbuilder.WriteString(strconv.Itoa(p.key) + \" -> \" + p.val + \" \")\n}\nbuilder.WriteString(\"]\")\nfmt.Println(builder.String())\nbuilder.Reset()\n}\n}\n
    hash_map_chaining.js
    [class]{HashMapChaining}-[func]{}\n
    hash_map_chaining.ts
    [class]{HashMapChaining}-[func]{}\n
    hash_map_chaining.c
    [class]{hashMapChaining}-[func]{}\n
    hash_map_chaining.cs
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\nint size; // \u952e\u503c\u5bf9\u6570\u91cf\nint capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\ndouble loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nint extendRatio; // \u6269\u5bb9\u500d\u6570\nList<List<Pair>> buckets; // \u6876\u6570\u7ec4\n/* \u6784\u9020\u65b9\u6cd5 */\npublic HashMapChaining() {\nsize = 0;\ncapacity = 4;\nloadThres = 2 / 3.0;\nextendRatio = 2;\nbuckets = new List<List<Pair>>(capacity);\nfor (int i = 0; i < capacity; i++) {\nbuckets.Add(new List<Pair>());\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate int hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nprivate double loadFactor() {\nreturn (double)size / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic string get(int key) {\nint index = hashFunc(key);\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nforeach (Pair pair in buckets[index]) {\nif (pair.key == key) {\nreturn pair.val;\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de null\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic void put(int key, string val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nforeach (Pair pair in buckets[index]) {\nif (pair.key == key) {\npair.val = val;\nreturn;\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\nbuckets[index].Add(new Pair(key, val));\nsize++;\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic void remove(int key) {\nint index = hashFunc(key);\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nforeach (Pair pair in buckets[index].ToList()) { if (pair.key == key) {\nbuckets[index].Remove(pair);\n}\n}\nsize--;   }\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nprivate void extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nList<List<Pair>> bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = new List<List<Pair>>(capacity);\nfor (int i = 0; i < capacity; i++) {\nbuckets.Add(new List<Pair>());\n}\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nforeach (List<Pair> bucket in bucketsTmp) {\nforeach (Pair pair in bucket) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic void print() {\nforeach (List<Pair> bucket in buckets) {\nList<string> res = new List<string>();\nforeach (Pair pair in bucket) {\nres.Add(pair.key + \" -> \" + pair.val);\n}\nforeach (string kv in res) {\nConsole.WriteLine(kv);\n}\n}\n}\n}\n
    hash_map_chaining.swift
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\nvar size: Int // \u952e\u503c\u5bf9\u6570\u91cf\nvar capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\nvar loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nvar extendRatio: Int // \u6269\u5bb9\u500d\u6570\nvar buckets: [[Pair]] // \u6876\u6570\u7ec4\n/* \u6784\u9020\u65b9\u6cd5 */\ninit() {\nsize = 0\ncapacity = 4\nloadThres = 2 / 3\nextendRatio = 2\nbuckets = Array(repeating: [], count: capacity)\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc hashFunc(key: Int) -> Int {\nkey % capacity\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc loadFactor() -> Double {\nDouble(size / capacity)\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc get(key: Int) -> String? {\nlet index = hashFunc(key: key)\nlet bucket = buckets[index]\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor pair in bucket {\nif pair.key == key {\nreturn pair.val\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de nil\nreturn nil\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc put(key: Int, val: String) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif loadFactor() > loadThres {\nextend()\n}\nlet index = hashFunc(key: key)\nlet bucket = buckets[index]\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor pair in bucket {\nif pair.key == key {\npair.val = val\nreturn\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\nlet pair = Pair(key: key, val: val)\nbuckets[index].append(pair)\nsize += 1\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc remove(key: Int) {\nlet index = hashFunc(key: key)\nlet bucket = buckets[index]\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nfor (pairIndex, pair) in bucket.enumerated() {\nif pair.key == key {\nbuckets[index].remove(at: pairIndex)\n}\n}\nsize -= 1\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nlet bucketsTmp = buckets\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio\nbuckets = Array(repeating: [], count: capacity)\nsize = 0\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor bucket in bucketsTmp {\nfor pair in bucket {\nput(key: pair.key, val: pair.val)\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc print() {\nfor bucket in buckets {\nlet res = bucket.map { \"\\($0.key) -> \\($0.val)\" }\nSwift.print(res)\n}\n}\n}\n
    hash_map_chaining.zig
    [class]{HashMapChaining}-[func]{}\n
    hash_map_chaining.dart
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\nlate int size; // \u952e\u503c\u5bf9\u6570\u91cf\nlate int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\nlate double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nlate int extendRatio; // \u6269\u5bb9\u500d\u6570\nlate List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n/* \u6784\u9020\u65b9\u6cd5 */\nHashMapChaining() {\nsize = 0;\ncapacity = 4;\nloadThres = 2 / 3.0;\nextendRatio = 2;\nbuckets = List.generate(capacity, (_) => []);\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor() {\nreturn size / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nString? get(int key) {\nint index = hashFunc(key);\nList<Pair> bucket = buckets[index];\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor (Pair pair in bucket) {\nif (pair.key == key) {\nreturn pair.val;\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de null\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, String val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\nList<Pair> bucket = buckets[index];\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor (Pair pair in bucket) {\nif (pair.key == key) {\npair.val = val;\nreturn;\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\nPair pair = Pair(key, val);\nbucket.add(pair);\nsize++;\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\nList<Pair> bucket = buckets[index];\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nbucket.removeWhere((Pair pair) => pair.key == key);\nsize--;\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nList<List<Pair>> bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = List.generate(capacity, (_) => []);\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (List<Pair> bucket in bucketsTmp) {\nfor (Pair pair in bucket) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid printHashMap() {\nfor (List<Pair> bucket in buckets) {\nList<String> res = [];\nfor (Pair pair in bucket) {\nres.add(\"${pair.key} -> ${pair.val}\");\n}\nprint(res);\n}\n}\n}\n

    Tip

    \u4e3a\u4e86\u63d0\u9ad8\u6548\u7387\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u300cAVL \u6811\u300d\u6216\u300c\u7ea2\u9ed1\u6811\u300d\uff0c\u4ece\u800c\u5c06\u67e5\u8be2\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u81f3 \\(O(\\log n)\\) \u3002

    "},{"location":"chapter_hashing/hash_collision/#622","title":"6.2.2. \u00a0 \u5f00\u653e\u5bfb\u5740","text":"

    \u300c\u5f00\u653e\u5bfb\u5740 Open Addressing\u300d\u4e0d\u5f15\u5165\u989d\u5916\u7684\u6570\u636e\u7ed3\u6784\uff0c\u800c\u662f\u901a\u8fc7\u201c\u591a\u6b21\u63a2\u6d4b\u201d\u6765\u5904\u7406\u54c8\u5e0c\u51b2\u7a81\uff0c\u63a2\u6d4b\u65b9\u5f0f\u4e3b\u8981\u5305\u62ec\u7ebf\u6027\u63a2\u6d4b\u3001\u5e73\u65b9\u63a2\u6d4b\u3001\u591a\u6b21\u54c8\u5e0c\u3002

    "},{"location":"chapter_hashing/hash_collision/#_1","title":"\u7ebf\u6027\u63a2\u6d4b","text":"

    \u7ebf\u6027\u63a2\u6d4b\u91c7\u7528\u56fa\u5b9a\u6b65\u957f\u7684\u7ebf\u6027\u67e5\u627e\u6765\u8fdb\u884c\u63a2\u6d4b\uff0c\u5bf9\u5e94\u7684\u54c8\u5e0c\u8868\u64cd\u4f5c\u65b9\u6cd5\u4e3a\uff1a

    • \u63d2\u5165\u5143\u7d20\uff1a\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u8ba1\u7b97\u6570\u7ec4\u7d22\u5f15\uff0c\u82e5\u53d1\u73b0\u6876\u5185\u5df2\u6709\u5143\u7d20\uff0c\u5219\u4ece\u51b2\u7a81\u4f4d\u7f6e\u5411\u540e\u7ebf\u6027\u904d\u5386\uff08\u6b65\u957f\u901a\u5e38\u4e3a \\(1\\) \uff09\uff0c\u76f4\u81f3\u627e\u5230\u7a7a\u4f4d\uff0c\u5c06\u5143\u7d20\u63d2\u5165\u5176\u4e2d\u3002
    • \u67e5\u627e\u5143\u7d20\uff1a\u82e5\u53d1\u73b0\u54c8\u5e0c\u51b2\u7a81\uff0c\u5219\u4f7f\u7528\u76f8\u540c\u6b65\u957f\u5411\u540e\u7ebf\u6027\u904d\u5386\uff0c\u76f4\u5230\u627e\u5230\u5bf9\u5e94\u5143\u7d20\uff0c\u8fd4\u56de value \u5373\u53ef\uff1b\u6216\u8005\u82e5\u9047\u5230\u7a7a\u4f4d\uff0c\u8bf4\u660e\u76ee\u6807\u952e\u503c\u5bf9\u4e0d\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u8fd4\u56de \\(\\text{None}\\) \u3002

    Fig. \u7ebf\u6027\u63a2\u6d4b

    \u7136\u800c\uff0c\u7ebf\u6027\u63a2\u6d4b\u5b58\u5728\u4ee5\u4e0b\u7f3a\u9677\uff1a

    • \u4e0d\u80fd\u76f4\u63a5\u5220\u9664\u5143\u7d20\u3002\u5220\u9664\u5143\u7d20\u4f1a\u5728\u6570\u7ec4\u5185\u4ea7\u751f\u4e00\u4e2a\u7a7a\u4f4d\uff0c\u67e5\u627e\u5176\u4ed6\u5143\u7d20\u65f6\uff0c\u8be5\u7a7a\u4f4d\u53ef\u80fd\u5bfc\u81f4\u7a0b\u5e8f\u8bef\u5224\u5143\u7d20\u4e0d\u5b58\u5728\u3002\u56e0\u6b64\uff0c\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u6807\u5fd7\u4f4d\u6765\u6807\u8bb0\u5df2\u5220\u9664\u5143\u7d20\u3002
    • \u5bb9\u6613\u4ea7\u751f\u805a\u96c6\u3002\u6570\u7ec4\u5185\u8fde\u7eed\u88ab\u5360\u7528\u4f4d\u7f6e\u8d8a\u957f\uff0c\u8fd9\u4e9b\u8fde\u7eed\u4f4d\u7f6e\u53d1\u751f\u54c8\u5e0c\u51b2\u7a81\u7684\u53ef\u80fd\u6027\u8d8a\u5927\uff0c\u8fdb\u4e00\u6b65\u4fc3\u4f7f\u8fd9\u4e00\u4f4d\u7f6e\u7684\u201c\u805a\u5806\u751f\u957f\u201d\uff0c\u6700\u7ec8\u5bfc\u81f4\u589e\u5220\u67e5\u6539\u64cd\u4f5c\u6548\u7387\u964d\u4f4e\u3002

    \u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u4e3a\u5f00\u653e\u5bfb\u5740\uff08\u7ebf\u6027\u63a2\u6d4b\uff09\u54c8\u5e0c\u8868\u7684\u7b80\u5355\u5b9e\u73b0\uff0c\u91cd\u70b9\u5305\u62ec\uff1a

    • \u6211\u4eec\u4f7f\u7528\u4e00\u4e2a\u56fa\u5b9a\u7684\u952e\u503c\u5bf9\u5b9e\u4f8b removed \u6765\u6807\u8bb0\u5df2\u5220\u9664\u5143\u7d20\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u5f53\u4e00\u4e2a\u6876\u4e3a \\(\\text{None}\\) \u6216 removed \u65f6\uff0c\u8fd9\u4e2a\u6876\u90fd\u662f\u7a7a\u7684\uff0c\u53ef\u7528\u4e8e\u653e\u7f6e\u952e\u503c\u5bf9\u3002
    • \u88ab\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u7a7a\u95f4\u662f\u53ef\u4ee5\u518d\u6b21\u88ab\u4f7f\u7528\u7684\u3002\u5f53\u63d2\u5165\u5143\u7d20\u65f6\uff0c\u82e5\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u627e\u5230\u4e86\u88ab\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u7d22\u5f15\uff0c\u5219\u53ef\u5c06\u8be5\u5143\u7d20\u653e\u7f6e\u5230\u8be5\u7d22\u5f15\u3002
    • \u5728\u7ebf\u6027\u63a2\u6d4b\u65f6\uff0c\u6211\u4eec\u4ece\u5f53\u524d\u7d22\u5f15 index \u5411\u540e\u904d\u5386\uff1b\u800c\u5f53\u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u9700\u8981\u56de\u5230\u5934\u90e8\u7ee7\u7eed\u904d\u5386\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart hash_map_open_addressing.java
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\nprivate int size; // \u952e\u503c\u5bf9\u6570\u91cf\nprivate int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\nprivate double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nprivate int extendRatio; // \u6269\u5bb9\u500d\u6570\nprivate Pair[] buckets; // \u6876\u6570\u7ec4\nprivate Pair removed; // \u5220\u9664\u6807\u8bb0\n/* \u6784\u9020\u65b9\u6cd5 */\npublic HashMapOpenAddressing() {\nsize = 0;\ncapacity = 4;\nloadThres = 2.0 / 3.0;\nextendRatio = 2;\nbuckets = new Pair[capacity];\nremoved = new Pair(-1, \"-1\");\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\npublic int hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\npublic double loadFactor() {\nreturn (double) size / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic String get(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de null\nif (buckets[j] == null)\nreturn null;\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif (buckets[j].key == key && buckets[j] != removed)\nreturn buckets[j].val;\n}\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic void put(int key, String val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif (buckets[j] == null || buckets[j] == removed) {\nbuckets[j] = new Pair(key, val);\nsize += 1;\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif (buckets[j].key == key) {\nbuckets[j].val = val;\nreturn;\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic void remove(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (buckets[j] == null) {\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif (buckets[j].key == key) {\nbuckets[j] = removed;\nsize -= 1;\nreturn;\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\npublic void extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nPair[] bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = new Pair[capacity];\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (Pair pair : bucketsTmp) {\nif (pair != null && pair != removed) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic void print() {\nfor (Pair pair : buckets) {\nif (pair != null) {\nSystem.out.println(pair.key + \" -> \" + pair.val);\n} else {\nSystem.out.println(\"null\");\n}\n}\n}\n}\n
    hash_map_open_addressing.cpp
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\nprivate:\nint size;               // \u952e\u503c\u5bf9\u6570\u91cf\nint capacity;           // \u54c8\u5e0c\u8868\u5bb9\u91cf\ndouble loadThres;       // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nint extendRatio;        // \u6269\u5bb9\u500d\u6570\nvector<Pair *> buckets; // \u6876\u6570\u7ec4\nPair *removed;          // \u5220\u9664\u6807\u8bb0\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nHashMapOpenAddressing() {\n// \u6784\u9020\u65b9\u6cd5\nsize = 0;\ncapacity = 4;\nloadThres = 2.0 / 3.0;\nextendRatio = 2;\nbuckets = vector<Pair *>(capacity, nullptr);\nremoved = new Pair(-1, \"-1\");\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor() {\nreturn static_cast<double>(size) / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nstring get(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de nullptr\nif (buckets[j] == nullptr)\nreturn nullptr;\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif (buckets[j]->key == key && buckets[j] != removed)\nreturn buckets[j]->val;\n}\nreturn nullptr;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, string val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres)\nextend();\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif (buckets[j] == nullptr || buckets[j] == removed) {\nbuckets[j] = new Pair(key, val);\nsize += 1;\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif (buckets[j]->key == key) {\nbuckets[j]->val = val;\nreturn;\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (buckets[j] == nullptr)\nreturn;\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif (buckets[j]->key == key) {\ndelete buckets[j]; // \u91ca\u653e\u5185\u5b58\nbuckets[j] = removed;\nsize -= 1;\nreturn;\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nvector<Pair *> bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = vector<Pair *>(capacity, nullptr);\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (Pair *pair : bucketsTmp) {\nif (pair != nullptr && pair != removed) {\nput(pair->key, pair->val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print() {\nfor (auto &pair : buckets) {\nif (pair != nullptr) {\ncout << pair->key << \" -> \" << pair->val << endl;\n} else {\ncout << \"nullptr\" << endl;\n}\n}\n}\n};\n
    hash_map_open_addressing.py
    class HashMapOpenAddressing:\n\"\"\"\u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\nself.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\nself.load_thres = 2 / 3  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nself.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\nself.buckets: list[Pair | None] = [None] * self.capacity  # \u6876\u6570\u7ec4\nself.removed = Pair(-1, \"-1\")  # \u5220\u9664\u6807\u8bb0\ndef hash_func(self, key: int) -> int:\n\"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\nreturn key % self.capacity\ndef load_factor(self) -> float:\n\"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\nreturn self.size / self.capacity\ndef get(self, key: int) -> str:\n\"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\nindex = self.hash_func(key)\n# \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in range(self.capacity):\n# \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj = (index + i) % self.capacity\n# \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de None\nif self.buckets[j] is None:\nreturn None\n# \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif self.buckets[j].key == key and self.buckets[j] != self.removed:\nreturn self.buckets[j].val\ndef put(self, key: int, val: str):\n\"\"\"\u6dfb\u52a0\u64cd\u4f5c\"\"\"\n# \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif self.load_factor() > self.load_thres:\nself.extend()\nindex = self.hash_func(key)\n# \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in range(self.capacity):\n# \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj = (index + i) % self.capacity\n# \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif self.buckets[j] in [None, self.removed]:\nself.buckets[j] = Pair(key, val)\nself.size += 1\nreturn\n# \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif self.buckets[j].key == key:\nself.buckets[j].val = val\nreturn\ndef remove(self, key: int):\n\"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\nindex = self.hash_func(key)\n# \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in range(self.capacity):\n# \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj = (index + i) % self.capacity\n# \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif self.buckets[j] is None:\nreturn\n# \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif self.buckets[j].key == key:\nself.buckets[j] = self.removed\nself.size -= 1\nreturn\ndef extend(self):\n\"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n# \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nbuckets_tmp = self.buckets\n# \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\nself.capacity *= self.extend_ratio\nself.buckets = [None] * self.capacity\nself.size = 0\n# \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor pair in buckets_tmp:\nif pair not in [None, self.removed]:\nself.put(pair.key, pair.val)\ndef print(self) -> None:\n\"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\nfor pair in self.buckets:\nif pair is not None:\nprint(pair.key, \"->\", pair.val)\nelse:\nprint(\"None\")\n
    hash_map_open_addressing.go
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntype hashMapOpenAddressing struct {\nsize        int     // \u952e\u503c\u5bf9\u6570\u91cf\ncapacity    int     // \u54c8\u5e0c\u8868\u5bb9\u91cf\nloadThres   float64 // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nextendRatio int     // \u6269\u5bb9\u500d\u6570\nbuckets     []pair  // \u6876\u6570\u7ec4\nremoved     pair    // \u5220\u9664\u6807\u8bb0\n}\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\nbuckets := make([]pair, 4)\nreturn &hashMapOpenAddressing{\nsize:        0,\ncapacity:    4,\nloadThres:   2 / 3.0,\nextendRatio: 2,\nbuckets:     buckets,\nremoved: pair{\nkey: -1,\nval: \"-1\",\n},\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (m *hashMapOpenAddressing) hashFunc(key int) int {\nreturn key % m.capacity\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (m *hashMapOpenAddressing) loadFactor() float64 {\nreturn float64(m.size) / float64(m.capacity)\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (m *hashMapOpenAddressing) get(key int) string {\nidx := m.hashFunc(key)\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i := 0; i < m.capacity; i++ {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj := (idx + 1) % m.capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de null\nif m.buckets[j] == (pair{}) {\nreturn \"\"\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif m.buckets[j].key == key && m.buckets[j] != m.removed {\nreturn m.buckets[j].val\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\nreturn \"\"\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (m *hashMapOpenAddressing) put(key int, val string) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif m.loadFactor() > m.loadThres {\nm.extend()\n}\nidx := m.hashFunc(key)\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i := 0; i < m.capacity; i++ {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj := (idx + i) % m.capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif m.buckets[j] == (pair{}) || m.buckets[j] == m.removed {\nm.buckets[j] = pair{\nkey: key,\nval: val,\n}\nm.size += 1\nreturn\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif m.buckets[j].key == key {\nm.buckets[j].val = val\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (m *hashMapOpenAddressing) remove(key int) {\nidx := m.hashFunc(key)\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i := 0; i < m.capacity; i++ {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj := (idx + 1) % m.capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif m.buckets[j] == (pair{}) {\nreturn\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif m.buckets[j].key == key {\nm.buckets[j] = m.removed\nm.size -= 1\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (m *hashMapOpenAddressing) extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\ntmpBuckets := make([]pair, len(m.buckets))\ncopy(tmpBuckets, m.buckets)\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\nm.capacity *= m.extendRatio\nm.buckets = make([]pair, m.capacity)\nm.size = 0\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor _, p := range tmpBuckets {\nif p != (pair{}) && p != m.removed {\nm.put(p.key, p.val)\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (m *hashMapOpenAddressing) print() {\nfor _, p := range m.buckets {\nif p != (pair{}) {\nfmt.Println(strconv.Itoa(p.key) + \" -> \" + p.val)\n} else {\nfmt.Println(\"nil\")\n}\n}\n}\n
    hash_map_open_addressing.js
    [class]{HashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.ts
    [class]{HashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.c
    [class]{hashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.cs
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\nint size; // \u952e\u503c\u5bf9\u6570\u91cf\nint capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\ndouble loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nint extendRatio; // \u6269\u5bb9\u500d\u6570\nPair[] buckets; // \u6876\u6570\u7ec4\nPair removed; // \u5220\u9664\u6807\u8bb0\n/* \u6784\u9020\u65b9\u6cd5 */\npublic HashMapOpenAddressing() {\nsize = 0;\ncapacity = 4;\nloadThres = 2.0 / 3.0;\nextendRatio = 2;\nbuckets = new Pair[capacity];\nremoved = new Pair(-1, \"-1\");\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate int hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nprivate double loadFactor() {\nreturn (double)size / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic string get(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de null\nif (buckets[j] == null)\nreturn null;\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif (buckets[j].key == key && buckets[j] != removed)\nreturn buckets[j].val;\n}\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic void put(int key, string val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif (buckets[j] == null || buckets[j] == removed) {\nbuckets[j] = new Pair(key, val);\nsize += 1;\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif (buckets[j].key == key) {\nbuckets[j].val = val;\nreturn;\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic void remove(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (buckets[j] == null) {\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif (buckets[j].key == key) {\nbuckets[j] = removed;\nsize -= 1;\nreturn;\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nprivate void extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nPair[] bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = new Pair[capacity];\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nforeach (Pair pair in bucketsTmp) {\nif (pair != null && pair != removed) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic void print() {\nforeach (Pair pair in buckets) {\nif (pair != null) {\nConsole.WriteLine(pair.key + \" -> \" + pair.val);\n} else {\nConsole.WriteLine(\"null\");\n}\n}\n}\n}\n
    hash_map_open_addressing.swift
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\nvar size: Int // \u952e\u503c\u5bf9\u6570\u91cf\nvar capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\nvar loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nvar extendRatio: Int // \u6269\u5bb9\u500d\u6570\nvar buckets: [Pair?] // \u6876\u6570\u7ec4\nvar removed: Pair // \u5220\u9664\u6807\u8bb0\n/* \u6784\u9020\u65b9\u6cd5 */\ninit() {\nsize = 0\ncapacity = 4\nloadThres = 2 / 3\nextendRatio = 2\nbuckets = Array(repeating: nil, count: capacity)\nremoved = Pair(key: -1, val: \"-1\")\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc hashFunc(key: Int) -> Int {\nkey % capacity\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc loadFactor() -> Double {\nDouble(size / capacity)\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc get(key: Int) -> String? {\nlet index = hashFunc(key: key)\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in stride(from: 0, to: capacity, by: 1) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nlet j = (index + i) % capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de nil\nif buckets[j] == nil {\nreturn nil\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif buckets[j]?.key == key, buckets[j] != removed {\nreturn buckets[j]?.val\n}\n}\nreturn nil\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc put(key: Int, val: String) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif loadFactor() > loadThres {\nextend()\n}\nlet index = hashFunc(key: key)\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in stride(from: 0, through: capacity, by: 1) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nlet j = (index + i) % capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif buckets[j] == nil || buckets[j] == removed {\nbuckets[j] = Pair(key: key, val: val)\nsize += 1\nreturn\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif buckets[j]?.key == key {\nbuckets[j]?.val = val\nreturn\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc remove(key: Int) {\nlet index = hashFunc(key: key)\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in stride(from: 0, to: capacity, by: 1) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nlet j = (index + i) % capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif buckets[j] == nil {\nreturn\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif buckets[j]?.key == key {\nbuckets[j] = removed\nsize -= 1\nreturn\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nlet bucketsTmp = buckets\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio\nbuckets = Array(repeating: nil, count: capacity)\nsize = 0\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor pair in bucketsTmp {\nif let pair, pair != removed {\nput(key: pair.key, val: pair.val)\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc print() {\nfor pair in buckets {\nif let pair {\nSwift.print(\"\\(pair.key) -> \\(pair.val)\")\n} else {\nSwift.print(\"null\")\n}\n}\n}\n}\n
    hash_map_open_addressing.zig
    [class]{HashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.dart
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\nlate int _size; // \u952e\u503c\u5bf9\u6570\u91cf\nlate int _capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\nlate double _loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nlate int _extendRatio; // \u6269\u5bb9\u500d\u6570\nlate List<Pair?> _buckets; // \u6876\u6570\u7ec4\nlate Pair _removed; // \u5220\u9664\u6807\u8bb0\n/* \u6784\u9020\u65b9\u6cd5 */\nHashMapOpenAddressing() {\n_size = 0;\n_capacity = 4;\n_loadThres = 2.0 / 3.0;\n_extendRatio = 2;\n_buckets = List.generate(_capacity, (index) => null);\n_removed = Pair(-1, \"-1\");\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nreturn key % _capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor() {\nreturn _size / _capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nString? get(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < _capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % _capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de null\nif (_buckets[j] == null) return null;\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif (_buckets[j]!.key == key && _buckets[j] != _removed)\nreturn _buckets[j]!.val;\n}\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, String val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > _loadThres) {\nextend();\n}\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < _capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % _capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif (_buckets[j] == null || _buckets[j] == _removed) {\n_buckets[j] = new Pair(key, val);\n_size += 1;\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif (_buckets[j]!.key == key) {\n_buckets[j]!.val = val;\nreturn;\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < _capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % _capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (_buckets[j] == null) {\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif (_buckets[j]!.key == key) {\n_buckets[j] = _removed;\n_size -= 1;\nreturn;\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nList<Pair?> bucketsTmp = _buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n_capacity *= _extendRatio;\n_buckets = List.generate(_capacity, (index) => null);\n_size = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (Pair? pair in bucketsTmp) {\nif (pair != null && pair != _removed) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid printHashMap() {\nfor (Pair? pair in _buckets) {\nif (pair != null) {\nprint(\"${pair.key} -> ${pair.val}\");\n} else {\nprint(null);\n}\n}\n}\n}\n
    "},{"location":"chapter_hashing/hash_collision/#_2","title":"\u591a\u6b21\u54c8\u5e0c","text":"

    \u987e\u540d\u601d\u4e49\uff0c\u591a\u6b21\u54c8\u5e0c\u65b9\u6cd5\u662f\u4f7f\u7528\u591a\u4e2a\u54c8\u5e0c\u51fd\u6570 \\(f_1(x)\\) , \\(f_2(x)\\) , \\(f_3(x)\\) , \\(\\cdots\\) \u8fdb\u884c\u63a2\u6d4b\u3002

    • \u63d2\u5165\u5143\u7d20\uff1a\u82e5\u54c8\u5e0c\u51fd\u6570 \\(f_1(x)\\) \u51fa\u73b0\u51b2\u7a81\uff0c\u5219\u5c1d\u8bd5 \\(f_2(x)\\) \uff0c\u4ee5\u6b64\u7c7b\u63a8\uff0c\u76f4\u5230\u627e\u5230\u7a7a\u4f4d\u540e\u63d2\u5165\u5143\u7d20\u3002
    • \u67e5\u627e\u5143\u7d20\uff1a\u5728\u76f8\u540c\u7684\u54c8\u5e0c\u51fd\u6570\u987a\u5e8f\u4e0b\u8fdb\u884c\u67e5\u627e\uff0c\u76f4\u5230\u627e\u5230\u76ee\u6807\u5143\u7d20\u65f6\u8fd4\u56de\uff1b\u6216\u9047\u5230\u7a7a\u4f4d\u6216\u5df2\u5c1d\u8bd5\u6240\u6709\u54c8\u5e0c\u51fd\u6570\uff0c\u8bf4\u660e\u54c8\u5e0c\u8868\u4e2d\u4e0d\u5b58\u5728\u8be5\u5143\u7d20\uff0c\u5219\u8fd4\u56de \\(\\text{None}\\) \u3002

    \u4e0e\u7ebf\u6027\u63a2\u6d4b\u76f8\u6bd4\uff0c\u591a\u6b21\u54c8\u5e0c\u65b9\u6cd5\u4e0d\u6613\u4ea7\u751f\u805a\u96c6\uff0c\u4f46\u591a\u4e2a\u54c8\u5e0c\u51fd\u6570\u4f1a\u589e\u52a0\u989d\u5916\u7684\u8ba1\u7b97\u91cf\u3002

    \u7f16\u7a0b\u8bed\u8a00\u7684\u9009\u62e9

    Java \u91c7\u7528\u94fe\u5f0f\u5730\u5740\u3002\u81ea JDK 1.8 \u4ee5\u6765\uff0c\u5f53 HashMap \u5185\u6570\u7ec4\u957f\u5ea6\u8fbe\u5230 64 \u4e14\u94fe\u8868\u957f\u5ea6\u8fbe\u5230 8 \u65f6\uff0c\u94fe\u8868\u4f1a\u88ab\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811\u4ee5\u63d0\u5347\u67e5\u627e\u6027\u80fd\u3002

    Python \u91c7\u7528\u5f00\u653e\u5bfb\u5740\u3002\u5b57\u5178 dict \u4f7f\u7528\u4f2a\u968f\u673a\u6570\u8fdb\u884c\u63a2\u6d4b\u3002

    Golang \u91c7\u7528\u94fe\u5f0f\u5730\u5740\u3002Go \u89c4\u5b9a\u6bcf\u4e2a\u6876\u6700\u591a\u5b58\u50a8 8 \u4e2a\u952e\u503c\u5bf9\uff0c\u8d85\u51fa\u5bb9\u91cf\u5219\u8fde\u63a5\u4e00\u4e2a\u6ea2\u51fa\u6876\uff1b\u5f53\u6ea2\u51fa\u6876\u8fc7\u591a\u65f6\uff0c\u4f1a\u6267\u884c\u4e00\u6b21\u7279\u6b8a\u7684\u7b49\u91cf\u6269\u5bb9\u64cd\u4f5c\uff0c\u4ee5\u786e\u4fdd\u6027\u80fd\u3002

    "},{"location":"chapter_hashing/hash_map/","title":"6.1. \u00a0 \u54c8\u5e0c\u8868","text":"

    \u300c\u54c8\u5e0c\u8868 Hash Table\u300d\u901a\u8fc7\u5efa\u7acb\u952e key \u4e0e\u503c value \u4e4b\u95f4\u7684\u6620\u5c04\uff0c\u5b9e\u73b0\u9ad8\u6548\u7684\u5143\u7d20\u67e5\u8be2\u3002\u5177\u4f53\u800c\u8a00\uff0c\u6211\u4eec\u5411\u54c8\u5e0c\u8868\u8f93\u5165\u4e00\u4e2a key \uff0c\u5219\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u83b7\u53d6\u5bf9\u5e94\u7684 value \u3002

    \u4ee5\u4e00\u4e2a\u5305\u542b \\(n\\) \u4e2a\u5b66\u751f\u7684\u6570\u636e\u5e93\u4e3a\u4f8b\uff0c\u6bcf\u4e2a\u5b66\u751f\u90fd\u6709\u201c\u59d3\u540d\u201d\u548c\u201c\u5b66\u53f7\u201d\u4e24\u9879\u6570\u636e\u3002\u5047\u5982\u6211\u4eec\u5e0c\u671b\u5b9e\u73b0\u201c\u8f93\u5165\u4e00\u4e2a\u5b66\u53f7\uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u59d3\u540d\u201d\u7684\u67e5\u8be2\u529f\u80fd\uff0c\u5219\u53ef\u4ee5\u91c7\u7528\u54c8\u5e0c\u8868\u6765\u5b9e\u73b0\u3002

    Fig. \u54c8\u5e0c\u8868\u7684\u62bd\u8c61\u8868\u793a

    \u9664\u54c8\u5e0c\u8868\u5916\uff0c\u6211\u4eec\u8fd8\u53ef\u4ee5\u4f7f\u7528\u6570\u7ec4\u6216\u94fe\u8868\u5b9e\u73b0\u67e5\u8be2\u529f\u80fd\u3002\u82e5\u5c06\u5b66\u751f\u6570\u636e\u770b\u4f5c\u6570\u7ec4\uff08\u94fe\u8868\uff09\u5143\u7d20\uff0c\u5219\u6709\uff1a

    • \u6dfb\u52a0\u5143\u7d20\uff1a\u4ec5\u9700\u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u6570\u7ec4\uff08\u94fe\u8868\uff09\u7684\u5c3e\u90e8\u5373\u53ef\uff0c\u4f7f\u7528 \\(O(1)\\) \u65f6\u95f4\uff1b
    • \u67e5\u8be2\u5143\u7d20\uff1a\u7531\u4e8e\u6570\u7ec4\uff08\u94fe\u8868\uff09\u662f\u4e71\u5e8f\u7684\uff0c\u56e0\u6b64\u9700\u8981\u904d\u5386\u6570\u7ec4\uff08\u94fe\u8868\uff09\u4e2d\u7684\u6240\u6709\u5143\u7d20\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\uff1b
    • \u5220\u9664\u5143\u7d20\uff1a\u9700\u8981\u5148\u67e5\u8be2\u5230\u5143\u7d20\uff0c\u518d\u4ece\u6570\u7ec4\u4e2d\u5220\u9664\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\uff1b
    \u6570\u7ec4 \u94fe\u8868 \u54c8\u5e0c\u8868 \u67e5\u627e\u5143\u7d20 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) \u6dfb\u52a0\u5143\u7d20 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) \u5220\u9664\u5143\u7d20 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\)

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u5728\u54c8\u5e0c\u8868\u4e2d\u8fdb\u884c\u589e\u5220\u67e5\u6539\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u662f \\(O(1)\\) \uff0c\u975e\u5e38\u9ad8\u6548\u3002\u56e0\u6b64\uff0c\u54c8\u5e0c\u8868\u5e38\u7528\u4e8e\u5bf9\u67e5\u627e\u6548\u7387\u8981\u6c42\u8f83\u9ad8\u7684\u573a\u666f\u3002

    "},{"location":"chapter_hashing/hash_map/#611","title":"6.1.1. \u00a0 \u54c8\u5e0c\u8868\u5e38\u7528\u64cd\u4f5c","text":"

    \u54c8\u5e0c\u8868\u7684\u5e38\u89c1\u64cd\u4f5c\u5305\u62ec\uff1a\u521d\u59cb\u5316\u3001\u67e5\u8be2\u64cd\u4f5c\u3001\u6dfb\u52a0\u952e\u503c\u5bf9\u548c\u5220\u9664\u952e\u503c\u5bf9\u7b49\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart hash_map.java
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nMap<Integer, String> map = new HashMap<>();\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.put(12836, \"\u5c0f\u54c8\");   map.put(15937, \"\u5c0f\u5570\");   map.put(16750, \"\u5c0f\u7b97\");   map.put(13276, \"\u5c0f\u6cd5\");\nmap.put(10583, \"\u5c0f\u9e2d\");\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nString name = map.get(15937);\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.remove(10583);\n
    hash_map.cpp
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nunordered_map<int, string> map;\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap[12836] = \"\u5c0f\u54c8\";\nmap[15937] = \"\u5c0f\u5570\";\nmap[16750] = \"\u5c0f\u7b97\";\nmap[13276] = \"\u5c0f\u6cd5\";\nmap[10583] = \"\u5c0f\u9e2d\";\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nstring name = map[15937];\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.erase(10583);\n
    hash_map.py
    # \u521d\u59cb\u5316\u54c8\u5e0c\u8868\nmapp: Dict = {}\n# \u6dfb\u52a0\u64cd\u4f5c\n# \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmapp[12836] = \"\u5c0f\u54c8\"\nmapp[15937] = \"\u5c0f\u5570\"\nmapp[16750] = \"\u5c0f\u7b97\"\nmapp[13276] = \"\u5c0f\u6cd5\"\nmapp[10583] = \"\u5c0f\u9e2d\"\n# \u67e5\u8be2\u64cd\u4f5c\n# \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nname: str = mapp[15937]\n# \u5220\u9664\u64cd\u4f5c\n# \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmapp.pop(10583)\n
    hash_map.go
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nmapp := make(map[int]string)\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmapp[12836] = \"\u5c0f\u54c8\"\nmapp[15937] = \"\u5c0f\u5570\"\nmapp[16750] = \"\u5c0f\u7b97\"\nmapp[13276] = \"\u5c0f\u6cd5\"\nmapp[10583] = \"\u5c0f\u9e2d\"\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nname := mapp[15937]\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\ndelete(mapp, 10583)\n
    hash_map.js
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nconst map = new ArrayHashMap();\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.set(12836, '\u5c0f\u54c8');\nmap.set(15937, '\u5c0f\u5570');\nmap.set(16750, '\u5c0f\u7b97');\nmap.set(13276, '\u5c0f\u6cd5');\nmap.set(10583, '\u5c0f\u9e2d');\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet name = map.get(15937);\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.delete(10583);\n
    hash_map.ts
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nconst map = new Map<number, string>();\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.set(12836, '\u5c0f\u54c8');\nmap.set(15937, '\u5c0f\u5570');\nmap.set(16750, '\u5c0f\u7b97');\nmap.set(13276, '\u5c0f\u6cd5');\nmap.set(10583, '\u5c0f\u9e2d');\nconsole.info('\\n\u6dfb\u52a0\u5b8c\u6210\u540e\uff0c\u54c8\u5e0c\u8868\u4e3a\\nKey -> Value');\nconsole.info(map);\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet name = map.get(15937);\nconsole.info('\\n\u8f93\u5165\u5b66\u53f7 15937 \uff0c\u67e5\u8be2\u5230\u59d3\u540d ' + name);\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.delete(10583);\nconsole.info('\\n\u5220\u9664 10583 \u540e\uff0c\u54c8\u5e0c\u8868\u4e3a\\nKey -> Value');\nconsole.info(map);\n
    hash_map.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u54c8\u5e0c\u8868\n
    hash_map.cs
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nDictionary<int, String> map = new ();\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.Add(12836, \"\u5c0f\u54c8\");\nmap.Add(15937, \"\u5c0f\u5570\");\nmap.Add(16750, \"\u5c0f\u7b97\");\nmap.Add(13276, \"\u5c0f\u6cd5\");\nmap.Add(10583, \"\u5c0f\u9e2d\");\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nString name = map[15937];\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.Remove(10583);\n
    hash_map.swift
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nvar map: [Int: String] = [:]\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap[12836] = \"\u5c0f\u54c8\"\nmap[15937] = \"\u5c0f\u5570\"\nmap[16750] = \"\u5c0f\u7b97\"\nmap[13276] = \"\u5c0f\u6cd5\"\nmap[10583] = \"\u5c0f\u9e2d\"\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet name = map[15937]!\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.removeValue(forKey: 10583)\n
    hash_map.zig
    \n
    hash_map.dart
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nMap<int, String> map = {};\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap[12836] = \"\u5c0f\u54c8\";\nmap[15937] = \"\u5c0f\u5570\";\nmap[16750] = \"\u5c0f\u7b97\";\nmap[13276] = \"\u5c0f\u6cd5\";\nmap[10583] = \"\u5c0f\u9e2d\";\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nString name = map[15937];\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.remove(10583);\n

    \u54c8\u5e0c\u8868\u6709\u4e09\u79cd\u5e38\u7528\u904d\u5386\u65b9\u5f0f\uff1a\u904d\u5386\u952e\u503c\u5bf9\u3001\u904d\u5386\u952e\u548c\u904d\u5386\u503c\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart hash_map.java
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor (Map.Entry <Integer, String> kv: map.entrySet()) {\nSystem.out.println(kv.getKey() + \" -> \" + kv.getValue());\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor (int key: map.keySet()) {\nSystem.out.println(key);\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor (String val: map.values()) {\nSystem.out.println(val);\n}\n
    hash_map.cpp
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor (auto kv: map) {\ncout << kv.first << \" -> \" << kv.second << endl;\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor (auto key: map) {\ncout << key.first << endl;\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor (auto val: map) {\ncout << val.second << endl;\n}\n
    hash_map.py
    # \u904d\u5386\u54c8\u5e0c\u8868\n# \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor key, value in mapp.items():\nprint(key, \"->\", value)\n# \u5355\u72ec\u904d\u5386\u952e key\nfor key in mapp.keys():\nprint(key)\n# \u5355\u72ec\u904d\u5386\u503c value\nfor value in mapp.values():\nprint(value)\n
    hash_map_test.go
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor key, value := range mapp {\nfmt.Println(key, \"->\", value)\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor key := range mapp {\nfmt.Println(key)\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor _, value := range mapp {\nfmt.Println(value)\n}\n
    hash_map.js
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\nconsole.info('\\n\u904d\u5386\u952e\u503c\u5bf9 Key->Value');\nfor (const [k, v] of map.entries()) {\nconsole.info(k + ' -> ' + v);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u952e Key');\nfor (const k of map.keys()) {\nconsole.info(k);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u503c Value');\nfor (const v of map.values()) {\nconsole.info(v);\n}\n
    hash_map.ts
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\nconsole.info('\\n\u904d\u5386\u952e\u503c\u5bf9 Key->Value');\nfor (const [k, v] of map.entries()) {\nconsole.info(k + ' -> ' + v);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u952e Key');\nfor (const k of map.keys()) {\nconsole.info(k);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u503c Value');\nfor (const v of map.values()) {\nconsole.info(v);\n}\n
    hash_map.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u54c8\u5e0c\u8868\n
    hash_map.cs
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nforeach (var kv in map)\n{\nConsole.WriteLine(kv.Key + \" -> \" + kv.Value);\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nforeach (int key in map.Keys)\n{\nConsole.WriteLine(key);\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nforeach (String val in map.Values)\n{\nConsole.WriteLine(val);\n}\n
    hash_map.swift
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nfor (key, value) in map {\nprint(\"\\(key) -> \\(value)\")\n}\n// \u5355\u72ec\u904d\u5386\u952e Key\nfor key in map.keys {\nprint(key)\n}\n// \u5355\u72ec\u904d\u5386\u503c Value\nfor value in map.values {\nprint(value)\n}\n
    hash_map.zig
    \n
    hash_map.dart
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nmap.forEach((key, value) {\nprint('$key -> $value');\n});\n// \u5355\u72ec\u904d\u5386\u952e Key\nmap.keys.forEach((key) {\nprint(key);\n});\n// \u5355\u72ec\u904d\u5386\u503c Value\nmap.values.forEach((value) {\nprint(value);\n});\n
    "},{"location":"chapter_hashing/hash_map/#612","title":"6.1.2. \u00a0 \u54c8\u5e0c\u8868\u7b80\u5355\u5b9e\u73b0","text":"

    \u6211\u4eec\u5148\u8003\u8651\u6700\u7b80\u5355\u7684\u60c5\u51b5\uff0c\u4ec5\u7528\u4e00\u4e2a\u6570\u7ec4\u6765\u5b9e\u73b0\u54c8\u5e0c\u8868\u3002\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u6211\u4eec\u5c06\u6570\u7ec4\u4e2d\u7684\u6bcf\u4e2a\u7a7a\u4f4d\u79f0\u4e3a\u300c\u6876 Bucket\u300d\uff0c\u6bcf\u4e2a\u6876\u53ef\u5b58\u50a8\u4e00\u4e2a\u952e\u503c\u5bf9\u3002\u56e0\u6b64\uff0c\u67e5\u8be2\u64cd\u4f5c\u5c31\u662f\u627e\u5230 key \u5bf9\u5e94\u7684\u6876\uff0c\u5e76\u5728\u6876\u4e2d\u83b7\u53d6 value \u3002

    \u90a3\u4e48\uff0c\u5982\u4f55\u57fa\u4e8e key \u6765\u5b9a\u4f4d\u5bf9\u5e94\u7684\u6876\u5462\uff1f\u8fd9\u662f\u901a\u8fc7\u300c\u54c8\u5e0c\u51fd\u6570 Hash Function\u300d\u5b9e\u73b0\u7684\u3002\u54c8\u5e0c\u51fd\u6570\u7684\u4f5c\u7528\u662f\u5c06\u4e00\u4e2a\u8f83\u5927\u7684\u8f93\u5165\u7a7a\u95f4\u6620\u5c04\u5230\u4e00\u4e2a\u8f83\u5c0f\u7684\u8f93\u51fa\u7a7a\u95f4\u3002\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u8f93\u5165\u7a7a\u95f4\u662f\u6240\u6709 key \uff0c\u8f93\u51fa\u7a7a\u95f4\u662f\u6240\u6709\u6876\uff08\u6570\u7ec4\u7d22\u5f15\uff09\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u8f93\u5165\u4e00\u4e2a key \uff0c\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u5f97\u5230\u8be5 key \u5bf9\u5e94\u7684\u952e\u503c\u5bf9\u5728\u6570\u7ec4\u4e2d\u7684\u5b58\u50a8\u4f4d\u7f6e\u3002

    \u8f93\u5165\u4e00\u4e2a key \uff0c\u54c8\u5e0c\u51fd\u6570\u7684\u8ba1\u7b97\u8fc7\u7a0b\u5206\u4e3a\u4e24\u6b65\uff1a\u9996\u5148\uff0c\u901a\u8fc7\u54c8\u5e0c\u7b97\u6cd5 hash() \u8ba1\u7b97\u5f97\u5230\u54c8\u5e0c\u503c\uff1b\u63a5\u4e0b\u6765\uff0c\u5c06\u54c8\u5e0c\u503c\u5bf9\u6876\u6570\u91cf\uff08\u6570\u7ec4\u957f\u5ea6\uff09capacity \u53d6\u6a21\uff0c\u4ece\u800c\u83b7\u53d6\u8be5 key \u5bf9\u5e94\u7684\u6570\u7ec4\u7d22\u5f15 index \u3002

    index = hash(key) % capacity\n

    \u968f\u540e\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5229\u7528 index \u5728\u54c8\u5e0c\u8868\u4e2d\u8bbf\u95ee\u5bf9\u5e94\u7684\u6876\uff0c\u4ece\u800c\u83b7\u53d6 value \u3002

    \u8bbe\u6570\u7ec4\u957f\u5ea6 capacity = 100 \u3001\u54c8\u5e0c\u7b97\u6cd5 hash(key) = key \uff0c\u6613\u5f97\u54c8\u5e0c\u51fd\u6570\u4e3a key % 100 \u3002\u4e0b\u56fe\u4ee5 key \u5b66\u53f7\u548c value \u59d3\u540d\u4e3a\u4f8b\uff0c\u5c55\u793a\u4e86\u54c8\u5e0c\u51fd\u6570\u7684\u5de5\u4f5c\u539f\u7406\u3002

    Fig. \u54c8\u5e0c\u51fd\u6570\u5de5\u4f5c\u539f\u7406

    \u4ee5\u4e0b\u4ee3\u7801\u7ed9\u51fa\u4e86\u4e00\u4e2a\u7b80\u5355\u54c8\u5e0c\u8868\u5b9e\u73b0\u3002\u5176\u4e2d\uff0c\u6211\u4eec\u5c06 key \u548c value \u5c01\u88c5\u6210\u4e00\u4e2a\u7c7b Pair \uff0c\u4ee5\u8868\u793a\u952e\u503c\u5bf9\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array_hash_map.java
    /* \u952e\u503c\u5bf9 */\nclass Pair {\npublic int key;\npublic String val;\npublic Pair(int key, String val) {\nthis.key = key;\nthis.val = val;\n}\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nprivate List<Pair> buckets;\npublic ArrayHashMap() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nbuckets = new ArrayList<>();\nfor (int i = 0; i < 100; i++) {\nbuckets.add(null);\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate int hashFunc(int key) {\nint index = key % 100;\nreturn index;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic String get(int key) {\nint index = hashFunc(key);\nPair pair = buckets.get(index);\nif (pair == null)\nreturn null;\nreturn pair.val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic void put(int key, String val) {\nPair pair = new Pair(key, val);\nint index = hashFunc(key);\nbuckets.set(index, pair);\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic void remove(int key) {\nint index = hashFunc(key);\n// \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\nbuckets.set(index, null);\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\npublic List<Pair> pairSet() {\nList<Pair> pairSet = new ArrayList<>();\nfor (Pair pair : buckets) {\nif (pair != null)\npairSet.add(pair);\n}\nreturn pairSet;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\npublic List<Integer> keySet() {\nList<Integer> keySet = new ArrayList<>();\nfor (Pair pair : buckets) {\nif (pair != null)\nkeySet.add(pair.key);\n}\nreturn keySet;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\npublic List<String> valueSet() {\nList<String> valueSet = new ArrayList<>();\nfor (Pair pair : buckets) {\nif (pair != null)\nvalueSet.add(pair.val);\n}\nreturn valueSet;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic void print() {\nfor (Pair kv : pairSet()) {\nSystem.out.println(kv.key + \" -> \" + kv.val);\n}\n}\n}\n
    array_hash_map.cpp
    /* \u952e\u503c\u5bf9 */\nstruct Pair {\npublic:\nint key;\nstring val;\nPair(int key, string val) {\nthis->key = key;\nthis->val = val;\n}\n};\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nprivate:\nvector<Pair *> buckets;\npublic:\nArrayHashMap() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nbuckets = vector<Pair *>(100);\n}\n~ArrayHashMap() {\n// \u91ca\u653e\u5185\u5b58\nfor (const auto &bucket : buckets) {\ndelete bucket;\n}\nbuckets.clear();\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nint index = key % 100;\nreturn index;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nstring get(int key) {\nint index = hashFunc(key);\nPair *pair = buckets[index];\nif (pair == nullptr)\nreturn nullptr;\nreturn pair->val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, string val) {\nPair *pair = new Pair(key, val);\nint index = hashFunc(key);\nbuckets[index] = pair;\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\n// \u91ca\u653e\u5185\u5b58\u5e76\u7f6e\u4e3a nullptr\ndelete buckets[index];\nbuckets[index] = nullptr;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nvector<Pair *> pairSet() {\nvector<Pair *> pairSet;\nfor (Pair *pair : buckets) {\nif (pair != nullptr) {\npairSet.push_back(pair);\n}\n}\nreturn pairSet;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\nvector<int> keySet() {\nvector<int> keySet;\nfor (Pair *pair : buckets) {\nif (pair != nullptr) {\nkeySet.push_back(pair->key);\n}\n}\nreturn keySet;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\nvector<string> valueSet() {\nvector<string> valueSet;\nfor (Pair *pair : buckets) {\nif (pair != nullptr) {\nvalueSet.push_back(pair->val);\n}\n}\nreturn valueSet;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print() {\nfor (Pair *kv : pairSet()) {\ncout << kv->key << \" -> \" << kv->val << endl;\n}\n}\n};\n
    array_hash_map.py
    class Pair:\n\"\"\"\u952e\u503c\u5bf9\"\"\"\ndef __init__(self, key: int, val: str):\nself.key = key\nself.val = val\nclass ArrayHashMap:\n\"\"\"\u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n# \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nself.buckets: list[Pair | None] = [None] * 100\ndef hash_func(self, key: int) -> int:\n\"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\nindex = key % 100\nreturn index\ndef get(self, key: int) -> str:\n\"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\nindex: int = self.hash_func(key)\npair: Pair = self.buckets[index]\nif pair is None:\nreturn None\nreturn pair.val\ndef put(self, key: int, val: str):\n\"\"\"\u6dfb\u52a0\u64cd\u4f5c\"\"\"\npair = Pair(key, val)\nindex: int = self.hash_func(key)\nself.buckets[index] = pair\ndef remove(self, key: int):\n\"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\nindex: int = self.hash_func(key)\n# \u7f6e\u4e3a None \uff0c\u4ee3\u8868\u5220\u9664\nself.buckets[index] = None\ndef entry_set(self) -> list[Pair]:\n\"\"\"\u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\"\"\"\nresult: list[Pair] = []\nfor pair in self.buckets:\nif pair is not None:\nresult.append(pair)\nreturn result\ndef key_set(self) -> list[int]:\n\"\"\"\u83b7\u53d6\u6240\u6709\u952e\"\"\"\nresult = []\nfor pair in self.buckets:\nif pair is not None:\nresult.append(pair.key)\nreturn result\ndef value_set(self) -> list[str]:\n\"\"\"\u83b7\u53d6\u6240\u6709\u503c\"\"\"\nresult = []\nfor pair in self.buckets:\nif pair is not None:\nresult.append(pair.val)\nreturn result\ndef print(self):\n\"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\nfor pair in self.buckets:\nif pair is not None:\nprint(pair.key, \"->\", pair.val)\n
    array_hash_map.go
    /* \u952e\u503c\u5bf9 */\ntype pair struct {\nkey int\nval string\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\ntype arrayHashMap struct {\nbuckets []*pair\n}\n/* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nfunc newArrayHashMap() *arrayHashMap {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nbuckets := make([]*pair, 100)\nreturn &arrayHashMap{buckets: buckets}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (a *arrayHashMap) hashFunc(key int) int {\nindex := key % 100\nreturn index\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (a *arrayHashMap) get(key int) string {\nindex := a.hashFunc(key)\npair := a.buckets[index]\nif pair == nil {\nreturn \"Not Found\"\n}\nreturn pair.val\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (a *arrayHashMap) put(key int, val string) {\npair := &pair{key: key, val: val}\nindex := a.hashFunc(key)\na.buckets[index] = pair\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (a *arrayHashMap) remove(key int) {\nindex := a.hashFunc(key)\n// \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\na.buckets[index] = nil\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u5bf9 */\nfunc (a *arrayHashMap) pairSet() []*pair {\nvar pairs []*pair\nfor _, pair := range a.buckets {\nif pair != nil {\npairs = append(pairs, pair)\n}\n}\nreturn pairs\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\nfunc (a *arrayHashMap) keySet() []int {\nvar keys []int\nfor _, pair := range a.buckets {\nif pair != nil {\nkeys = append(keys, pair.key)\n}\n}\nreturn keys\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\nfunc (a *arrayHashMap) valueSet() []string {\nvar values []string\nfor _, pair := range a.buckets {\nif pair != nil {\nvalues = append(values, pair.val)\n}\n}\nreturn values\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (a *arrayHashMap) print() {\nfor _, pair := range a.buckets {\nif pair != nil {\nfmt.Println(pair.key, \"->\", pair.val)\n}\n}\n}\n
    array_hash_map.js
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\nconstructor(key, val) {\nthis.key = key;\nthis.val = val;\n}\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n#buckets;\nconstructor() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nthis.#buckets = new Array(100).fill(null);\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\n#hashFunc(key) {\nreturn key % 100;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nget(key) {\nlet index = this.#hashFunc(key);\nlet pair = this.#buckets[index];\nif (pair === null) return null;\nreturn pair.val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nset(key, val) {\nlet index = this.#hashFunc(key);\nthis.#buckets[index] = new Pair(key, val);\n}\n/* \u5220\u9664\u64cd\u4f5c */\ndelete(key) {\nlet index = this.#hashFunc(key);\n// \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\nthis.#buckets[index] = null;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nentries() {\nlet arr = [];\nfor (let i = 0; i < this.#buckets.length; i++) {\nif (this.#buckets[i]) {\narr.push(this.#buckets[i]);\n}\n}\nreturn arr;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\nkeys() {\nlet arr = [];\nfor (let i = 0; i < this.#buckets.length; i++) {\nif (this.#buckets[i]) {\narr.push(this.#buckets[i]?.key);\n}\n}\nreturn arr;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\nvalues() {\nlet arr = [];\nfor (let i = 0; i < this.#buckets.length; i++) {\nif (this.#buckets[i]) {\narr.push(this.#buckets[i]?.val);\n}\n}\nreturn arr;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nprint() {\nlet pairSet = this.entries();\nfor (const pair of pairSet) {\nif (!pair) continue;\nconsole.info(`${pair.key} -> ${pair.val}`);\n}\n}\n}\n
    array_hash_map.ts
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\npublic key: number;\npublic val: string;\nconstructor(key: number, val: string) {\nthis.key = key;\nthis.val = val;\n}\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nprivate readonly buckets: (Pair | null)[];\nconstructor() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nthis.buckets = new Array(100).fill(null);\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate hashFunc(key: number): number {\nreturn key % 100;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic get(key: number): string | null {\nlet index = this.hashFunc(key);\nlet pair = this.buckets[index];\nif (pair === null) return null;\nreturn pair.val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic set(key: number, val: string) {\nlet index = this.hashFunc(key);\nthis.buckets[index] = new Pair(key, val);\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic delete(key: number) {\nlet index = this.hashFunc(key);\n// \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\nthis.buckets[index] = null;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\npublic entries(): (Pair | null)[] {\nlet arr: (Pair | null)[] = [];\nfor (let i = 0; i < this.buckets.length; i++) {\nif (this.buckets[i]) {\narr.push(this.buckets[i]);\n}\n}\nreturn arr;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\npublic keys(): (number | undefined)[] {\nlet arr: (number | undefined)[] = [];\nfor (let i = 0; i < this.buckets.length; i++) {\nif (this.buckets[i]) {\narr.push(this.buckets[i]?.key);\n}\n}\nreturn arr;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\npublic values(): (string | undefined)[] {\nlet arr: (string | undefined)[] = [];\nfor (let i = 0; i < this.buckets.length; i++) {\nif (this.buckets[i]) {\narr.push(this.buckets[i]?.val);\n}\n}\nreturn arr;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic print() {\nlet pairSet = this.entries();\nfor (const pair of pairSet) {\nif (!pair) continue;\nconsole.info(`${pair.key} -> ${pair.val}`);\n}\n}\n}\n
    array_hash_map.c
    /* \u952e\u503c\u5bf9 int->string */\nstruct pair {\nint key;\nchar *val;\n};\ntypedef struct pair pair;\n[class]{arrayHashMap}-[func]{}\n
    array_hash_map.cs
    /* \u952e\u503c\u5bf9 int->string */\nclass Pair {\npublic int key;\npublic string val;\npublic Pair(int key, string val) {\nthis.key = key;\nthis.val = val;\n}\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nprivate List<Pair?> buckets;\npublic ArrayHashMap() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nbuckets = new();\nfor (int i = 0; i < 100; i++) {\nbuckets.Add(null);\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate int hashFunc(int key) {\nint index = key % 100;\nreturn index;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic string? get(int key) {\nint index = hashFunc(key);\nPair? pair = buckets[index];\nif (pair == null) return null;\nreturn pair.val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic void put(int key, string val) {\nPair pair = new Pair(key, val);\nint index = hashFunc(key);\nbuckets[index] = pair;\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic void remove(int key) {\nint index = hashFunc(key);\n// \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\nbuckets[index] = null;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\npublic List<Pair> pairSet() {\nList<Pair> pairSet = new();\nforeach (Pair? pair in buckets) {\nif (pair != null)\npairSet.Add(pair);\n}\nreturn pairSet;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\npublic List<int> keySet() {\nList<int> keySet = new();\nforeach (Pair? pair in buckets) {\nif (pair != null)\nkeySet.Add(pair.key);\n}\nreturn keySet;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\npublic List<string> valueSet() {\nList<string> valueSet = new();\nforeach (Pair? pair in buckets) {\nif (pair != null)\nvalueSet.Add(pair.val);\n}\nreturn valueSet;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic void print() {\nforeach (Pair kv in pairSet()) {\nConsole.WriteLine(kv.key + \" -> \" + kv.val);\n}\n}\n}\n
    array_hash_map.swift
    /* \u952e\u503c\u5bf9 */\nclass Pair {\nvar key: Int\nvar val: String\ninit(key: Int, val: String) {\nself.key = key\nself.val = val\n}\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nprivate var buckets: [Pair?] = []\ninit() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nfor _ in 0 ..< 100 {\nbuckets.append(nil)\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate func hashFunc(key: Int) -> Int {\nlet index = key % 100\nreturn index\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc get(key: Int) -> String? {\nlet index = hashFunc(key: key)\nlet pair = buckets[index]\nreturn pair?.val\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc put(key: Int, val: String) {\nlet pair = Pair(key: key, val: val)\nlet index = hashFunc(key: key)\nbuckets[index] = pair\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc remove(key: Int) {\nlet index = hashFunc(key: key)\n// \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\nbuckets[index] = nil\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nfunc pairSet() -> [Pair] {\nvar pairSet: [Pair] = []\nfor pair in buckets {\nif let pair = pair {\npairSet.append(pair)\n}\n}\nreturn pairSet\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\nfunc keySet() -> [Int] {\nvar keySet: [Int] = []\nfor pair in buckets {\nif let pair = pair {\nkeySet.append(pair.key)\n}\n}\nreturn keySet\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\nfunc valueSet() -> [String] {\nvar valueSet: [String] = []\nfor pair in buckets {\nif let pair = pair {\nvalueSet.append(pair.val)\n}\n}\nreturn valueSet\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc print() {\nfor pair in pairSet() {\nSwift.print(\"\\(pair.key) -> \\(pair.val)\")\n}\n}\n}\n
    array_hash_map.zig
    // \u952e\u503c\u5bf9\nconst Pair = struct {\nkey: usize = undefined,\nval: []const u8 = undefined,\npub fn init(key: usize, val: []const u8) Pair {\nreturn Pair {\n.key = key,\n.val = val,\n};\n}\n};\n// \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\nfn ArrayHashMap(comptime T: type) type {\nreturn struct {\nbucket: ?std.ArrayList(?T) = null,\nmem_allocator: std.mem.Allocator = undefined,\nconst Self = @This();\n// \u6784\u9020\u51fd\u6570\npub fn init(self: *Self, allocator: std.mem.Allocator) !void {\nself.mem_allocator = allocator;\n// \u521d\u59cb\u5316\u4e00\u4e2a\u957f\u5ea6\u4e3a 100 \u7684\u6876\uff08\u6570\u7ec4\uff09\nself.bucket = std.ArrayList(?T).init(self.mem_allocator);\nvar i: i32 = 0;\nwhile (i < 100) : (i += 1) {\ntry self.bucket.?.append(null);\n}\n}\n// \u6790\u6784\u51fd\u6570\npub fn deinit(self: *Self) void {\nif (self.bucket != null) self.bucket.?.deinit();\n}\n// \u54c8\u5e0c\u51fd\u6570\nfn hashFunc(key: usize) usize {\nvar index = key % 100;\nreturn index;\n}\n// \u67e5\u8be2\u64cd\u4f5c\npub fn get(self: *Self, key: usize) []const u8 {\nvar index = hashFunc(key);\nvar pair = self.bucket.?.items[index];\nreturn pair.?.val;\n}\n// \u6dfb\u52a0\u64cd\u4f5c\npub fn put(self: *Self, key: usize, val: []const u8) !void {\nvar pair = Pair.init(key, val);\nvar index = hashFunc(key);\nself.bucket.?.items[index] = pair;\n}\n// \u5220\u9664\u64cd\u4f5c\npub fn remove(self: *Self, key: usize) !void {\nvar index = hashFunc(key);\n// \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\nself.bucket.?.items[index] = null;\n}       // \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\npub fn pairSet(self: *Self) !std.ArrayList(T) {\nvar entry_set = std.ArrayList(T).init(self.mem_allocator);\nfor (self.bucket.?.items) |item| {\nif (item == null) continue;\ntry entry_set.append(item.?);\n}\nreturn entry_set;\n}  // \u83b7\u53d6\u6240\u6709\u952e\npub fn keySet(self: *Self) !std.ArrayList(usize) {\nvar key_set = std.ArrayList(usize).init(self.mem_allocator);\nfor (self.bucket.?.items) |item| {\nif (item == null) continue;\ntry key_set.append(item.?.key);\n}\nreturn key_set;\n}  // \u83b7\u53d6\u6240\u6709\u503c\npub fn valueSet(self: *Self) !std.ArrayList([]const u8) {\nvar value_set = std.ArrayList([]const u8).init(self.mem_allocator);\nfor (self.bucket.?.items) |item| {\nif (item == null) continue;\ntry value_set.append(item.?.val);\n}\nreturn value_set;\n}\n// \u6253\u5370\u54c8\u5e0c\u8868\npub fn print(self: *Self) !void {\nvar entry_set = try self.pairSet();\ndefer entry_set.deinit();\nfor (entry_set.items) |item| {\nstd.debug.print(\"{} -> {s}\\n\", .{item.key, item.val});\n}\n}\n};\n}\n
    array_hash_map.dart
    /* \u952e\u503c\u5bf9 */\nclass Pair {\nint key;\nString val;\nPair(this.key, this.val);\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nlate List<Pair?> _buckets;\nArrayHashMap() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n_buckets = List.filled(100, null);\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint _hashFunc(int key) {\nfinal int index = key % 100;\nreturn index;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nString? get(int key) {\nfinal int index = _hashFunc(key);\nfinal Pair? pair = _buckets[index];\nif (pair == null) {\nreturn null;\n}\nreturn pair.val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, String val) {\nfinal Pair pair = Pair(key, val);\nfinal int index = _hashFunc(key);\n_buckets[index] = pair;\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nfinal int index = _hashFunc(key);\n_buckets[index] = null;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nList<Pair> pairSet() {\nList<Pair> pairSet = [];\nfor (final Pair? pair in _buckets) {\nif (pair != null) {\npairSet.add(pair);\n}\n}\nreturn pairSet;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\nList<int> keySet() {\nList<int> keySet = [];\nfor (final Pair? pair in _buckets) {\nif (pair != null) {\nkeySet.add(pair.key);\n}\n}\nreturn keySet;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\nList<String> values() {\nList<String> valueSet = [];\nfor (final Pair? pair in _buckets) {\nif (pair != null) {\nvalueSet.add(pair.val);\n}\n}\nreturn valueSet;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid printHashMap() {\nfor (final Pair kv in pairSet()) {\nprint(\"${kv.key} -> ${kv.val}\");\n}\n}\n}\n
    "},{"location":"chapter_hashing/hash_map/#613","title":"6.1.3. \u00a0 \u54c8\u5e0c\u51b2\u7a81\u4e0e\u6269\u5bb9","text":"

    \u672c\u8d28\u4e0a\u770b\uff0c\u54c8\u5e0c\u51fd\u6570\u7684\u4f5c\u7528\u662f\u5c06\u8f93\u5165\u7a7a\u95f4\uff08key \u8303\u56f4\uff09\u6620\u5c04\u5230\u8f93\u51fa\u7a7a\u95f4\uff08\u6570\u7ec4\u7d22\u5f15\u8303\u56f4\uff09\uff0c\u800c\u8f93\u5165\u7a7a\u95f4\u5f80\u5f80\u8fdc\u5927\u4e8e\u8f93\u51fa\u7a7a\u95f4\u3002\u56e0\u6b64\uff0c\u7406\u8bba\u4e0a\u4e00\u5b9a\u5b58\u5728\u201c\u591a\u4e2a\u8f93\u5165\u5bf9\u5e94\u76f8\u540c\u8f93\u51fa\u201d\u7684\u60c5\u51b5\u3002

    \u5bf9\u4e8e\u4e0a\u8ff0\u793a\u4f8b\u4e2d\u7684\u54c8\u5e0c\u51fd\u6570\uff0c\u5f53\u8f93\u5165\u7684 key \u540e\u4e24\u4f4d\u76f8\u540c\u65f6\uff0c\u54c8\u5e0c\u51fd\u6570\u7684\u8f93\u51fa\u7ed3\u679c\u4e5f\u76f8\u540c\u3002\u4f8b\u5982\uff0c\u67e5\u8be2\u5b66\u53f7\u4e3a 12836 \u548c 20336 \u7684\u4e24\u4e2a\u5b66\u751f\u65f6\uff0c\u6211\u4eec\u5f97\u5230\uff1a

    12386 % 100 = 36\n20386 % 100 = 36\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u4e24\u4e2a\u5b66\u53f7\u6307\u5411\u4e86\u540c\u4e00\u4e2a\u59d3\u540d\uff0c\u8fd9\u663e\u7136\u662f\u4e0d\u5bf9\u7684\u3002\u6211\u4eec\u5c06\u8fd9\u79cd\u591a\u4e2a\u8f93\u5165\u5bf9\u5e94\u540c\u4e00\u8f93\u51fa\u7684\u60c5\u51b5\u79f0\u4e3a\u300c\u54c8\u5e0c\u51b2\u7a81 Hash Collision\u300d\u3002

    Fig. \u54c8\u5e0c\u51b2\u7a81\u793a\u4f8b

    \u5bb9\u6613\u60f3\u5230\uff0c\u54c8\u5e0c\u8868\u5bb9\u91cf \\(n\\) \u8d8a\u5927\uff0c\u591a\u4e2a key \u88ab\u5206\u914d\u5230\u540c\u4e00\u4e2a\u6876\u4e2d\u7684\u6982\u7387\u5c31\u8d8a\u4f4e\uff0c\u51b2\u7a81\u5c31\u8d8a\u5c11\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u6269\u5bb9\u54c8\u5e0c\u8868\u6765\u51cf\u5c11\u54c8\u5e0c\u51b2\u7a81\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u6269\u5bb9\u524d\u952e\u503c\u5bf9 (136, A) \u548c (236, D) \u53d1\u751f\u51b2\u7a81\uff0c\u6269\u5bb9\u540e\u51b2\u7a81\u6d88\u5931\u3002

    Fig. \u54c8\u5e0c\u8868\u6269\u5bb9

    \u7c7b\u4f3c\u4e8e\u6570\u7ec4\u6269\u5bb9\uff0c\u54c8\u5e0c\u8868\u6269\u5bb9\u9700\u5c06\u6240\u6709\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u8fc1\u79fb\u81f3\u65b0\u54c8\u5e0c\u8868\uff0c\u975e\u5e38\u8017\u65f6\u3002\u5e76\u4e14\u7531\u4e8e\u54c8\u5e0c\u8868\u5bb9\u91cf capacity \u6539\u53d8\uff0c\u6211\u4eec\u9700\u8981\u91cd\u65b0\u8ba1\u7b97\u6240\u6709\u952e\u503c\u5bf9\u7684\u5b58\u50a8\u4f4d\u7f6e\uff0c\u8fdb\u4e00\u6b65\u63d0\u9ad8\u4e86\u6269\u5bb9\u8fc7\u7a0b\u7684\u8ba1\u7b97\u5f00\u9500\u3002\u56e0\u6b64\uff0c\u7f16\u7a0b\u8bed\u8a00\u901a\u5e38\u4f1a\u9884\u7559\u8db3\u591f\u5927\u7684\u54c8\u5e0c\u8868\u5bb9\u91cf\uff0c\u9632\u6b62\u9891\u7e41\u6269\u5bb9\u3002

    \u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u300c\u8d1f\u8f7d\u56e0\u5b50 Load Factor\u300d\u662f\u4e00\u4e2a\u91cd\u8981\u6982\u5ff5\uff0c\u5176\u5b9a\u4e49\u4e3a\u54c8\u5e0c\u8868\u7684\u5143\u7d20\u6570\u91cf\u9664\u4ee5\u6876\u6570\u91cf\uff0c\u4e3a\u4e86\u8861\u91cf\u54c8\u5e0c\u51b2\u7a81\u7684\u4e25\u91cd\u7a0b\u5ea6\uff0c\u4e5f\u5e38\u88ab\u4f5c\u4e3a\u54c8\u5e0c\u8868\u6269\u5bb9\u7684\u89e6\u53d1\u6761\u4ef6\u3002\u4f8b\u5982\u5728 Java \u4e2d\uff0c\u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7 \\(0.75\\) \u65f6\uff0c\u7cfb\u7edf\u4f1a\u5c06\u54c8\u5e0c\u8868\u5bb9\u91cf\u6269\u5c55\u4e3a\u539f\u5148\u7684 \\(2\\) \u500d\u3002

    "},{"location":"chapter_hashing/summary/","title":"6.4. \u00a0 \u5c0f\u7ed3","text":"
    • \u8f93\u5165 key \uff0c\u54c8\u5e0c\u8868\u80fd\u591f\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u67e5\u8be2\u5230 value \uff0c\u6548\u7387\u975e\u5e38\u9ad8\u3002
    • \u5e38\u89c1\u7684\u54c8\u5e0c\u8868\u64cd\u4f5c\u5305\u62ec\u67e5\u8be2\u3001\u6dfb\u52a0\u952e\u503c\u5bf9\u3001\u5220\u9664\u952e\u503c\u5bf9\u548c\u904d\u5386\u54c8\u5e0c\u8868\u7b49\u3002
    • \u54c8\u5e0c\u51fd\u6570\u5c06 key \u6620\u5c04\u4e3a\u6570\u7ec4\u7d22\u5f15\uff0c\u4ece\u800c\u8bbf\u95ee\u5bf9\u5e94\u6876\u5e76\u83b7\u53d6 value \u3002
    • \u4e24\u4e2a\u4e0d\u540c\u7684 key \u53ef\u80fd\u5728\u7ecf\u8fc7\u54c8\u5e0c\u51fd\u6570\u540e\u5f97\u5230\u76f8\u540c\u7684\u6570\u7ec4\u7d22\u5f15\uff0c\u5bfc\u81f4\u67e5\u8be2\u7ed3\u679c\u51fa\u9519\uff0c\u8fd9\u79cd\u73b0\u8c61\u88ab\u79f0\u4e3a\u54c8\u5e0c\u51b2\u7a81\u3002
    • \u54c8\u5e0c\u8868\u5bb9\u91cf\u8d8a\u5927\uff0c\u54c8\u5e0c\u51b2\u7a81\u7684\u6982\u7387\u5c31\u8d8a\u4f4e\u3002\u56e0\u6b64\u53ef\u4ee5\u901a\u8fc7\u6269\u5bb9\u54c8\u5e0c\u8868\u6765\u7f13\u89e3\u54c8\u5e0c\u51b2\u7a81\u3002\u4e0e\u6570\u7ec4\u6269\u5bb9\u7c7b\u4f3c\uff0c\u54c8\u5e0c\u8868\u6269\u5bb9\u64cd\u4f5c\u7684\u5f00\u9500\u5f88\u5927\u3002
    • \u8d1f\u8f7d\u56e0\u5b50\u5b9a\u4e49\u4e3a\u54c8\u5e0c\u8868\u4e2d\u5143\u7d20\u6570\u91cf\u9664\u4ee5\u6876\u6570\u91cf\uff0c\u53cd\u6620\u4e86\u54c8\u5e0c\u51b2\u7a81\u7684\u4e25\u91cd\u7a0b\u5ea6\uff0c\u5e38\u7528\u4f5c\u89e6\u53d1\u54c8\u5e0c\u8868\u6269\u5bb9\u7684\u6761\u4ef6\u3002
    • \u94fe\u5f0f\u5730\u5740\u901a\u8fc7\u5c06\u5355\u4e2a\u5143\u7d20\u8f6c\u5316\u4e3a\u94fe\u8868\uff0c\u5c06\u6240\u6709\u51b2\u7a81\u5143\u7d20\u5b58\u50a8\u5728\u540c\u4e00\u4e2a\u94fe\u8868\u4e2d\u3002\u7136\u800c\uff0c\u94fe\u8868\u8fc7\u957f\u4f1a\u964d\u4f4e\u67e5\u8be2\u6548\u7387\uff0c\u53ef\u4ee5\u8fdb\u4e00\u6b65\u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811\u6765\u63d0\u9ad8\u6548\u7387\u3002
    • \u5f00\u653e\u5bfb\u5740\u901a\u8fc7\u591a\u6b21\u63a2\u6d4b\u6765\u5904\u7406\u54c8\u5e0c\u51b2\u7a81\u3002\u7ebf\u6027\u63a2\u6d4b\u4f7f\u7528\u56fa\u5b9a\u6b65\u957f\uff0c\u7f3a\u70b9\u662f\u4e0d\u80fd\u5220\u9664\u5143\u7d20\uff0c\u4e14\u5bb9\u6613\u4ea7\u751f\u805a\u96c6\u3002\u591a\u6b21\u54c8\u5e0c\u4f7f\u7528\u591a\u4e2a\u54c8\u5e0c\u51fd\u6570\u8fdb\u884c\u63a2\u6d4b\uff0c\u76f8\u8f83\u7ebf\u6027\u63a2\u6d4b\u66f4\u4e0d\u6613\u4ea7\u751f\u805a\u96c6\uff0c\u4f46\u591a\u4e2a\u54c8\u5e0c\u51fd\u6570\u589e\u52a0\u4e86\u8ba1\u7b97\u91cf\u3002
    • \u4e0d\u540c\u7f16\u7a0b\u8bed\u8a00\u91c7\u53d6\u4e86\u4e0d\u540c\u7684\u54c8\u5e0c\u8868\u5b9e\u73b0\u3002\u4f8b\u5982\uff0cJava \u7684 HashMap \u4f7f\u7528\u94fe\u5f0f\u5730\u5740\uff0c\u800c Python \u7684 Dict \u91c7\u7528\u5f00\u653e\u5bfb\u5740\u3002
    • \u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u6211\u4eec\u5e0c\u671b\u54c8\u5e0c\u7b97\u6cd5\u5177\u6709\u786e\u5b9a\u6027\u3001\u9ad8\u6548\u7387\u548c\u5747\u5300\u5206\u5e03\u7684\u7279\u70b9\u3002\u5728\u5bc6\u7801\u5b66\u4e2d\uff0c\u54c8\u5e0c\u7b97\u6cd5\u8fd8\u5e94\u8be5\u5177\u5907\u6297\u78b0\u649e\u6027\u548c\u96ea\u5d29\u6548\u5e94\u3002
    • \u54c8\u5e0c\u7b97\u6cd5\u901a\u5e38\u91c7\u7528\u5927\u8d28\u6570\u4f5c\u4e3a\u6a21\u6570\uff0c\u4ee5\u6700\u5927\u5316\u5730\u4fdd\u8bc1\u54c8\u5e0c\u503c\u7684\u5747\u5300\u5206\u5e03\uff0c\u51cf\u5c11\u54c8\u5e0c\u51b2\u7a81\u3002
    • \u5e38\u89c1\u7684\u54c8\u5e0c\u7b97\u6cd5\u5305\u62ec MD5, SHA-1, SHA-2, SHA3 \u7b49\u3002MD5 \u5e38\u7528\u8bed\u6821\u9a8c\u6587\u4ef6\u5b8c\u6574\u6027\uff0cSHA-2 \u5e38\u7528\u4e8e\u5b89\u5168\u5e94\u7528\u4e0e\u534f\u8bae\u3002
    • \u7f16\u7a0b\u8bed\u8a00\u901a\u5e38\u4f1a\u4e3a\u6570\u636e\u7c7b\u578b\u63d0\u4f9b\u5185\u7f6e\u54c8\u5e0c\u7b97\u6cd5\uff0c\u7528\u4e8e\u8ba1\u7b97\u54c8\u5e0c\u8868\u4e2d\u7684\u6876\u7d22\u5f15\u3002\u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\u53ea\u6709\u4e0d\u53ef\u53d8\u5bf9\u8c61\u662f\u53ef\u54c8\u5e0c\u7684\u3002
    "},{"location":"chapter_hashing/summary/#641-q-a","title":"6.4.1. \u00a0 Q & A","text":"

    \u54c8\u5e0c\u8868\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a\u4ec0\u4e48\u4e0d\u662f \\(O(n)\\) \uff1f

    \u5f53\u54c8\u5e0c\u51b2\u7a81\u6bd4\u8f83\u4e25\u91cd\u65f6\uff0c\u54c8\u5e0c\u8868\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4f1a\u9000\u5316\u81f3 \\(O(n)\\) \u3002\u5f53\u54c8\u5e0c\u51fd\u6570\u8bbe\u8ba1\u7684\u6bd4\u8f83\u597d\u3001\u5bb9\u91cf\u8bbe\u7f6e\u6bd4\u8f83\u5408\u7406\u3001\u51b2\u7a81\u6bd4\u8f83\u5e73\u5747\u65f6\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(1)\\) \u3002\u6211\u4eec\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u5185\u7f6e\u7684\u54c8\u5e0c\u8868\u65f6\uff0c\u901a\u5e38\u8ba4\u4e3a\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(1)\\) \u3002

    \u4e3a\u4ec0\u4e48\u4e0d\u4f7f\u7528\u54c8\u5e0c\u51fd\u6570 \\(f(x) = x\\) \u5462\uff1f\u8fd9\u6837\u5c31\u4e0d\u4f1a\u6709\u51b2\u7a81\u4e86

    \u5728 \\(f(x) = x\\) \u54c8\u5e0c\u51fd\u6570\u4e0b\uff0c\u6bcf\u4e2a\u5143\u7d20\u5bf9\u5e94\u552f\u4e00\u7684\u6876\u7d22\u5f15\uff0c\u8fd9\u4e0e\u6570\u7ec4\u7b49\u4ef7\u3002\u7136\u800c\uff0c\u8f93\u5165\u7a7a\u95f4\u901a\u5e38\u8fdc\u5927\u4e8e\u8f93\u51fa\u7a7a\u95f4\uff08\u6570\u7ec4\u957f\u5ea6\uff09\uff0c\u56e0\u6b64\u54c8\u5e0c\u51fd\u6570\u7684\u6700\u540e\u4e00\u6b65\u5f80\u5f80\u662f\u5bf9\u6570\u7ec4\u957f\u5ea6\u53d6\u6a21\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u54c8\u5e0c\u8868\u7684\u76ee\u6807\u662f\u5c06\u4e00\u4e2a\u8f83\u5927\u7684\u72b6\u6001\u7a7a\u95f4\u6620\u5c04\u5230\u4e00\u4e2a\u8f83\u5c0f\u7684\u7a7a\u95f4\uff0c\u5e76\u63d0\u4f9b \\(O(1)\\) \u7684\u67e5\u8be2\u6548\u7387\u3002

    \u54c8\u5e0c\u8868\u5e95\u5c42\u5b9e\u73b0\u662f\u6570\u7ec4\u3001\u94fe\u8868\u3001\u4e8c\u53c9\u6811\uff0c\u4f46\u4e3a\u4ec0\u4e48\u6548\u7387\u53ef\u4ee5\u6bd4\u4ed6\u4eec\u66f4\u9ad8\u5462\uff1f

    \u9996\u5148\uff0c\u54c8\u5e0c\u8868\u7684\u65f6\u95f4\u6548\u7387\u53d8\u9ad8\uff0c\u4f46\u7a7a\u95f4\u6548\u7387\u53d8\u4f4e\u4e86\u3002\u54c8\u5e0c\u8868\u6709\u76f8\u5f53\u4e00\u90e8\u5206\u7684\u5185\u5b58\u662f\u672a\u4f7f\u7528\u7684\uff0c

    \u5176\u6b21\uff0c\u53ea\u662f\u5728\u7279\u5b9a\u4f7f\u7528\u573a\u666f\u4e0b\u65f6\u95f4\u6548\u7387\u53d8\u9ad8\u4e86\u3002\u5982\u679c\u4e00\u4e2a\u529f\u80fd\u80fd\u591f\u5728\u76f8\u540c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e0b\u4f7f\u7528\u6570\u7ec4\u6216\u94fe\u8868\u5b9e\u73b0\uff0c\u90a3\u4e48\u901a\u5e38\u6bd4\u54c8\u5e0c\u8868\u66f4\u5feb\u3002\u8fd9\u662f\u56e0\u4e3a\u54c8\u5e0c\u51fd\u6570\u8ba1\u7b97\u9700\u8981\u5f00\u9500\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u7684\u5e38\u6570\u9879\u66f4\u5927\u3002

    \u6700\u540e\uff0c\u54c8\u5e0c\u8868\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u80fd\u53d1\u751f\u52a3\u5316\u3002\u4f8b\u5982\u5728\u94fe\u5f0f\u5730\u5740\u4e2d\uff0c\u6211\u4eec\u91c7\u53d6\u5728\u94fe\u8868\u6216\u7ea2\u9ed1\u6811\u4e2d\u6267\u884c\u67e5\u627e\u64cd\u4f5c\uff0c\u4ecd\u7136\u6709\u9000\u5316\u81f3 \\(O(n)\\) \u65f6\u95f4\u7684\u98ce\u9669\u3002

    \u591a\u6b21\u54c8\u5e0c\u6709\u4e0d\u80fd\u76f4\u63a5\u5220\u9664\u5143\u7d20\u7684\u7f3a\u9677\u5417\uff1f\u5bf9\u4e8e\u6807\u8bb0\u5df2\u5220\u9664\u7684\u7a7a\u95f4\uff0c\u8fd9\u4e2a\u7a7a\u95f4\u8fd8\u80fd\u518d\u6b21\u4f7f\u7528\u5417\uff1f

    \u591a\u6b21\u54c8\u5e0c\u662f\u5f00\u653e\u5bfb\u5740\u7684\u4e00\u79cd\uff0c\u5f00\u653e\u5bfb\u5740\u6cd5\u90fd\u6709\u4e0d\u80fd\u76f4\u63a5\u5220\u9664\u5143\u7d20\u7684\u7f3a\u9677\uff0c\u9700\u8981\u901a\u8fc7\u6807\u8bb0\u5220\u9664\u3002\u88ab\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u7a7a\u95f4\u662f\u53ef\u4ee5\u518d\u6b21\u88ab\u4f7f\u7528\u7684\u3002\u5f53\u5c06\u65b0\u5143\u7d20\u63d2\u5165\u54c8\u5e0c\u8868\uff0c\u5e76\u4e14\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u627e\u5230\u4e86\u88ab\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u4f4d\u7f6e\u65f6\uff0c\u8be5\u4f4d\u7f6e\u53ef\u4ee5\u88ab\u65b0\u7684\u5143\u7d20\u4f7f\u7528\u3002\u8fd9\u6837\u505a\u65e2\u80fd\u4fdd\u6301\u54c8\u5e0c\u8868\u7684\u63a2\u6d4b\u5e8f\u5217\u4e0d\u53d8\uff0c\u53c8\u80fd\u4fdd\u8bc1\u54c8\u5e0c\u8868\u7684\u7a7a\u95f4\u4f7f\u7528\u7387\u3002

    \u4e3a\u4ec0\u4e48\u5728\u7ebf\u6027\u63a2\u6d4b\u4e2d\uff0c\u67e5\u627e\u5143\u7d20\u7684\u65f6\u5019\u4f1a\u51fa\u73b0\u54c8\u5e0c\u51b2\u7a81\u5462\uff1f

    \u67e5\u627e\u7684\u65f6\u5019\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u627e\u5230\u5bf9\u5e94\u7684\u6876\u548c\u952e\u503c\u5bf9\uff0c\u53d1\u73b0 key \u4e0d\u5339\u914d\uff0c\u8fd9\u5c31\u4ee3\u8868\u6709\u54c8\u5e0c\u51b2\u7a81\u3002\u56e0\u6b64\uff0c\u7ebf\u6027\u63a2\u6d4b\u6cd5\u4f1a\u6839\u636e\u9884\u5148\u8bbe\u5b9a\u7684\u6b65\u957f\u4f9d\u6b21\u5411\u4e0b\u67e5\u627e\uff0c\u76f4\u81f3\u627e\u5230\u6b63\u786e\u7684\u952e\u503c\u5bf9\u6216\u65e0\u6cd5\u627e\u5230\u8df3\u51fa\u4e3a\u6b62\u3002

    \u4e3a\u4ec0\u4e48\u54c8\u5e0c\u8868\u6269\u5bb9\u80fd\u591f\u7f13\u89e3\u54c8\u5e0c\u51b2\u7a81\uff1f

    \u54c8\u5e0c\u51fd\u6570\u7684\u6700\u540e\u4e00\u6b65\u5f80\u5f80\u662f\u5bf9\u6570\u7ec4\u957f\u5ea6 \\(n\\) \u53d6\u4f59\uff0c\u8ba9\u8f93\u51fa\u503c\u843d\u5165\u5728\u6570\u7ec4\u7d22\u5f15\u8303\u56f4\uff1b\u5728\u6269\u5bb9\u540e\uff0c\u6570\u7ec4\u957f\u5ea6 \\(n\\) \u53d1\u751f\u53d8\u5316\uff0c\u800c key \u5bf9\u5e94\u7684\u7d22\u5f15\u4e5f\u53ef\u80fd\u53d1\u751f\u53d8\u5316\u3002\u539f\u5148\u843d\u5728\u540c\u4e00\u4e2a\u6876\u7684\u591a\u4e2a key \uff0c\u5728\u6269\u5bb9\u540e\u53ef\u80fd\u4f1a\u88ab\u5206\u914d\u5230\u591a\u4e2a\u6876\u4e2d\uff0c\u4ece\u800c\u5b9e\u73b0\u54c8\u5e0c\u51b2\u7a81\u7684\u7f13\u89e3\u3002

    "},{"location":"chapter_heap/","title":"8. \u00a0 \u5806","text":""},{"location":"chapter_heap/build_heap/","title":"8.2. \u00a0 \u5efa\u5806\u64cd\u4f5c","text":"

    \u5982\u679c\u6211\u4eec\u60f3\u8981\u6839\u636e\u8f93\u5165\u5217\u8868\u751f\u6210\u4e00\u4e2a\u5806\uff0c\u8fd9\u4e2a\u8fc7\u7a0b\u88ab\u79f0\u4e3a\u300c\u5efa\u5806\u300d\u3002

    "},{"location":"chapter_heap/build_heap/#821","title":"8.2.1. \u00a0 \u501f\u52a9\u5165\u5806\u65b9\u6cd5\u5b9e\u73b0","text":"

    \u6700\u76f4\u63a5\u7684\u65b9\u6cd5\u662f\u501f\u52a9\u201c\u5143\u7d20\u5165\u5806\u64cd\u4f5c\u201d\u5b9e\u73b0\uff0c\u9996\u5148\u521b\u5efa\u4e00\u4e2a\u7a7a\u5806\uff0c\u7136\u540e\u5c06\u5217\u8868\u5143\u7d20\u4f9d\u6b21\u6dfb\u52a0\u5230\u5806\u4e2d\u3002

    \u8bbe\u5143\u7d20\u6570\u91cf\u4e3a \\(n\\) \uff0c\u5219\u6700\u540e\u4e00\u4e2a\u5143\u7d20\u5165\u5806\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u3002\u5728\u4f9d\u6b21\u6dfb\u52a0\u5143\u7d20\u65f6\uff0c\u5806\u7684\u5e73\u5747\u957f\u5ea6\u4e3a \\(\\frac{n}{2}\\) \uff0c\u56e0\u6b64\u8be5\u65b9\u6cd5\u7684\u603b\u4f53\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002

    "},{"location":"chapter_heap/build_heap/#822","title":"8.2.2. \u00a0 \u57fa\u4e8e\u5806\u5316\u64cd\u4f5c\u5b9e\u73b0","text":"

    \u6709\u8da3\u7684\u662f\uff0c\u5b58\u5728\u4e00\u79cd\u66f4\u9ad8\u6548\u7684\u5efa\u5806\u65b9\u6cd5\uff0c\u5176\u65f6\u95f4\u590d\u6742\u5ea6\u4ec5\u4e3a \\(O(n)\\) \u3002\u6211\u4eec\u5148\u5c06\u5217\u8868\u6240\u6709\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u5230\u5806\u4e2d\uff0c\u7136\u540e\u8fed\u4ee3\u5730\u5bf9\u5404\u4e2a\u8282\u70b9\u6267\u884c\u201c\u4ece\u9876\u81f3\u5e95\u5806\u5316\u201d\u3002\u5f53\u7136\uff0c\u6211\u4eec\u4e0d\u9700\u8981\u5bf9\u53f6\u8282\u70b9\u6267\u884c\u5806\u5316\u64cd\u4f5c\uff0c\u56e0\u4e3a\u5b83\u4eec\u6ca1\u6709\u5b50\u8282\u70b9\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_heap.java
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nMaxHeap(List<Integer> nums) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nmaxHeap = new ArrayList<>(nums);\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = parent(size() - 1); i >= 0; i--) {\nsiftDown(i);\n}\n}\n
    my_heap.cpp
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nMaxHeap(vector<int> nums) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nmaxHeap = nums;\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = parent(size() - 1); i >= 0; i--) {\nsiftDown(i);\n}\n}\n
    my_heap.py
    def __init__(self, nums: list[int]):\n\"\"\"\u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806\"\"\"\n# \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nself.max_heap = nums\n# \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor i in range(self.parent(self.size() - 1), -1, -1):\nself.sift_down(i)\n
    my_heap.go
    /* \u6784\u9020\u51fd\u6570\uff0c\u6839\u636e\u5207\u7247\u5efa\u5806 */\nfunc newMaxHeap(nums []any) *maxHeap {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nh := &maxHeap{data: nums}\nfor i := len(h.data) - 1; i >= 0; i-- {\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nh.siftDown(i)\n}\nreturn h\n}\n
    my_heap.js
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u5efa\u7acb\u7a7a\u5806\u6216\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nconstructor(nums) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nthis.#maxHeap = nums === undefined ? [] : [...nums];\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (let i = this.#parent(this.size() - 1); i >= 0; i--) {\nthis.#siftDown(i);\n}\n}\n
    my_heap.ts
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u5efa\u7acb\u7a7a\u5806\u6216\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nconstructor(nums?: number[]) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nthis.maxHeap = nums === undefined ? [] : [...nums];\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (let i = this.parent(this.size() - 1); i >= 0; i--) {\nthis.siftDown(i);\n}\n}\n
    my_heap.c
    /* \u6784\u9020\u51fd\u6570\uff0c\u6839\u636e\u5207\u7247\u5efa\u5806 */\nmaxHeap *newMaxHeap(int nums[], int size) {\n// \u6240\u6709\u5143\u7d20\u5165\u5806\nmaxHeap *h = (maxHeap *)malloc(sizeof(maxHeap));\nh->size = size;\nmemcpy(h->data, nums, size * sizeof(int));\nfor (int i = size - 1; i >= 0; i--) {\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nsiftDown(h, i);\n}\nreturn h;\n}\n
    my_heap.cs
    /* \u6784\u9020\u51fd\u6570\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nMaxHeap(IEnumerable<int> nums) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nmaxHeap = new List<int>(nums);\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nvar size = parent(this.size() - 1);\nfor (int i = size; i >= 0; i--) {\nsiftDown(i);\n}\n}\n
    my_heap.swift
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\ninit(nums: [Int]) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nmaxHeap = nums\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor i in stride(from: parent(i: size() - 1), through: 0, by: -1) {\nsiftDown(i: i)\n}\n}\n
    my_heap.zig
    // \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806\nfn init(self: *Self, allocator: std.mem.Allocator, nums: []const T) !void {\nif (self.max_heap != null) return;\nself.max_heap = std.ArrayList(T).init(allocator);\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\ntry self.max_heap.?.appendSlice(nums);\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nvar i: usize = parent(self.size() - 1) + 1;\nwhile (i > 0) : (i -= 1) {\ntry self.siftDown(i - 1);\n}\n}\n
    my_heap.dart
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nMaxHeap(List<int> nums) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\n_maxHeap = nums;\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = _parent(size() - 1); i >= 0; i--) {\n_siftDown(i);\n}\n}\n
    "},{"location":"chapter_heap/build_heap/#823","title":"8.2.3. \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"

    \u4e3a\u4ec0\u4e48\u7b2c\u4e8c\u79cd\u5efa\u5806\u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(n)\\) \uff1f\u6211\u4eec\u6765\u5c55\u5f00\u63a8\u7b97\u4e00\u4e0b\u3002

    • \u5b8c\u5168\u4e8c\u53c9\u6811\u4e2d\uff0c\u8bbe\u8282\u70b9\u603b\u6570\u4e3a \\(n\\) \uff0c\u5219\u53f6\u8282\u70b9\u6570\u91cf\u4e3a \\((n + 1) / 2\\) \uff0c\u5176\u4e2d \\(/\\) \u4e3a\u5411\u4e0b\u6574\u9664\u3002\u56e0\u6b64\uff0c\u5728\u6392\u9664\u53f6\u8282\u70b9\u540e\uff0c\u9700\u8981\u5806\u5316\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\((n - 1)/2\\) \uff0c\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff1b
    • \u5728\u4ece\u9876\u81f3\u5e95\u5806\u5316\u7684\u8fc7\u7a0b\u4e2d\uff0c\u6bcf\u4e2a\u8282\u70b9\u6700\u591a\u5806\u5316\u5230\u53f6\u8282\u70b9\uff0c\u56e0\u6b64\u6700\u5927\u8fed\u4ee3\u6b21\u6570\u4e3a\u4e8c\u53c9\u6811\u9ad8\u5ea6 \\(O(\\log n)\\) \uff1b

    \u5c06\u4e0a\u8ff0\u4e24\u8005\u76f8\u4e58\uff0c\u53ef\u5f97\u5230\u5efa\u5806\u8fc7\u7a0b\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002\u7136\u800c\uff0c\u8fd9\u4e2a\u4f30\u7b97\u7ed3\u679c\u5e76\u4e0d\u51c6\u786e\uff0c\u56e0\u4e3a\u6211\u4eec\u6ca1\u6709\u8003\u8651\u5230\u4e8c\u53c9\u6811\u5e95\u5c42\u8282\u70b9\u6570\u91cf\u8fdc\u591a\u4e8e\u9876\u5c42\u8282\u70b9\u7684\u7279\u6027\u3002

    \u63a5\u4e0b\u6765\u6211\u4eec\u6765\u8fdb\u884c\u66f4\u4e3a\u8be6\u7ec6\u7684\u8ba1\u7b97\u3002\u4e3a\u4e86\u51cf\u5c0f\u8ba1\u7b97\u96be\u5ea6\uff0c\u6211\u4eec\u5047\u8bbe\u6811\u662f\u4e00\u4e2a\u201c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u201d\uff0c\u8be5\u5047\u8bbe\u4e0d\u4f1a\u5f71\u54cd\u8ba1\u7b97\u7ed3\u679c\u7684\u6b63\u786e\u6027\u3002\u8bbe\u4e8c\u53c9\u6811\uff08\u5373\u5806\uff09\u8282\u70b9\u6570\u91cf\u4e3a \\(n\\) \uff0c\u6811\u9ad8\u5ea6\u4e3a \\(h\\) \u3002\u4e0a\u6587\u63d0\u5230\uff0c\u8282\u70b9\u5806\u5316\u6700\u5927\u8fed\u4ee3\u6b21\u6570\u7b49\u4e8e\u8be5\u8282\u70b9\u5230\u53f6\u8282\u70b9\u7684\u8ddd\u79bb\uff0c\u800c\u8be5\u8ddd\u79bb\u6b63\u662f\u201c\u8282\u70b9\u9ad8\u5ea6\u201d\u3002

    Fig. \u5b8c\u7f8e\u4e8c\u53c9\u6811\u7684\u5404\u5c42\u8282\u70b9\u6570\u91cf

    \u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5404\u5c42\u7684\u201c\u8282\u70b9\u6570\u91cf \\(\\times\\) \u8282\u70b9\u9ad8\u5ea6\u201d\u6c42\u548c\uff0c\u4ece\u800c\u5f97\u5230\u6240\u6709\u8282\u70b9\u7684\u5806\u5316\u8fed\u4ee3\u6b21\u6570\u7684\u603b\u548c\u3002

    \\[ T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \\cdots + 2^{(h-1)}\\times1 \\]

    \u5316\u7b80\u4e0a\u5f0f\u9700\u8981\u501f\u52a9\u4e2d\u5b66\u7684\u6570\u5217\u77e5\u8bc6\uff0c\u5148\u5bf9 \\(T(h)\\) \u4e58\u4ee5 \\(2\\) \uff0c\u5f97\u5230

    \\[ \\begin{aligned} T(h) & = 2^0h + 2^1(h-1) + 2^2(h-2) + \\cdots + 2^{h-1}\\times1 \\newline 2 T(h) & = 2^1h + 2^2(h-1) + 2^3(h-2) + \\cdots + 2^{h}\\times1 \\newline \\end{aligned} \\]

    \u4f7f\u7528\u9519\u4f4d\u76f8\u51cf\u6cd5\uff0c\u4ee4\u4e0b\u5f0f \\(2 T(h)\\) \u51cf\u53bb\u4e0a\u5f0f \\(T(h)\\) \uff0c\u53ef\u5f97

    \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\cdots + 2^{h-1} + 2^h \\]

    \u89c2\u5bdf\u4e0a\u5f0f\uff0c\u53d1\u73b0 \\(T(h)\\) \u662f\u4e00\u4e2a\u7b49\u6bd4\u6570\u5217\uff0c\u53ef\u76f4\u63a5\u4f7f\u7528\u6c42\u548c\u516c\u5f0f\uff0c\u5f97\u5230\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a

    \\[ \\begin{aligned} T(h) & = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline & = 2^{h+1} - h \\newline & = O(2^h) \\end{aligned} \\]

    \u8fdb\u4e00\u6b65\u5730\uff0c\u9ad8\u5ea6\u4e3a \\(h\\) \u7684\u5b8c\u7f8e\u4e8c\u53c9\u6811\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\(n = 2^{h+1} - 1\\) \uff0c\u6613\u5f97\u590d\u6742\u5ea6\u4e3a \\(O(2^h) = O(n)\\) \u3002\u4ee5\u4e0a\u63a8\u7b97\u8868\u660e\uff0c\u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u975e\u5e38\u9ad8\u6548\u3002

    "},{"location":"chapter_heap/heap/","title":"8.1. \u00a0 \u5806","text":"

    \u300c\u5806 Heap\u300d\u662f\u4e00\u79cd\u6ee1\u8db3\u7279\u5b9a\u6761\u4ef6\u7684\u5b8c\u5168\u4e8c\u53c9\u6811\uff0c\u53ef\u5206\u4e3a\u4e24\u79cd\u7c7b\u578b\uff1a

    • \u300c\u5927\u9876\u5806 Max Heap\u300d\uff0c\u4efb\u610f\u8282\u70b9\u7684\u503c \\(\\geq\\) \u5176\u5b50\u8282\u70b9\u7684\u503c\uff1b
    • \u300c\u5c0f\u9876\u5806 Min Heap\u300d\uff0c\u4efb\u610f\u8282\u70b9\u7684\u503c \\(\\leq\\) \u5176\u5b50\u8282\u70b9\u7684\u503c\uff1b

    Fig. \u5c0f\u9876\u5806\u4e0e\u5927\u9876\u5806

    \u5806\u4f5c\u4e3a\u5b8c\u5168\u4e8c\u53c9\u6811\u7684\u4e00\u4e2a\u7279\u4f8b\uff0c\u5177\u6709\u4ee5\u4e0b\u7279\u6027\uff1a

    • \u6700\u5e95\u5c42\u8282\u70b9\u9760\u5de6\u586b\u5145\uff0c\u5176\u4ed6\u5c42\u7684\u8282\u70b9\u90fd\u88ab\u586b\u6ee1\u3002
    • \u6211\u4eec\u5c06\u4e8c\u53c9\u6811\u7684\u6839\u8282\u70b9\u79f0\u4e3a\u300c\u5806\u9876\u300d\uff0c\u5c06\u5e95\u5c42\u6700\u9760\u53f3\u7684\u8282\u70b9\u79f0\u4e3a\u300c\u5806\u5e95\u300d\u3002
    • \u5bf9\u4e8e\u5927\u9876\u5806\uff08\u5c0f\u9876\u5806\uff09\uff0c\u5806\u9876\u5143\u7d20\uff08\u5373\u6839\u8282\u70b9\uff09\u7684\u503c\u5206\u522b\u662f\u6700\u5927\uff08\u6700\u5c0f\uff09\u7684\u3002
    "},{"location":"chapter_heap/heap/#811","title":"8.1.1. \u00a0 \u5806\u5e38\u7528\u64cd\u4f5c","text":"

    \u9700\u8981\u6307\u51fa\u7684\u662f\uff0c\u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\u63d0\u4f9b\u7684\u662f\u300c\u4f18\u5148\u961f\u5217 Priority Queue\u300d\uff0c\u8fd9\u662f\u4e00\u79cd\u62bd\u8c61\u6570\u636e\u7ed3\u6784\uff0c\u5b9a\u4e49\u4e3a\u5177\u6709\u4f18\u5148\u7ea7\u6392\u5e8f\u7684\u961f\u5217\u3002

    \u5b9e\u9645\u4e0a\uff0c\u5806\u901a\u5e38\u7528\u4f5c\u5b9e\u73b0\u4f18\u5148\u961f\u5217\uff0c\u5927\u9876\u5806\u76f8\u5f53\u4e8e\u5143\u7d20\u6309\u4ece\u5927\u5230\u5c0f\u987a\u5e8f\u51fa\u961f\u7684\u4f18\u5148\u961f\u5217\u3002\u4ece\u4f7f\u7528\u89d2\u5ea6\u6765\u770b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u300c\u4f18\u5148\u961f\u5217\u300d\u548c\u300c\u5806\u300d\u770b\u4f5c\u7b49\u4ef7\u7684\u6570\u636e\u7ed3\u6784\u3002\u56e0\u6b64\uff0c\u672c\u4e66\u5bf9\u4e24\u8005\u4e0d\u505a\u7279\u522b\u533a\u5206\uff0c\u7edf\u4e00\u4f7f\u7528\u300c\u5806\u300d\u6765\u547d\u540d\u3002

    \u5806\u7684\u5e38\u7528\u64cd\u4f5c\u89c1\u4e0b\u8868\uff0c\u65b9\u6cd5\u540d\u9700\u8981\u6839\u636e\u7f16\u7a0b\u8bed\u8a00\u6765\u786e\u5b9a\u3002

    \u65b9\u6cd5\u540d \u63cf\u8ff0 \u65f6\u95f4\u590d\u6742\u5ea6 push() \u5143\u7d20\u5165\u5806 \\(O(\\log n)\\) pop() \u5806\u9876\u5143\u7d20\u51fa\u5806 \\(O(\\log n)\\) peek() \u8bbf\u95ee\u5806\u9876\u5143\u7d20\uff08\u5927 / \u5c0f\u9876\u5806\u5206\u522b\u4e3a\u6700\u5927 / \u5c0f\u503c\uff09 \\(O(1)\\) size() \u83b7\u53d6\u5806\u7684\u5143\u7d20\u6570\u91cf \\(O(1)\\) isEmpty() \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a \\(O(1)\\)

    \u5728\u5b9e\u9645\u5e94\u7528\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u63d0\u4f9b\u7684\u5806\u7c7b\uff08\u6216\u4f18\u5148\u961f\u5217\u7c7b\uff09\u3002

    Tip

    \u7c7b\u4f3c\u4e8e\u6392\u5e8f\u7b97\u6cd5\u4e2d\u7684\u201c\u4ece\u5c0f\u5230\u5927\u6392\u5217\u201d\u548c\u201c\u4ece\u5927\u5230\u5c0f\u6392\u5217\u201d\uff0c\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u4fee\u6539 Comparator \u6765\u5b9e\u73b0\u201c\u5c0f\u9876\u5806\u201d\u4e0e\u201c\u5927\u9876\u5806\u201d\u4e4b\u95f4\u7684\u8f6c\u6362\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart heap.java
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nQueue<Integer> minHeap = new PriorityQueue<>();\n// \u521d\u59cb\u5316\u5927\u9876\u5806\uff08\u4f7f\u7528 lambda \u8868\u8fbe\u5f0f\u4fee\u6539 Comparator \u5373\u53ef\uff09\nQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.peek(); // 5\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n// \u51fa\u5806\u5143\u7d20\u4f1a\u5f62\u6210\u4e00\u4e2a\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\npeek = heap.poll();  // 5\npeek = heap.poll();  // 4\npeek = heap.poll();  // 3\npeek = heap.poll();  // 2\npeek = heap.poll();  // 1\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.size();\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = maxHeap.isEmpty();\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = new PriorityQueue<>(Arrays.asList(1, 3, 2, 5, 4));\n
    heap.cpp
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\npriority_queue<int, vector<int>, greater<int>> minHeap;\n// \u521d\u59cb\u5316\u5927\u9876\u5806\npriority_queue<int, vector<int>, less<int>> maxHeap;\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.top(); // 5\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n// \u51fa\u5806\u5143\u7d20\u4f1a\u5f62\u6210\u4e00\u4e2a\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\nmaxHeap.pop(); // 5\nmaxHeap.pop(); // 4\nmaxHeap.pop(); // 3\nmaxHeap.pop(); // 2\nmaxHeap.pop(); // 1\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.size();\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = maxHeap.empty();\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nvector<int> input{1, 3, 2, 5, 4};\npriority_queue<int, vector<int>, greater<int>> minHeap(input.begin(), input.end());\n
    heap.py
    # \u521d\u59cb\u5316\u5c0f\u9876\u5806\nmin_heap, flag = [], 1\n# \u521d\u59cb\u5316\u5927\u9876\u5806\nmax_heap, flag = [], -1\n# Python \u7684 heapq \u6a21\u5757\u9ed8\u8ba4\u5b9e\u73b0\u5c0f\u9876\u5806\n# \u8003\u8651\u5c06\u201c\u5143\u7d20\u53d6\u8d1f\u201d\u540e\u518d\u5165\u5806\uff0c\u8fd9\u6837\u5c31\u53ef\u4ee5\u5c06\u5927\u5c0f\u5173\u7cfb\u98a0\u5012\uff0c\u4ece\u800c\u5b9e\u73b0\u5927\u9876\u5806\n# \u5728\u672c\u793a\u4f8b\u4e2d\uff0cflag = 1 \u65f6\u5bf9\u5e94\u5c0f\u9876\u5806\uff0cflag = -1 \u65f6\u5bf9\u5e94\u5927\u9876\u5806\n# \u5143\u7d20\u5165\u5806\nheapq.heappush(max_heap, flag * 1)\nheapq.heappush(max_heap, flag * 3)\nheapq.heappush(max_heap, flag * 2)\nheapq.heappush(max_heap, flag * 5)\nheapq.heappush(max_heap, flag * 4)\n# \u83b7\u53d6\u5806\u9876\u5143\u7d20\npeek: int = flag * max_heap[0] # 5\n# \u5806\u9876\u5143\u7d20\u51fa\u5806\n# \u51fa\u5806\u5143\u7d20\u4f1a\u5f62\u6210\u4e00\u4e2a\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\nval = flag * heapq.heappop(max_heap) # 5\nval = flag * heapq.heappop(max_heap) # 4\nval = flag * heapq.heappop(max_heap) # 3\nval = flag * heapq.heappop(max_heap) # 2\nval = flag * heapq.heappop(max_heap) # 1\n# \u83b7\u53d6\u5806\u5927\u5c0f\nsize: int = len(max_heap)\n# \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = not max_heap\n# \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806\nmin_heap: List[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\n
    heap.go
    // Go \u8bed\u8a00\u4e2d\u53ef\u4ee5\u901a\u8fc7\u5b9e\u73b0 heap.Interface \u6765\u6784\u5efa\u6574\u6570\u5927\u9876\u5806\n// \u5b9e\u73b0 heap.Interface \u9700\u8981\u540c\u65f6\u5b9e\u73b0 sort.Interface\ntype intHeap []any\n// Push heap.Interface \u7684\u65b9\u6cd5\uff0c\u5b9e\u73b0\u63a8\u5165\u5143\u7d20\u5230\u5806\nfunc (h *intHeap) Push(x any) {\n// Push \u548c Pop \u4f7f\u7528 pointer receiver \u4f5c\u4e3a\u53c2\u6570\n// \u56e0\u4e3a\u5b83\u4eec\u4e0d\u4ec5\u4f1a\u5bf9\u5207\u7247\u7684\u5185\u5bb9\u8fdb\u884c\u8c03\u6574\uff0c\u8fd8\u4f1a\u4fee\u6539\u5207\u7247\u7684\u957f\u5ea6\u3002\n*h = append(*h, x.(int))\n}\n// Pop heap.Interface \u7684\u65b9\u6cd5\uff0c\u5b9e\u73b0\u5f39\u51fa\u5806\u9876\u5143\u7d20\nfunc (h *intHeap) Pop() any {\n// \u5f85\u51fa\u5806\u5143\u7d20\u5b58\u653e\u5728\u6700\u540e\nlast := (*h)[len(*h)-1]\n*h = (*h)[:len(*h)-1]\nreturn last\n}\n// Len sort.Interface \u7684\u65b9\u6cd5\nfunc (h *intHeap) Len() int {\nreturn len(*h)\n}\n// Less sort.Interface \u7684\u65b9\u6cd5\nfunc (h *intHeap) Less(i, j int) bool {\n// \u5982\u679c\u5b9e\u73b0\u5c0f\u9876\u5806\uff0c\u5219\u9700\u8981\u8c03\u6574\u4e3a\u5c0f\u4e8e\u53f7\nreturn (*h)[i].(int) > (*h)[j].(int)\n}\n// Swap sort.Interface \u7684\u65b9\u6cd5\nfunc (h *intHeap) Swap(i, j int) {\n(*h)[i], (*h)[j] = (*h)[j], (*h)[i]\n}\n// Top \u83b7\u53d6\u5806\u9876\u5143\u7d20\nfunc (h *intHeap) Top() any {\nreturn (*h)[0]\n}\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n/* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5927\u9876\u5806\nmaxHeap := &intHeap{}\nheap.Init(maxHeap)\n/* \u5143\u7d20\u5165\u5806 */\n// \u8c03\u7528 heap.Interface \u7684\u65b9\u6cd5\uff0c\u6765\u6dfb\u52a0\u5143\u7d20\nheap.Push(maxHeap, 1)\nheap.Push(maxHeap, 3)\nheap.Push(maxHeap, 2)\nheap.Push(maxHeap, 4)\nheap.Push(maxHeap, 5)\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\ntop := maxHeap.Top()\nfmt.Printf(\"\u5806\u9876\u5143\u7d20\u4e3a %d\\n\", top)\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n// \u8c03\u7528 heap.Interface \u7684\u65b9\u6cd5\uff0c\u6765\u79fb\u9664\u5143\u7d20\nheap.Pop(maxHeap) // 5\nheap.Pop(maxHeap) // 4\nheap.Pop(maxHeap) // 3\nheap.Pop(maxHeap) // 2\nheap.Pop(maxHeap) // 1\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nsize := len(*maxHeap)\nfmt.Printf(\"\u5806\u5143\u7d20\u6570\u91cf\u4e3a %d\\n\", size)\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nisEmpty := len(*maxHeap) == 0\nfmt.Printf(\"\u5806\u662f\u5426\u4e3a\u7a7a %t\\n\", isEmpty)\n}\n
    heap.js
    // JavaScript \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.ts
    // TypeScript \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.cs
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nPriorityQueue<int, int> minHeap = new PriorityQueue<int, int>();\n// \u521d\u59cb\u5316\u5927\u9876\u5806\uff08\u4f7f\u7528 lambda \u8868\u8fbe\u5f0f\u4fee\u6539 Comparator \u5373\u53ef\uff09\nPriorityQueue<int, int> maxHeap = new PriorityQueue<int, int>(Comparer<int>.Create((x, y) => y - x));\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.Enqueue(1, 1);\nmaxHeap.Enqueue(3, 3);\nmaxHeap.Enqueue(2, 2);\nmaxHeap.Enqueue(5, 5);\nmaxHeap.Enqueue(4, 4);\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.Peek();//5\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n// \u51fa\u5806\u5143\u7d20\u4f1a\u5f62\u6210\u4e00\u4e2a\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\npeek = maxHeap.Dequeue();  // 5\npeek = maxHeap.Dequeue();  // 4\npeek = maxHeap.Dequeue();  // 3\npeek = maxHeap.Dequeue();  // 2\npeek = maxHeap.Dequeue();  // 1\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.Count;\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = maxHeap.Count == 0;\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = new PriorityQueue<int, int>(new List<(int, int)> { (1, 1), (3, 3), (2, 2), (5, 5), (4, 4), });\n
    heap.swift
    // Swift \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.zig
    \n
    heap.dart
    // Dart \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    "},{"location":"chapter_heap/heap/#812","title":"8.1.2. \u00a0 \u5806\u7684\u5b9e\u73b0","text":"

    \u4e0b\u6587\u5b9e\u73b0\u7684\u662f\u5927\u9876\u5806\u3002\u82e5\u8981\u5c06\u5176\u8f6c\u6362\u4e3a\u5c0f\u9876\u5806\uff0c\u53ea\u9700\u5c06\u6240\u6709\u5927\u5c0f\u903b\u8f91\u5224\u65ad\u53d6\u9006\uff08\u4f8b\u5982\uff0c\u5c06 \\(\\geq\\) \u66ff\u6362\u4e3a \\(\\leq\\) \uff09\u3002\u611f\u5174\u8da3\u7684\u8bfb\u8005\u53ef\u4ee5\u81ea\u884c\u5b9e\u73b0\u3002

    "},{"location":"chapter_heap/heap/#_1","title":"\u5806\u7684\u5b58\u50a8\u4e0e\u8868\u793a","text":"

    \u6211\u4eec\u5728\u4e8c\u53c9\u6811\u7ae0\u8282\u4e2d\u5b66\u4e60\u5230\uff0c\u5b8c\u5168\u4e8c\u53c9\u6811\u975e\u5e38\u9002\u5408\u7528\u6570\u7ec4\u6765\u8868\u793a\u3002\u7531\u4e8e\u5806\u6b63\u662f\u4e00\u79cd\u5b8c\u5168\u4e8c\u53c9\u6811\uff0c\u6211\u4eec\u5c06\u91c7\u7528\u6570\u7ec4\u6765\u5b58\u50a8\u5806\u3002

    \u5f53\u4f7f\u7528\u6570\u7ec4\u8868\u793a\u4e8c\u53c9\u6811\u65f6\uff0c\u5143\u7d20\u4ee3\u8868\u8282\u70b9\u503c\uff0c\u7d22\u5f15\u4ee3\u8868\u8282\u70b9\u5728\u4e8c\u53c9\u6811\u4e2d\u7684\u4f4d\u7f6e\u3002\u8282\u70b9\u6307\u9488\u901a\u8fc7\u7d22\u5f15\u6620\u5c04\u516c\u5f0f\u6765\u5b9e\u73b0\u3002

    \u5177\u4f53\u800c\u8a00\uff0c\u7ed9\u5b9a\u7d22\u5f15 \\(i\\) \uff0c\u5176\u5de6\u5b50\u8282\u70b9\u7d22\u5f15\u4e3a \\(2i + 1\\) \uff0c\u53f3\u5b50\u8282\u70b9\u7d22\u5f15\u4e3a \\(2i + 2\\) \uff0c\u7236\u8282\u70b9\u7d22\u5f15\u4e3a \\((i - 1) / 2\\)\uff08\u5411\u4e0b\u53d6\u6574\uff09\u3002\u5f53\u7d22\u5f15\u8d8a\u754c\u65f6\uff0c\u8868\u793a\u7a7a\u8282\u70b9\u6216\u8282\u70b9\u4e0d\u5b58\u5728\u3002

    Fig. \u5806\u7684\u8868\u793a\u4e0e\u5b58\u50a8

    \u6211\u4eec\u53ef\u4ee5\u5c06\u7d22\u5f15\u6620\u5c04\u516c\u5f0f\u5c01\u88c5\u6210\u51fd\u6570\uff0c\u65b9\u4fbf\u540e\u7eed\u4f7f\u7528\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_heap.java
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nint left(int i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nint right(int i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nint parent(int i) {\nreturn (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.cpp
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nint left(int i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nint right(int i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nint parent(int i) {\nreturn (i - 1) / 2; // \u5411\u4e0b\u53d6\u6574\n}\n
    my_heap.py
    def left(self, i: int) -> int:\n\"\"\"\u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15\"\"\"\nreturn 2 * i + 1\ndef right(self, i: int) -> int:\n\"\"\"\u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15\"\"\"\nreturn 2 * i + 2\ndef parent(self, i: int) -> int:\n\"\"\"\u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15\"\"\"\nreturn (i - 1) // 2  # \u5411\u4e0b\u6574\u9664\n
    my_heap.go
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nfunc (h *maxHeap) left(i int) int {\nreturn 2*i + 1\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nfunc (h *maxHeap) right(i int) int {\nreturn 2*i + 2\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nfunc (h *maxHeap) parent(i int) int {\n// \u5411\u4e0b\u6574\u9664\nreturn (i - 1) / 2\n}\n
    my_heap.js
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\n#left(i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\n#right(i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\n#parent(i) {\nreturn Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.ts
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nleft(i: number): number {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nright(i: number): number {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nparent(i: number): number {\nreturn Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.c
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nint left(maxHeap *h, int i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nint right(maxHeap *h, int i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nint parent(maxHeap *h, int i) {\nreturn (i - 1) / 2;\n}\n
    my_heap.cs
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nint left(int i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nint right(int i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nint parent(int i) {\nreturn (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.swift
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nfunc left(i: Int) -> Int {\n2 * i + 1\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nfunc right(i: Int) -> Int {\n2 * i + 2\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nfunc parent(i: Int) -> Int {\n(i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.zig
    // \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15\nfn left(i: usize) usize {\nreturn 2 * i + 1;\n}\n// \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15\nfn right(i: usize) usize {\nreturn 2 * i + 2;\n}\n// \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15\nfn parent(i: usize) usize {\n// return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\nreturn @divFloor(i - 1, 2);\n}\n
    my_heap.dart
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nint _left(int i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nint _right(int i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nint _parent(int i) {\nreturn (i - 1) ~/ 2; // \u5411\u4e0b\u6574\u9664\n}\n
    "},{"location":"chapter_heap/heap/#_2","title":"\u8bbf\u95ee\u5806\u9876\u5143\u7d20","text":"

    \u5806\u9876\u5143\u7d20\u5373\u4e3a\u4e8c\u53c9\u6811\u7684\u6839\u8282\u70b9\uff0c\u4e5f\u5c31\u662f\u5217\u8868\u7684\u9996\u4e2a\u5143\u7d20\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_heap.java
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\nreturn maxHeap.get(0);\n}\n
    my_heap.cpp
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\nreturn maxHeap[0];\n}\n
    my_heap.py
    def peek(self) -> int:\n\"\"\"\u8bbf\u95ee\u5806\u9876\u5143\u7d20\"\"\"\nreturn self.max_heap[0]\n
    my_heap.go
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunc (h *maxHeap) peek() any {\nreturn h.data[0]\n}\n
    my_heap.js
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\npeek() {\nreturn this.#maxHeap[0];\n}\n
    my_heap.ts
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\npeek(): number {\nreturn this.maxHeap[0];\n}\n
    my_heap.c
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek(maxHeap *h) {\nreturn h->data[0];\n}\n
    my_heap.cs
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\nreturn maxHeap[0];\n}\n
    my_heap.swift
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunc peek() -> Int {\nmaxHeap[0]\n}\n
    my_heap.zig
    // \u8bbf\u95ee\u5806\u9876\u5143\u7d20\nfn peek(self: *Self) T {\nreturn self.max_heap.?.items[0];\n}
    my_heap.dart
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\nreturn _maxHeap[0];\n}\n
    "},{"location":"chapter_heap/heap/#_3","title":"\u5143\u7d20\u5165\u5806","text":"

    \u7ed9\u5b9a\u5143\u7d20 val \uff0c\u6211\u4eec\u9996\u5148\u5c06\u5176\u6dfb\u52a0\u5230\u5806\u5e95\u3002\u6dfb\u52a0\u4e4b\u540e\uff0c\u7531\u4e8e val \u53ef\u80fd\u5927\u4e8e\u5806\u4e2d\u5176\u4ed6\u5143\u7d20\uff0c\u5806\u7684\u6210\u7acb\u6761\u4ef6\u53ef\u80fd\u5df2\u88ab\u7834\u574f\u3002\u56e0\u6b64\uff0c\u9700\u8981\u4fee\u590d\u4ece\u63d2\u5165\u8282\u70b9\u5230\u6839\u8282\u70b9\u7684\u8def\u5f84\u4e0a\u7684\u5404\u4e2a\u8282\u70b9\uff0c\u8fd9\u4e2a\u64cd\u4f5c\u88ab\u79f0\u4e3a\u300c\u5806\u5316 Heapify\u300d\u3002

    \u8003\u8651\u4ece\u5165\u5806\u8282\u70b9\u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u6267\u884c\u5806\u5316\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u6211\u4eec\u6bd4\u8f83\u63d2\u5165\u8282\u70b9\u4e0e\u5176\u7236\u8282\u70b9\u7684\u503c\uff0c\u5982\u679c\u63d2\u5165\u8282\u70b9\u66f4\u5927\uff0c\u5219\u5c06\u5b83\u4eec\u4ea4\u6362\u3002\u7136\u540e\u7ee7\u7eed\u6267\u884c\u6b64\u64cd\u4f5c\uff0c\u4ece\u5e95\u81f3\u9876\u4fee\u590d\u5806\u4e2d\u7684\u5404\u4e2a\u8282\u70b9\uff0c\u76f4\u81f3\u8d8a\u8fc7\u6839\u8282\u70b9\u6216\u9047\u5230\u65e0\u9700\u4ea4\u6362\u7684\u8282\u70b9\u65f6\u7ed3\u675f\u3002

    <1><2><3><4><5><6><7><8><9>

    \u8bbe\u8282\u70b9\u603b\u6570\u4e3a \\(n\\) \uff0c\u5219\u6811\u7684\u9ad8\u5ea6\u4e3a \\(O(\\log n)\\) \u3002\u7531\u6b64\u53ef\u77e5\uff0c\u5806\u5316\u64cd\u4f5c\u7684\u5faa\u73af\u8f6e\u6570\u6700\u591a\u4e3a \\(O(\\log n)\\) \uff0c\u5143\u7d20\u5165\u5806\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_heap.java
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(int val) {\n// \u6dfb\u52a0\u8282\u70b9\nmaxHeap.add(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nsiftUp(size() - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nint p = parent(i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 || maxHeap.get(i) <= maxHeap.get(p))\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.cpp
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(int val) {\n// \u6dfb\u52a0\u8282\u70b9\nmaxHeap.push_back(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nsiftUp(size() - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nint p = parent(i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 || maxHeap[i] <= maxHeap[p])\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(maxHeap[i], maxHeap[p]);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.py
    def push(self, val: int):\n\"\"\"\u5143\u7d20\u5165\u5806\"\"\"\n# \u6dfb\u52a0\u8282\u70b9\nself.max_heap.append(val)\n# \u4ece\u5e95\u81f3\u9876\u5806\u5316\nself.sift_up(self.size() - 1)\ndef sift_up(self, i: int):\n\"\"\"\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316\"\"\"\nwhile True:\n# \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\np = self.parent(i)\n# \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif p < 0 or self.max_heap[i] <= self.max_heap[p]:\nbreak\n# \u4ea4\u6362\u4e24\u8282\u70b9\nself.swap(i, p)\n# \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p\n
    my_heap.go
    /* \u5143\u7d20\u5165\u5806 */\nfunc (h *maxHeap) push(val any) {\n// \u6dfb\u52a0\u8282\u70b9\nh.data = append(h.data, val)\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nh.siftUp(len(h.data) - 1)\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfunc (h *maxHeap) siftUp(i int) {\nfor true {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\np := h.parent(i)\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif p < 0 || h.data[i].(int) <= h.data[p].(int) {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nh.swap(i, p)\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p\n}\n}\n
    my_heap.js
    /* \u5143\u7d20\u5165\u5806 */\npush(val) {\n// \u6dfb\u52a0\u8282\u70b9\nthis.#maxHeap.push(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nthis.#siftUp(this.size() - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\n#siftUp(i) {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nconst p = this.#parent(i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nthis.#swap(i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.ts
    /* \u5143\u7d20\u5165\u5806 */\npush(val: number): void {\n// \u6dfb\u52a0\u8282\u70b9\nthis.maxHeap.push(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nthis.siftUp(this.size() - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nsiftUp(i: number): void {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nconst p = this.parent(i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nthis.swap(i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.c
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(maxHeap *h, int val) {\n// \u9ed8\u8ba4\u60c5\u51b5\u4e0b\uff0c\u4e0d\u5e94\u8be5\u6dfb\u52a0\u8fd9\u4e48\u591a\u8282\u70b9\nif (h->size == MAX_SIZE) {\nprintf(\"heap is full!\");\nreturn;\n}\n// \u6dfb\u52a0\u8282\u70b9\nh->data[h->size] = val;\nh->size++;\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nsiftUp(h, h->size - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(maxHeap *h, int i) {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nint p = parent(h, i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 || h->data[i] <= h->data[p]) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(h, i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.cs
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(int val) {\n// \u6dfb\u52a0\u8282\u70b9\nmaxHeap.Add(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nsiftUp(size() - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nint p = parent(i);\n// \u82e5\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\uff0c\u5219\u7ed3\u675f\u5806\u5316\nif (p < 0 || maxHeap[i] <= maxHeap[p])\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.swift
    /* \u5143\u7d20\u5165\u5806 */\nfunc push(val: Int) {\n// \u6dfb\u52a0\u8282\u70b9\nmaxHeap.append(val)\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nsiftUp(i: size() - 1)\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfunc siftUp(i: Int) {\nvar i = i\nwhile true {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nlet p = parent(i: i)\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif p < 0 || maxHeap[i] <= maxHeap[p] {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i: i, j: p)\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p\n}\n}\n
    my_heap.zig
    // \u5143\u7d20\u5165\u5806\nfn push(self: *Self, val: T) !void {\n// \u6dfb\u52a0\u8282\u70b9\ntry self.max_heap.?.append(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\ntry self.siftUp(self.size() - 1);\n}  // \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316\nfn siftUp(self: *Self, i_: usize) !void {\nvar i = i_;\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nvar p = parent(i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\ntry self.swap(i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.dart
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(int val) {\n// \u6dfb\u52a0\u8282\u70b9\n_maxHeap.add(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\n_siftUp(size() - 1);\n}\n[class]{MaxHeap}-[func]{siftUp}\n
    "},{"location":"chapter_heap/heap/#_4","title":"\u5806\u9876\u5143\u7d20\u51fa\u5806","text":"

    \u5806\u9876\u5143\u7d20\u662f\u4e8c\u53c9\u6811\u7684\u6839\u8282\u70b9\uff0c\u5373\u5217\u8868\u9996\u5143\u7d20\u3002\u5982\u679c\u6211\u4eec\u76f4\u63a5\u4ece\u5217\u8868\u4e2d\u5220\u9664\u9996\u5143\u7d20\uff0c\u90a3\u4e48\u4e8c\u53c9\u6811\u4e2d\u6240\u6709\u8282\u70b9\u7684\u7d22\u5f15\u90fd\u4f1a\u53d1\u751f\u53d8\u5316\uff0c\u8fd9\u5c06\u4f7f\u5f97\u540e\u7eed\u4f7f\u7528\u5806\u5316\u4fee\u590d\u53d8\u5f97\u56f0\u96be\u3002\u4e3a\u4e86\u5c3d\u91cf\u51cf\u5c11\u5143\u7d20\u7d22\u5f15\u7684\u53d8\u52a8\uff0c\u6211\u4eec\u91c7\u53d6\u4ee5\u4e0b\u64cd\u4f5c\u6b65\u9aa4\uff1a

    1. \u4ea4\u6362\u5806\u9876\u5143\u7d20\u4e0e\u5806\u5e95\u5143\u7d20\uff08\u5373\u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff09\uff1b
    2. \u4ea4\u6362\u5b8c\u6210\u540e\uff0c\u5c06\u5806\u5e95\u4ece\u5217\u8868\u4e2d\u5220\u9664\uff08\u6ce8\u610f\uff0c\u7531\u4e8e\u5df2\u7ecf\u4ea4\u6362\uff0c\u5b9e\u9645\u4e0a\u5220\u9664\u7684\u662f\u539f\u6765\u7684\u5806\u9876\u5143\u7d20\uff09\uff1b
    3. \u4ece\u6839\u8282\u70b9\u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u6267\u884c\u5806\u5316\uff1b

    \u987e\u540d\u601d\u4e49\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\u7684\u64cd\u4f5c\u65b9\u5411\u4e0e\u4ece\u5e95\u81f3\u9876\u5806\u5316\u76f8\u53cd\uff0c\u6211\u4eec\u5c06\u6839\u8282\u70b9\u7684\u503c\u4e0e\u5176\u4e24\u4e2a\u5b50\u8282\u70b9\u7684\u503c\u8fdb\u884c\u6bd4\u8f83\uff0c\u5c06\u6700\u5927\u7684\u5b50\u8282\u70b9\u4e0e\u6839\u8282\u70b9\u4ea4\u6362\uff1b\u7136\u540e\u5faa\u73af\u6267\u884c\u6b64\u64cd\u4f5c\uff0c\u76f4\u5230\u8d8a\u8fc7\u53f6\u8282\u70b9\u6216\u9047\u5230\u65e0\u9700\u4ea4\u6362\u7684\u8282\u70b9\u65f6\u7ed3\u675f\u3002

    <1><2><3><4><5><6><7><8><9><10>

    \u4e0e\u5143\u7d20\u5165\u5806\u64cd\u4f5c\u76f8\u4f3c\uff0c\u5806\u9876\u5143\u7d20\u51fa\u5806\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e5f\u4e3a \\(O(\\log n)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_heap.java
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n// \u5224\u7a7a\u5904\u7406\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(0, size() - 1);\n// \u5220\u9664\u8282\u70b9\nint val = maxHeap.remove(size() - 1);\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nsiftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = left(i), r = right(i), ma = i;\nif (l < size() && maxHeap.get(l) > maxHeap.get(ma))\nma = l;\nif (r < size() && maxHeap.get(r) > maxHeap.get(ma))\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i)\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i, ma);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.cpp
    /* \u5143\u7d20\u51fa\u5806 */\nvoid pop() {\n// \u5224\u7a7a\u5904\u7406\nif (empty()) {\nthrow out_of_range(\"\u5806\u4e3a\u7a7a\");\n}\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(maxHeap[0], maxHeap[size() - 1]);\n// \u5220\u9664\u8282\u70b9\nmaxHeap.pop_back();\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nsiftDown(0);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = left(i), r = right(i), ma = i;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (l < size() && maxHeap[l] > maxHeap[ma])\nma = l;\nif (r < size() && maxHeap[r] > maxHeap[ma])\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i)\nbreak;\nswap(maxHeap[i], maxHeap[ma]);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.py
    def pop(self) -> int:\n\"\"\"\u5143\u7d20\u51fa\u5806\"\"\"\n# \u5224\u7a7a\u5904\u7406\nif self.is_empty():\nraise IndexError(\"\u5806\u4e3a\u7a7a\")\n# \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nself.swap(0, self.size() - 1)\n# \u5220\u9664\u8282\u70b9\nval = self.max_heap.pop()\n# \u4ece\u9876\u81f3\u5e95\u5806\u5316\nself.sift_down(0)\n# \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val\ndef sift_down(self, i: int):\n\"\"\"\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\"\"\"\nwhile True:\n# \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nl, r, ma = self.left(i), self.right(i), i\nif l < self.size() and self.max_heap[l] > self.max_heap[ma]:\nma = l\nif r < self.size() and self.max_heap[r] > self.max_heap[ma]:\nma = r\n# \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif ma == i:\nbreak\n# \u4ea4\u6362\u4e24\u8282\u70b9\nself.swap(i, ma)\n# \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma\n
    my_heap.go
    /* \u5143\u7d20\u51fa\u5806 */\nfunc (h *maxHeap) pop() any {\n// \u5224\u7a7a\u5904\u7406\nif h.isEmpty() {\nfmt.Println(\"error\")\nreturn nil\n}\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nh.swap(0, h.size()-1)\n// \u5220\u9664\u8282\u70b9\nval := h.data[len(h.data)-1]\nh.data = h.data[:len(h.data)-1]\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nh.siftDown(0)\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc (h *maxHeap) siftDown(i int) {\nfor true {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a max\nl, r, max := h.left(i), h.right(i), i\nif l < h.size() && h.data[l].(int) > h.data[max].(int) {\nmax = l\n}\nif r < h.size() && h.data[r].(int) > h.data[max].(int) {\nmax = r\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif max == i {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nh.swap(i, max)\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = max\n}\n}\n
    my_heap.js
    /* \u5143\u7d20\u51fa\u5806 */\npop() {\n// \u5224\u7a7a\u5904\u7406\nif (this.isEmpty()) throw new Error('\u5806\u4e3a\u7a7a');\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nthis.#swap(0, this.size() - 1);\n// \u5220\u9664\u8282\u70b9\nconst val = this.#maxHeap.pop();\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nthis.#siftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\n#siftDown(i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nconst l = this.#left(i),\nr = this.#right(i);\nlet ma = i;\nif (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;\nif (r < this.size() && this.#maxHeap[r] > this.#maxHeap[ma]) ma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nthis.#swap(i, ma);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.ts
    /* \u5143\u7d20\u51fa\u5806 */\npop(): number {\n// \u5224\u7a7a\u5904\u7406\nif (this.isEmpty()) throw new RangeError('Heap is empty.');\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nthis.swap(0, this.size() - 1);\n// \u5220\u9664\u8282\u70b9\nconst val = this.maxHeap.pop();\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nthis.siftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nsiftDown(i: number): void {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nconst l = this.left(i),\nr = this.right(i);\nlet ma = i;\nif (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l;\nif (r < this.size() && this.maxHeap[r] > this.maxHeap[ma]) ma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nthis.swap(i, ma);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.c
    /* \u5143\u7d20\u51fa\u5806 */\nint pop(maxHeap *h) {\n// \u5224\u7a7a\u5904\u7406\nif (isEmpty(h)) {\nprintf(\"heap is empty!\");\nreturn INT_MAX;\n}\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(h, 0, size(h) - 1);\n// \u5220\u9664\u8282\u70b9\nint val = h->data[h->size - 1];\nh->size--;\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nsiftDown(h, 0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(maxHeap *h, int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a max\nint l = left(h, i);\nint r = right(h, i);\nint max = i;\nif (l < size(h) && h->data[l] > h->data[max]) {\nmax = l;\n}\nif (r < size(h) && h->data[r] > h->data[max]) {\nmax = r;\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (max == i) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(h, i, max);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = max;\n}\n}\n
    my_heap.cs
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n// \u5224\u7a7a\u5904\u7406\nif (isEmpty())\nthrow new IndexOutOfRangeException();\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(0, size() - 1);\n// \u5220\u9664\u8282\u70b9\nint val = maxHeap.Last();\nmaxHeap.RemoveAt(size() - 1);\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nsiftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = left(i), r = right(i), ma = i;\nif (l < size() && maxHeap[l] > maxHeap[ma])\nma = l;\nif (r < size() && maxHeap[r] > maxHeap[ma])\nma = r;\n// \u82e5\u201c\u8282\u70b9 i \u6700\u5927\u201d\u6216\u201c\u8d8a\u8fc7\u53f6\u8282\u70b9\u201d\uff0c\u5219\u7ed3\u675f\u5806\u5316\nif (ma == i) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i, ma);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.swift
    /* \u5143\u7d20\u51fa\u5806 */\nfunc pop() -> Int {\n// \u5224\u7a7a\u5904\u7406\nif isEmpty() {\nfatalError(\"\u5806\u4e3a\u7a7a\")\n}\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(i: 0, j: size() - 1)\n// \u5220\u9664\u8282\u70b9\nlet val = maxHeap.remove(at: size() - 1)\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nsiftDown(i: 0)\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc siftDown(i: Int) {\nvar i = i\nwhile true {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nlet l = left(i: i)\nlet r = right(i: i)\nvar ma = i\nif l < size(), maxHeap[l] > maxHeap[ma] {\nma = l\n}\nif r < size(), maxHeap[r] > maxHeap[ma] {\nma = r\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif ma == i {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i: i, j: ma)\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma\n}\n}\n
    my_heap.zig
    // \u5143\u7d20\u51fa\u5806\nfn pop(self: *Self) !T {\n// \u5224\u65ad\u5904\u7406\nif (self.isEmpty()) unreachable;\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\ntry self.swap(0, self.size() - 1);\n// \u5220\u9664\u8282\u70b9\nvar val = self.max_heap.?.pop();\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\ntry self.siftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n} // \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\nfn siftDown(self: *Self, i_: usize) !void {\nvar i = i_;\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nvar l = left(i);\nvar r = right(i);\nvar ma = i;\nif (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l;\nif (r < self.size() and self.max_heap.?.items[r] > self.max_heap.?.items[ma]) ma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\ntry self.swap(i, ma);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.dart
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n// \u5224\u7a7a\u5904\u7406\nif (isEmpty()) throw Exception('\u5806\u4e3a\u7a7a');\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n_swap(0, size() - 1);\n// \u5220\u9664\u8282\u70b9\nint val = _maxHeap.removeLast();\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\n_siftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n[class]{MaxHeap}-[func]{siftDown}\n
    "},{"location":"chapter_heap/heap/#813","title":"8.1.3. \u00a0 \u5806\u5e38\u89c1\u5e94\u7528","text":"
    • \u4f18\u5148\u961f\u5217\uff1a\u5806\u901a\u5e38\u4f5c\u4e3a\u5b9e\u73b0\u4f18\u5148\u961f\u5217\u7684\u9996\u9009\u6570\u636e\u7ed3\u6784\uff0c\u5176\u5165\u961f\u548c\u51fa\u961f\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(\\log n)\\) \uff0c\u800c\u5efa\u961f\u64cd\u4f5c\u4e3a \\(O(n)\\) \uff0c\u8fd9\u4e9b\u64cd\u4f5c\u90fd\u975e\u5e38\u9ad8\u6548\u3002
    • \u5806\u6392\u5e8f\uff1a\u7ed9\u5b9a\u4e00\u7ec4\u6570\u636e\uff0c\u6211\u4eec\u53ef\u4ee5\u7528\u5b83\u4eec\u5efa\u7acb\u4e00\u4e2a\u5806\uff0c\u7136\u540e\u4e0d\u65ad\u5730\u6267\u884c\u5143\u7d20\u51fa\u5806\u64cd\u4f5c\uff0c\u4ece\u800c\u5f97\u5230\u6709\u5e8f\u6570\u636e\u3002\u7136\u800c\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u4f7f\u7528\u4e00\u79cd\u66f4\u4f18\u96c5\u7684\u65b9\u5f0f\u5b9e\u73b0\u5806\u6392\u5e8f\uff0c\u8be6\u89c1\u540e\u7eed\u7684\u5806\u6392\u5e8f\u7ae0\u8282\u3002
    • \u83b7\u53d6\u6700\u5927\u7684 \\(k\\) \u4e2a\u5143\u7d20\uff1a\u8fd9\u662f\u4e00\u4e2a\u7ecf\u5178\u7684\u7b97\u6cd5\u95ee\u9898\uff0c\u540c\u65f6\u4e5f\u662f\u4e00\u79cd\u5178\u578b\u5e94\u7528\uff0c\u4f8b\u5982\u9009\u62e9\u70ed\u5ea6\u524d 10 \u7684\u65b0\u95fb\u4f5c\u4e3a\u5fae\u535a\u70ed\u641c\uff0c\u9009\u53d6\u9500\u91cf\u524d 10 \u7684\u5546\u54c1\u7b49\u3002
    "},{"location":"chapter_heap/summary/","title":"8.4. \u00a0 \u5c0f\u7ed3","text":"
    • \u5806\u662f\u4e00\u68f5\u5b8c\u5168\u4e8c\u53c9\u6811\uff0c\u6839\u636e\u6210\u7acb\u6761\u4ef6\u53ef\u5206\u4e3a\u5927\u9876\u5806\u548c\u5c0f\u9876\u5806\u3002\u5927\uff08\u5c0f\uff09\u9876\u5806\u7684\u5806\u9876\u5143\u7d20\u662f\u6700\u5927\uff08\u5c0f\uff09\u7684\u3002
    • \u4f18\u5148\u961f\u5217\u7684\u5b9a\u4e49\u662f\u5177\u6709\u51fa\u961f\u4f18\u5148\u7ea7\u7684\u961f\u5217\uff0c\u901a\u5e38\u4f7f\u7528\u5806\u6765\u5b9e\u73b0\u3002
    • \u5806\u7684\u5e38\u7528\u64cd\u4f5c\u53ca\u5176\u5bf9\u5e94\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5305\u62ec\uff1a\u5143\u7d20\u5165\u5806 \\(O(\\log n)\\) \u3001\u5806\u9876\u5143\u7d20\u51fa\u5806 \\(O(\\log n)\\) \u548c\u8bbf\u95ee\u5806\u9876\u5143\u7d20 \\(O(1)\\) \u7b49\u3002
    • \u5b8c\u5168\u4e8c\u53c9\u6811\u975e\u5e38\u9002\u5408\u7528\u6570\u7ec4\u8868\u793a\uff0c\u56e0\u6b64\u6211\u4eec\u901a\u5e38\u4f7f\u7528\u6570\u7ec4\u6765\u5b58\u50a8\u5806\u3002
    • \u5806\u5316\u64cd\u4f5c\u7528\u4e8e\u7ef4\u62a4\u5806\u7684\u6027\u8d28\uff0c\u5728\u5165\u5806\u548c\u51fa\u5806\u64cd\u4f5c\u4e2d\u90fd\u4f1a\u7528\u5230\u3002
    • \u8f93\u5165 \\(n\\) \u4e2a\u5143\u7d20\u5e76\u5efa\u5806\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u4f18\u5316\u81f3 \\(O(n)\\) \uff0c\u975e\u5e38\u9ad8\u6548\u3002
    • Top-K \u662f\u4e00\u4e2a\u7ecf\u5178\u7b97\u6cd5\u95ee\u9898\uff0c\u53ef\u4ee5\u4f7f\u7528\u5806\u6570\u636e\u7ed3\u6784\u9ad8\u6548\u89e3\u51b3\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log k)\\) \u3002
    "},{"location":"chapter_heap/summary/#841-q-a","title":"8.4.1. \u00a0 Q & A","text":"

    \u6570\u636e\u7ed3\u6784\u7684\u201c\u5806\u201d\u4e0e\u5185\u5b58\u7ba1\u7406\u7684\u201c\u5806\u201d\u662f\u540c\u4e00\u4e2a\u6982\u5ff5\u5417\uff1f

    \u4e24\u8005\u4e0d\u662f\u540c\u4e00\u4e2a\u6982\u5ff5\uff0c\u53ea\u662f\u78b0\u5de7\u90fd\u53eb\u5806\u3002\u8ba1\u7b97\u673a\u7cfb\u7edf\u5185\u5b58\u4e2d\u7684\u5806\u662f\u52a8\u6001\u5185\u5b58\u5206\u914d\u7684\u4e00\u90e8\u5206\uff0c\u7a0b\u5e8f\u5728\u8fd0\u884c\u65f6\u53ef\u4ee5\u4f7f\u7528\u5b83\u6765\u5b58\u50a8\u6570\u636e\u3002\u7a0b\u5e8f\u53ef\u4ee5\u8bf7\u6c42\u4e00\u5b9a\u91cf\u7684\u5806\u5185\u5b58\uff0c\u7528\u4e8e\u5b58\u50a8\u5982\u5bf9\u8c61\u548c\u6570\u7ec4\u7b49\u590d\u6742\u7ed3\u6784\u3002\u5f53\u8fd9\u4e9b\u6570\u636e\u4e0d\u518d\u9700\u8981\u65f6\uff0c\u7a0b\u5e8f\u9700\u8981\u91ca\u653e\u8fd9\u4e9b\u5185\u5b58\uff0c\u4ee5\u9632\u6b62\u5185\u5b58\u6cc4\u9732\u3002\u76f8\u8f83\u4e8e\u6808\u5185\u5b58\uff0c\u5806\u5185\u5b58\u7684\u7ba1\u7406\u548c\u4f7f\u7528\u9700\u8981\u66f4\u8c28\u614e\uff0c\u4e0d\u6070\u5f53\u7684\u4f7f\u7528\u53ef\u80fd\u4f1a\u5bfc\u81f4\u5185\u5b58\u6cc4\u9732\u548c\u91ce\u6307\u9488\u7b49\u95ee\u9898\u3002

    "},{"location":"chapter_heap/top_k/","title":"8.3. \u00a0 Top-K \u95ee\u9898","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u65e0\u5e8f\u6570\u7ec4 nums \uff0c\u8bf7\u8fd4\u56de\u6570\u7ec4\u4e2d\u524d \\(k\\) \u5927\u7684\u5143\u7d20\u3002

    \u5bf9\u4e8e\u8be5\u95ee\u9898\uff0c\u6211\u4eec\u5148\u4ecb\u7ecd\u4e24\u79cd\u601d\u8def\u6bd4\u8f83\u76f4\u63a5\u7684\u89e3\u6cd5\uff0c\u518d\u4ecb\u7ecd\u6548\u7387\u66f4\u9ad8\u7684\u5806\u89e3\u6cd5\u3002

    "},{"location":"chapter_heap/top_k/#831","title":"8.3.1. \u00a0 \u65b9\u6cd5\u4e00\uff1a\u904d\u5386\u9009\u62e9","text":"

    \u6211\u4eec\u53ef\u4ee5\u8fdb\u884c \\(k\\) \u8f6e\u904d\u5386\uff0c\u5206\u522b\u5728\u6bcf\u8f6e\u4e2d\u63d0\u53d6\u7b2c \\(1\\) , \\(2\\) , \\(\\cdots\\) , \\(k\\) \u5927\u7684\u5143\u7d20\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(nk)\\) \u3002

    \u8be5\u65b9\u6cd5\u53ea\u9002\u7528\u4e8e \\(k \\ll n\\) \u7684\u60c5\u51b5\uff0c\u56e0\u4e3a\u5f53 \\(k\\) \u4e0e \\(n\\) \u6bd4\u8f83\u63a5\u8fd1\u65f6\uff0c\u5176\u65f6\u95f4\u590d\u6742\u5ea6\u8d8b\u5411\u4e8e \\(O(n^2)\\) \uff0c\u975e\u5e38\u8017\u65f6\u3002

    Fig. \u904d\u5386\u5bfb\u627e\u6700\u5927\u7684 k \u4e2a\u5143\u7d20

    Tip

    \u5f53 \\(k = n\\) \u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u5230\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\uff0c\u7b49\u4ef7\u4e8e\u300c\u9009\u62e9\u6392\u5e8f\u300d\u7b97\u6cd5\u3002

    "},{"location":"chapter_heap/top_k/#832","title":"8.3.2. \u00a0 \u65b9\u6cd5\u4e8c\uff1a\u6392\u5e8f","text":"

    \u6211\u4eec\u53ef\u4ee5\u5bf9\u6570\u7ec4 nums \u8fdb\u884c\u6392\u5e8f\uff0c\u5e76\u8fd4\u56de\u6700\u53f3\u8fb9\u7684 \\(k\\) \u4e2a\u5143\u7d20\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002

    \u663e\u7136\uff0c\u8be5\u65b9\u6cd5\u201c\u8d85\u989d\u201d\u5b8c\u6210\u4efb\u52a1\u4e86\uff0c\u56e0\u4e3a\u6211\u4eec\u53ea\u9700\u8981\u627e\u51fa\u6700\u5927\u7684 \\(k\\) \u4e2a\u5143\u7d20\u5373\u53ef\uff0c\u800c\u4e0d\u9700\u8981\u6392\u5e8f\u5176\u4ed6\u5143\u7d20\u3002

    Fig. \u6392\u5e8f\u5bfb\u627e\u6700\u5927\u7684 k \u4e2a\u5143\u7d20

    "},{"location":"chapter_heap/top_k/#833","title":"8.3.3. \u00a0 \u65b9\u6cd5\u4e09\uff1a\u5806","text":"

    \u6211\u4eec\u53ef\u4ee5\u57fa\u4e8e\u5806\u66f4\u52a0\u9ad8\u6548\u5730\u89e3\u51b3 Top-K \u95ee\u9898\uff0c\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u521d\u59cb\u5316\u4e00\u4e2a\u5c0f\u9876\u5806\uff0c\u5176\u5806\u9876\u5143\u7d20\u6700\u5c0f\uff1b
    2. \u5148\u5c06\u6570\u7ec4\u7684\u524d \\(k\\) \u4e2a\u5143\u7d20\u4f9d\u6b21\u5165\u5806\uff1b
    3. \u4ece\u7b2c \\(k + 1\\) \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u82e5\u5f53\u524d\u5143\u7d20\u5927\u4e8e\u5806\u9876\u5143\u7d20\uff0c\u5219\u5c06\u5806\u9876\u5143\u7d20\u51fa\u5806\uff0c\u5e76\u5c06\u5f53\u524d\u5143\u7d20\u5165\u5806\uff1b
    4. \u904d\u5386\u5b8c\u6210\u540e\uff0c\u5806\u4e2d\u4fdd\u5b58\u7684\u5c31\u662f\u6700\u5927\u7684 \\(k\\) \u4e2a\u5143\u7d20\uff1b
    <1><2><3><4><5><6><7><8><9>

    \u603b\u5171\u6267\u884c\u4e86 \\(n\\) \u8f6e\u5165\u5806\u548c\u51fa\u5806\uff0c\u5806\u7684\u6700\u5927\u957f\u5ea6\u4e3a \\(k\\) \uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log k)\\) \u3002\u8be5\u65b9\u6cd5\u7684\u6548\u7387\u5f88\u9ad8\uff0c\u5f53 \\(k\\) \u8f83\u5c0f\u65f6\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u8d8b\u5411 \\(O(n)\\) \uff1b\u5f53 \\(k\\) \u8f83\u5927\u65f6\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u4f1a\u8d85\u8fc7 \\(O(n \\log n)\\) \u3002

    \u53e6\u5916\uff0c\u8be5\u65b9\u6cd5\u9002\u7528\u4e8e\u52a8\u6001\u6570\u636e\u6d41\u7684\u4f7f\u7528\u573a\u666f\u3002\u5728\u4e0d\u65ad\u52a0\u5165\u6570\u636e\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u6301\u7eed\u7ef4\u62a4\u5806\u5185\u7684\u5143\u7d20\uff0c\u4ece\u800c\u5b9e\u73b0\u6700\u5927 \\(k\\) \u4e2a\u5143\u7d20\u7684\u52a8\u6001\u66f4\u65b0\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart top_k.java
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nQueue<Integer> topKHeap(int[] nums, int k) {\nQueue<Integer> heap = new PriorityQueue<Integer>();\n// \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\nfor (int i = 0; i < k; i++) {\nheap.add(nums[i]);\n}\n// \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\nfor (int i = k; i < nums.length; i++) {\n// \u82e5\u5f53\u524d\u5143\u7d20\u5927\u4e8e\u5806\u9876\u5143\u7d20\uff0c\u5219\u5c06\u5806\u9876\u5143\u7d20\u51fa\u5806\u3001\u5f53\u524d\u5143\u7d20\u5165\u5806\nif (nums[i] > heap.peek()) {\nheap.poll();\nheap.add(nums[i]);\n}\n}\nreturn heap;\n}\n
    top_k.cpp
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\npriority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k) {\npriority_queue<int, vector<int>, greater<int>> heap;\n// \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\nfor (int i = 0; i < k; i++) {\nheap.push(nums[i]);\n}\n// \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\nfor (int i = k; i < nums.size(); i++) {\n// \u82e5\u5f53\u524d\u5143\u7d20\u5927\u4e8e\u5806\u9876\u5143\u7d20\uff0c\u5219\u5c06\u5806\u9876\u5143\u7d20\u51fa\u5806\u3001\u5f53\u524d\u5143\u7d20\u5165\u5806\nif (nums[i] > heap.top()) {\nheap.pop();\nheap.push(nums[i]);\n}\n}\nreturn heap;\n}\n
    top_k.py
    def top_k_heap(nums: list[int], k: int) -> list[int]:\n\"\"\"\u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20\"\"\"\nheap = []\n# \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\nfor i in range(k):\nheapq.heappush(heap, nums[i])\n# \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\nfor i in range(k, len(nums)):\n# \u82e5\u5f53\u524d\u5143\u7d20\u5927\u4e8e\u5806\u9876\u5143\u7d20\uff0c\u5219\u5c06\u5806\u9876\u5143\u7d20\u51fa\u5806\u3001\u5f53\u524d\u5143\u7d20\u5165\u5806\nif nums[i] > heap[0]:\nheapq.heappop(heap)\nheapq.heappush(heap, nums[i])\nreturn heap\n
    top_k.go
    [class]{maxHeap}-[func]{topKHeap}\n
    top_k.js
    [class]{}-[func]{topKHeap}\n
    top_k.ts
    [class]{}-[func]{topKHeap}\n
    top_k.c
    [class]{maxHeap}-[func]{topKHeap}\n
    top_k.cs
    [class]{top_k}-[func]{topKHeap}\n
    top_k.swift
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfunc topKHeap(nums: [Int], k: Int) -> [Int] {\n// \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\nvar heap = Array(nums.prefix(k))\n// \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\nfor i in stride(from: k, to: nums.count, by: 1) {\n// \u82e5\u5f53\u524d\u5143\u7d20\u5927\u4e8e\u5806\u9876\u5143\u7d20\uff0c\u5219\u5c06\u5806\u9876\u5143\u7d20\u51fa\u5806\u3001\u5f53\u524d\u5143\u7d20\u5165\u5806\nif nums[i] > heap.first! {\nheap.removeFirst()\nheap.insert(nums[i], at: 0)\n}\n}\nreturn heap\n}\n
    top_k.zig
    [class]{}-[func]{topKHeap}\n
    top_k.dart
    [class]{}-[func]{top_k_heap}\n
    "},{"location":"chapter_introduction/","title":"1. \u00a0 \u521d\u8bc6\u7b97\u6cd5","text":""},{"location":"chapter_introduction/algorithms_are_everywhere/","title":"1.1. \u00a0 \u7b97\u6cd5\u65e0\u5904\u4e0d\u5728","text":"

    \u5f53\u6211\u4eec\u542c\u5230\u201c\u7b97\u6cd5\u201d\u8fd9\u4e2a\u8bcd\u65f6\uff0c\u5f88\u81ea\u7136\u5730\u4f1a\u60f3\u5230\u6570\u5b66\u3002\u7136\u800c\u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u7b97\u6cd5\u5e76\u4e0d\u6d89\u53ca\u590d\u6742\u6570\u5b66\uff0c\u800c\u662f\u66f4\u591a\u5730\u4f9d\u8d56\u4e8e\u57fa\u672c\u903b\u8f91\uff0c\u8fd9\u4e9b\u903b\u8f91\u5728\u6211\u4eec\u7684\u65e5\u5e38\u751f\u6d3b\u4e2d\u5904\u5904\u53ef\u89c1\u3002

    \u5728\u6b63\u5f0f\u63a2\u8ba8\u7b97\u6cd5\u4e4b\u524d\uff0c\u6709\u4e00\u4e2a\u6709\u8da3\u7684\u4e8b\u5b9e\u503c\u5f97\u5206\u4eab\uff1a\u4f60\u5df2\u7ecf\u5728\u4e0d\u77e5\u4e0d\u89c9\u4e2d\u5b66\u4f1a\u4e86\u8bb8\u591a\u7b97\u6cd5\uff0c\u5e76\u4e60\u60ef\u5c06\u5b83\u4eec\u5e94\u7528\u5230\u65e5\u5e38\u751f\u6d3b\u4e2d\u4e86\u3002\u4e0b\u9762\uff0c\u6211\u5c06\u4e3e\u51e0\u4e2a\u5177\u4f53\u4f8b\u5b50\u6765\u8bc1\u5b9e\u8fd9\u4e00\u70b9\u3002

    \u4f8b\u4e00\uff1a\u62fc\u88c5\u79ef\u6728\u3002\u4e00\u5957\u79ef\u6728\uff0c\u9664\u4e86\u5305\u542b\u8bb8\u591a\u96f6\u4ef6\u4e4b\u5916\uff0c\u8fd8\u9644\u6709\u8be6\u7ec6\u7684\u7ec4\u88c5\u8bf4\u660e\u4e66\u3002\u6211\u4eec\u6309\u7167\u8bf4\u660e\u4e66\u4e00\u6b65\u6b65\u64cd\u4f5c\uff0c\u5c31\u80fd\u7ec4\u88c5\u51fa\u7cbe\u7f8e\u7684\u79ef\u6728\u6a21\u578b\u3002

    \u4ece\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u89d2\u5ea6\u6765\u770b\uff0c\u79ef\u6728\u7684\u5404\u79cd\u5f62\u72b6\u548c\u8fde\u63a5\u65b9\u5f0f\u4ee3\u8868\u6570\u636e\u7ed3\u6784\uff0c\u800c\u7ec4\u88c5\u8bf4\u660e\u4e66\u4e0a\u7684\u4e00\u7cfb\u5217\u6b65\u9aa4\u5219\u662f\u7b97\u6cd5\u3002

    Fig. \u62fc\u88c5\u79ef\u6728

    \u4f8b\u4e8c\uff1a\u67e5\u9605\u5b57\u5178\u3002\u5728\u5b57\u5178\u91cc\uff0c\u6bcf\u4e2a\u6c49\u5b57\u90fd\u5bf9\u5e94\u4e00\u4e2a\u62fc\u97f3\uff0c\u800c\u5b57\u5178\u662f\u6309\u7167\u62fc\u97f3\u7684\u82f1\u6587\u5b57\u6bcd\u987a\u5e8f\u6392\u5217\u7684\u3002\u5047\u8bbe\u6211\u4eec\u9700\u8981\u67e5\u627e\u4e00\u4e2a\u62fc\u97f3\u9996\u5b57\u6bcd\u4e3a \\(r\\) \u7684\u5b57\uff0c\u901a\u5e38\u4f1a\u8fd9\u6837\u64cd\u4f5c\uff1a

    1. \u7ffb\u5f00\u5b57\u5178\u7ea6\u4e00\u534a\u7684\u9875\u6570\uff0c\u67e5\u770b\u8be5\u9875\u9996\u5b57\u6bcd\u662f\u4ec0\u4e48\uff08\u5047\u8bbe\u4e3a \\(m\\) \uff09\uff1b
    2. \u7531\u4e8e\u5728\u82f1\u6587\u5b57\u6bcd\u8868\u4e2d \\(r\\) \u4f4d\u4e8e \\(m\\) \u4e4b\u540e\uff0c\u6240\u4ee5\u6392\u9664\u5b57\u5178\u524d\u534a\u90e8\u5206\uff0c\u67e5\u627e\u8303\u56f4\u7f29\u5c0f\u5230\u540e\u534a\u90e8\u5206\uff1b
    3. \u4e0d\u65ad\u91cd\u590d\u6b65\u9aa4 1-2 \uff0c\u76f4\u81f3\u627e\u5230\u62fc\u97f3\u9996\u5b57\u6bcd\u4e3a \\(r\\) \u7684\u9875\u7801\u4e3a\u6b62\u3002
    <1><2><3><4><5>

    \u67e5\u9605\u5b57\u5178\u8fd9\u4e2a\u5c0f\u5b66\u751f\u5fc5\u5907\u6280\u80fd\uff0c\u5b9e\u9645\u4e0a\u5c31\u662f\u8457\u540d\u7684\u300c\u4e8c\u5206\u67e5\u627e\u300d\u3002\u4ece\u6570\u636e\u7ed3\u6784\u7684\u89d2\u5ea6\uff0c\u6211\u4eec\u53ef\u4ee5\u628a\u5b57\u5178\u89c6\u4e3a\u4e00\u4e2a\u5df2\u6392\u5e8f\u7684\u300c\u6570\u7ec4\u300d\uff1b\u4ece\u7b97\u6cd5\u7684\u89d2\u5ea6\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u4e0a\u8ff0\u67e5\u5b57\u5178\u7684\u4e00\u7cfb\u5217\u64cd\u4f5c\u770b\u4f5c\u662f\u300c\u4e8c\u5206\u67e5\u627e\u300d\u7b97\u6cd5\u3002

    \u4f8b\u4e09\uff1a\u8d27\u5e01\u627e\u96f6\u3002\u5047\u8bbe\u6211\u4eec\u5728\u8d85\u5e02\u8d2d\u4e70\u4e86 \\(69\\) \u5143\u7684\u5546\u54c1\uff0c\u7ed9\u6536\u94f6\u5458\u4ed8\u4e86 \\(100\\) \u5143\uff0c\u5219\u6536\u94f6\u5458\u9700\u8981\u7ed9\u6211\u4eec\u627e \\(31\\) \u5143\u3002\u4ed6\u4f1a\u5f88\u81ea\u7136\u5730\u5b8c\u6210\u4ee5\u4e0b\u601d\u8003\uff1a

    1. \u53ef\u9009\u9879\u662f\u6bd4 \\(31\\) \u5143\u9762\u503c\u66f4\u5c0f\u7684\u8d27\u5e01\uff0c\u5305\u62ec \\(1\\) , \\(5\\) , \\(10\\) , \\(20\\) \u5143\u3002
    2. \u4ece\u53ef\u9009\u9879\u4e2d\u62ff\u51fa\u6700\u5927\u7684 \\(20\\) \u5143\uff0c\u5269\u4f59 \\(31 - 20 = 11\\) \u5143\u3002
    3. \u4ece\u5269\u4f59\u53ef\u9009\u9879\u4e2d\u62ff\u51fa\u6700\u5927\u7684 \\(10\\) \u5143\uff0c\u5269\u4f59 \\(11 - 10 = 1\\) \u5143\u3002
    4. \u4ece\u5269\u4f59\u53ef\u9009\u9879\u4e2d\u62ff\u51fa\u6700\u5927\u7684 \\(1\\) \u5143\uff0c\u5269\u4f59 \\(1 - 1 = 0\\) \u5143\u3002
    5. \u5b8c\u6210\u627e\u96f6\uff0c\u65b9\u6848\u4e3a \\(20 + 10 + 1 = 31\\) \u5143\u3002

    \u5728\u4ee5\u4e0a\u6b65\u9aa4\u4e2d\uff0c\u6211\u4eec\u6bcf\u4e00\u6b65\u90fd\u91c7\u53d6\u5f53\u524d\u770b\u6765\u6700\u597d\u7684\u9009\u62e9\uff08\u5c3d\u53ef\u80fd\u7528\u5927\u9762\u989d\u7684\u8d27\u5e01\uff09\uff0c\u6700\u7ec8\u5f97\u5230\u4e86\u53ef\u884c\u7684\u627e\u96f6\u65b9\u6848\u3002\u4ece\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u89d2\u5ea6\u770b\uff0c\u8fd9\u79cd\u65b9\u6cd5\u672c\u8d28\u4e0a\u662f\u300c\u8d2a\u5fc3\u7b97\u6cd5\u300d\u3002

    Fig. \u8d27\u5e01\u627e\u96f6

    \u5c0f\u5230\u70f9\u996a\u4e00\u9053\u83dc\uff0c\u5927\u5230\u661f\u9645\u822a\u884c\uff0c\u51e0\u4e4e\u6240\u6709\u95ee\u9898\u7684\u89e3\u51b3\u90fd\u79bb\u4e0d\u5f00\u7b97\u6cd5\u3002\u8ba1\u7b97\u673a\u7684\u51fa\u73b0\u4f7f\u6211\u4eec\u80fd\u591f\u901a\u8fc7\u7f16\u7a0b\u5c06\u6570\u636e\u7ed3\u6784\u5b58\u50a8\u5728\u5185\u5b58\u4e2d\uff0c\u540c\u65f6\u7f16\u5199\u4ee3\u7801\u8c03\u7528 CPU \u548c GPU \u6267\u884c\u7b97\u6cd5\u3002\u8fd9\u6837\u4e00\u6765\uff0c\u6211\u4eec\u5c31\u80fd\u628a\u751f\u6d3b\u4e2d\u7684\u95ee\u9898\u8f6c\u79fb\u5230\u8ba1\u7b97\u673a\u4e0a\uff0c\u4ee5\u66f4\u9ad8\u6548\u7684\u65b9\u5f0f\u89e3\u51b3\u5404\u79cd\u590d\u6742\u95ee\u9898\u3002

    Tip

    \u9605\u8bfb\u81f3\u6b64\uff0c\u5982\u679c\u4f60\u5bf9\u6570\u636e\u7ed3\u6784\u3001\u7b97\u6cd5\u3001\u6570\u7ec4\u548c\u4e8c\u5206\u67e5\u627e\u7b49\u6982\u5ff5\u4ecd\u611f\u5230\u4e00\u77e5\u534a\u89e3\uff0c\u90a3\u4e48\u592a\u597d\u4e86\uff01\u56e0\u4e3a\u8fd9\u6b63\u662f\u672c\u4e66\u5b58\u5728\u7684\u610f\u4e49\u3002\u63a5\u4e0b\u6765\uff0c\u8fd9\u672c\u4e66\u5c06\u4e00\u6b65\u6b65\u5f15\u5bfc\u4f60\u6df1\u5165\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u77e5\u8bc6\u6bbf\u5802\u3002

    "},{"location":"chapter_introduction/summary/","title":"1.3. \u00a0 \u5c0f\u7ed3","text":"
    • \u7b97\u6cd5\u5728\u65e5\u5e38\u751f\u6d3b\u4e2d\u65e0\u5904\u4e0d\u5728\uff0c\u5e76\u4e0d\u662f\u9065\u4e0d\u53ef\u53ca\u7684\u9ad8\u6df1\u77e5\u8bc6\u3002\u5b9e\u9645\u4e0a\uff0c\u6211\u4eec\u5df2\u7ecf\u5728\u4e0d\u77e5\u4e0d\u89c9\u4e2d\u5b66\u4f1a\u4e86\u8bb8\u591a\u7b97\u6cd5\uff0c\u7528\u4ee5\u89e3\u51b3\u751f\u6d3b\u4e2d\u7684\u5927\u5c0f\u95ee\u9898\u3002
    • \u67e5\u9605\u5b57\u5178\u7684\u539f\u7406\u4e0e\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u76f8\u4e00\u81f4\u3002\u4e8c\u5206\u67e5\u627e\u4f53\u73b0\u4e86\u5206\u800c\u6cbb\u4e4b\u7684\u91cd\u8981\u7b97\u6cd5\u601d\u60f3\u3002
    • \u7b97\u6cd5\u662f\u5728\u6709\u9650\u65f6\u95f4\u5185\u89e3\u51b3\u7279\u5b9a\u95ee\u9898\u7684\u4e00\u7ec4\u6307\u4ee4\u6216\u64cd\u4f5c\u6b65\u9aa4\uff0c\u800c\u6570\u636e\u7ed3\u6784\u662f\u8ba1\u7b97\u673a\u4e2d\u7ec4\u7ec7\u548c\u5b58\u50a8\u6570\u636e\u7684\u65b9\u5f0f\u3002
    • \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7d27\u5bc6\u76f8\u8fde\u3002\u6570\u636e\u7ed3\u6784\u662f\u7b97\u6cd5\u7684\u57fa\u77f3\uff0c\u800c\u7b97\u6cd5\u5219\u662f\u53d1\u6325\u6570\u636e\u7ed3\u6784\u4f5c\u7528\u7684\u821e\u53f0\u3002
    • \u4e50\u9ad8\u79ef\u6728\u5bf9\u5e94\u4e8e\u6570\u636e\uff0c\u79ef\u6728\u5f62\u72b6\u548c\u8fde\u63a5\u65b9\u5f0f\u4ee3\u8868\u6570\u636e\u7ed3\u6784\uff0c\u62fc\u88c5\u79ef\u6728\u7684\u6b65\u9aa4\u5219\u5bf9\u5e94\u7b97\u6cd5\u3002
    "},{"location":"chapter_introduction/what_is_dsa/","title":"1.2. \u00a0 \u7b97\u6cd5\u662f\u4ec0\u4e48","text":""},{"location":"chapter_introduction/what_is_dsa/#121","title":"1.2.1. \u00a0 \u7b97\u6cd5\u5b9a\u4e49","text":"

    \u300c\u7b97\u6cd5 Algorithm\u300d\u662f\u5728\u6709\u9650\u65f6\u95f4\u5185\u89e3\u51b3\u7279\u5b9a\u95ee\u9898\u7684\u4e00\u7ec4\u6307\u4ee4\u6216\u64cd\u4f5c\u6b65\u9aa4\u3002\u7b97\u6cd5\u5177\u6709\u4ee5\u4e0b\u7279\u6027\uff1a

    • \u95ee\u9898\u662f\u660e\u786e\u7684\uff0c\u5305\u542b\u6e05\u6670\u7684\u8f93\u5165\u548c\u8f93\u51fa\u5b9a\u4e49\u3002
    • \u5177\u6709\u53ef\u884c\u6027\uff0c\u80fd\u591f\u5728\u6709\u9650\u6b65\u9aa4\u3001\u65f6\u95f4\u548c\u5185\u5b58\u7a7a\u95f4\u4e0b\u5b8c\u6210\u3002
    • \u5404\u6b65\u9aa4\u90fd\u6709\u786e\u5b9a\u7684\u542b\u4e49\uff0c\u76f8\u540c\u7684\u8f93\u5165\u548c\u8fd0\u884c\u6761\u4ef6\u4e0b\uff0c\u8f93\u51fa\u59cb\u7ec8\u76f8\u540c\u3002
    "},{"location":"chapter_introduction/what_is_dsa/#122","title":"1.2.2. \u00a0 \u6570\u636e\u7ed3\u6784\u5b9a\u4e49","text":"

    \u300c\u6570\u636e\u7ed3\u6784 Data Structure\u300d\u662f\u8ba1\u7b97\u673a\u4e2d\u7ec4\u7ec7\u548c\u5b58\u50a8\u6570\u636e\u7684\u65b9\u5f0f\u3002\u4e3a\u4e86\u63d0\u9ad8\u6570\u636e\u5b58\u50a8\u548c\u64cd\u4f5c\u6027\u80fd\uff0c\u6570\u636e\u7ed3\u6784\u7684\u8bbe\u8ba1\u76ee\u6807\u5305\u62ec\uff1a

    • \u7a7a\u95f4\u5360\u7528\u5c3d\u91cf\u51cf\u5c11\uff0c\u8282\u7701\u8ba1\u7b97\u673a\u5185\u5b58\u3002
    • \u6570\u636e\u64cd\u4f5c\u5c3d\u53ef\u80fd\u5feb\u901f\uff0c\u6db5\u76d6\u6570\u636e\u8bbf\u95ee\u3001\u6dfb\u52a0\u3001\u5220\u9664\u3001\u66f4\u65b0\u7b49\u3002
    • \u63d0\u4f9b\u7b80\u6d01\u7684\u6570\u636e\u8868\u793a\u548c\u903b\u8f91\u4fe1\u606f\uff0c\u4ee5\u4fbf\u4f7f\u5f97\u7b97\u6cd5\u9ad8\u6548\u8fd0\u884c\u3002

    \u6570\u636e\u7ed3\u6784\u8bbe\u8ba1\u662f\u4e00\u4e2a\u5145\u6ee1\u6743\u8861\u7684\u8fc7\u7a0b\uff0c\u8fd9\u610f\u5473\u7740\u8981\u5728\u67d0\u65b9\u9762\u53d6\u5f97\u4f18\u52bf\uff0c\u5f80\u5f80\u9700\u8981\u5728\u53e6\u4e00\u65b9\u9762\u4f5c\u51fa\u59a5\u534f\u3002\u4f8b\u5982\uff0c\u94fe\u8868\u76f8\u8f83\u4e8e\u6570\u7ec4\uff0c\u5728\u6570\u636e\u6dfb\u52a0\u548c\u5220\u9664\u64cd\u4f5c\u4e0a\u66f4\u52a0\u4fbf\u6377\uff0c\u4f46\u727a\u7272\u4e86\u6570\u636e\u8bbf\u95ee\u901f\u5ea6\uff1b\u56fe\u76f8\u8f83\u4e8e\u94fe\u8868\uff0c\u63d0\u4f9b\u4e86\u66f4\u4e30\u5bcc\u7684\u903b\u8f91\u4fe1\u606f\uff0c\u4f46\u9700\u8981\u5360\u7528\u66f4\u5927\u7684\u5185\u5b58\u7a7a\u95f4\u3002

    "},{"location":"chapter_introduction/what_is_dsa/#123","title":"1.2.3. \u00a0 \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u5173\u7cfb","text":"

    \u300c\u6570\u636e\u7ed3\u6784\u300d\u4e0e\u300c\u7b97\u6cd5\u300d\u9ad8\u5ea6\u76f8\u5173\u4e14\u7d27\u5bc6\u7ed3\u5408\uff0c\u5177\u4f53\u8868\u73b0\u5728\uff1a

    • \u6570\u636e\u7ed3\u6784\u662f\u7b97\u6cd5\u7684\u57fa\u77f3\u3002\u6570\u636e\u7ed3\u6784\u4e3a\u7b97\u6cd5\u63d0\u4f9b\u4e86\u7ed3\u6784\u5316\u5b58\u50a8\u7684\u6570\u636e\uff0c\u4ee5\u53ca\u7528\u4e8e\u64cd\u4f5c\u6570\u636e\u7684\u65b9\u6cd5\u3002
    • \u7b97\u6cd5\u662f\u6570\u636e\u7ed3\u6784\u53d1\u6325\u7684\u821e\u53f0\u3002\u6570\u636e\u7ed3\u6784\u672c\u8eab\u4ec5\u5b58\u50a8\u6570\u636e\u4fe1\u606f\uff0c\u901a\u8fc7\u7ed3\u5408\u7b97\u6cd5\u624d\u80fd\u89e3\u51b3\u7279\u5b9a\u95ee\u9898\u3002
    • \u7279\u5b9a\u7b97\u6cd5\u901a\u5e38\u6709\u5bf9\u5e94\u6700\u4f18\u7684\u6570\u636e\u7ed3\u6784\u3002\u7b97\u6cd5\u901a\u5e38\u53ef\u4ee5\u57fa\u4e8e\u4e0d\u540c\u7684\u6570\u636e\u7ed3\u6784\u8fdb\u884c\u5b9e\u73b0\uff0c\u4f46\u6700\u7ec8\u6267\u884c\u6548\u7387\u53ef\u80fd\u76f8\u5dee\u5f88\u5927\u3002

    Fig. \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u5173\u7cfb

    \u7c7b\u6bd4\u300cLEGO \u4e50\u9ad8\u300d\u548c\u300c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u300d\uff0c\u5219\u5bf9\u5e94\u5173\u7cfb\u5982\u4e0b\u8868\u6240\u793a\u3002

    \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5 LEGO \u4e50\u9ad8 \u8f93\u5165\u6570\u636e \u672a\u62fc\u88c5\u7684\u79ef\u6728 \u6570\u636e\u7ed3\u6784 \u79ef\u6728\u7ec4\u7ec7\u5f62\u5f0f\uff0c\u5305\u62ec\u5f62\u72b6\u3001\u5927\u5c0f\u3001\u8fde\u63a5\u65b9\u5f0f\u7b49 \u7b97\u6cd5 \u628a\u79ef\u6728\u62fc\u6210\u76ee\u6807\u5f62\u6001\u7684\u4e00\u7cfb\u5217\u64cd\u4f5c\u6b65\u9aa4 \u8f93\u51fa\u6570\u636e \u79ef\u6728\u6a21\u578b

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u72ec\u7acb\u4e8e\u7f16\u7a0b\u8bed\u8a00\u3002\u6b63\u56e0\u5982\u6b64\uff0c\u672c\u4e66\u5f97\u4ee5\u63d0\u4f9b\u591a\u79cd\u7f16\u7a0b\u8bed\u8a00\u7684\u5b9e\u73b0\u3002

    \u7ea6\u5b9a\u4fd7\u6210\u7684\u7b80\u79f0

    \u5728\u5b9e\u9645\u8ba8\u8bba\u65f6\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u5c06\u300c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u300d\u7b80\u79f0\u4e3a\u300c\u7b97\u6cd5\u300d\u3002\u4f8b\u5982\uff0c\u4f17\u6240\u5468\u77e5\u7684 LeetCode \u7b97\u6cd5\u9898\u76ee\uff0c\u5b9e\u9645\u4e0a\u540c\u65f6\u8003\u5bdf\u4e86\u6570\u636e\u7ed3\u6784\u548c\u7b97\u6cd5\u4e24\u65b9\u9762\u7684\u77e5\u8bc6\u3002

    "},{"location":"chapter_preface/","title":"0. \u00a0 \u524d\u8a00","text":""},{"location":"chapter_preface/about_the_book/","title":"0.1. \u00a0 \u5173\u4e8e\u672c\u4e66","text":"

    \u672c\u9879\u76ee\u65e8\u5728\u521b\u5efa\u4e00\u672c\u5f00\u6e90\u514d\u8d39\u3001\u65b0\u624b\u53cb\u597d\u7684\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u5165\u95e8\u6559\u7a0b\u3002

    • \u5168\u4e66\u91c7\u7528\u52a8\u753b\u56fe\u89e3\uff0c\u7ed3\u6784\u5316\u5730\u8bb2\u89e3\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u77e5\u8bc6\uff0c\u5185\u5bb9\u6e05\u6670\u6613\u61c2\u3001\u5b66\u4e60\u66f2\u7ebf\u5e73\u6ed1\uff1b
    • \u7b97\u6cd5\u6e90\u4ee3\u7801\u7686\u53ef\u4e00\u952e\u8fd0\u884c\uff0c\u652f\u6301 Java, C++, Python, Go, JS, TS, C#, Swift, Zig \u7b49\u8bed\u8a00\uff1b
    • \u9f13\u52b1\u8bfb\u8005\u5728\u7ae0\u8282\u8ba8\u8bba\u533a\u4e92\u5e2e\u4e92\u52a9\u3001\u5171\u540c\u8fdb\u6b65\uff0c\u63d0\u95ee\u4e0e\u8bc4\u8bba\u901a\u5e38\u53ef\u5728\u4e24\u65e5\u5185\u5f97\u5230\u56de\u590d\uff1b
    "},{"location":"chapter_preface/about_the_book/#011","title":"0.1.1. \u00a0 \u8bfb\u8005\u5bf9\u8c61","text":"

    \u82e5\u60a8\u662f\u300c\u7b97\u6cd5\u521d\u5b66\u8005\u300d\uff0c\u4ece\u672a\u63a5\u89e6\u8fc7\u7b97\u6cd5\uff0c\u6216\u8005\u5df2\u7ecf\u6709\u4e00\u4e9b\u5237\u9898\u7ecf\u9a8c\uff0c\u5bf9\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u6709\u6a21\u7cca\u7684\u8ba4\u8bc6\uff0c\u5728\u4f1a\u4e0e\u4e0d\u4f1a\u4e4b\u95f4\u53cd\u590d\u6a2a\u8df3\uff0c\u90a3\u4e48\u8fd9\u672c\u4e66\u6b63\u662f\u4e3a\u60a8\u91cf\u8eab\u5b9a\u5236\uff01

    \u5982\u679c\u60a8\u662f\u300c\u7b97\u6cd5\u8001\u624b\u300d\uff0c\u5df2\u7ecf\u79ef\u7d2f\u4e00\u5b9a\u5237\u9898\u91cf\uff0c\u719f\u6089\u5927\u90e8\u5206\u9898\u578b\uff0c\u90a3\u4e48\u672c\u4e66\u53ef\u52a9\u60a8\u56de\u987e\u4e0e\u68b3\u7406\u7b97\u6cd5\u77e5\u8bc6\u4f53\u7cfb\uff0c\u4ed3\u5e93\u6e90\u4ee3\u7801\u53ef\u4ee5\u88ab\u5f53\u4f5c\u201c\u5237\u9898\u5de5\u5177\u5e93\u201d\u6216\u201c\u7b97\u6cd5\u5b57\u5178\u201d\u6765\u4f7f\u7528\u3002

    \u82e5\u60a8\u662f\u300c\u7b97\u6cd5\u5927\u795e\u300d\uff0c\u6211\u4eec\u671f\u5f85\u6536\u5230\u60a8\u7684\u5b9d\u8d35\u5efa\u8bae\uff0c\u6216\u8005\u4e00\u8d77\u53c2\u4e0e\u521b\u4f5c\u3002

    \u524d\u7f6e\u6761\u4ef6

    \u60a8\u9700\u8981\u81f3\u5c11\u5177\u5907\u4efb\u4e00\u8bed\u8a00\u7684\u7f16\u7a0b\u57fa\u7840\uff0c\u80fd\u591f\u9605\u8bfb\u548c\u7f16\u5199\u7b80\u5355\u4ee3\u7801\u3002

    "},{"location":"chapter_preface/about_the_book/#012","title":"0.1.2. \u00a0 \u5185\u5bb9\u7ed3\u6784","text":"

    \u672c\u4e66\u4e3b\u8981\u5185\u5bb9\u5305\u62ec\uff1a

    • \u590d\u6742\u5ea6\u5206\u6790\uff1a\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u8bc4\u4ef7\u7ef4\u5ea6\u3001\u7b97\u6cd5\u6548\u7387\u7684\u8bc4\u4f30\u65b9\u6cd5\u3002\u65f6\u95f4\u590d\u6742\u5ea6\u3001\u7a7a\u95f4\u590d\u6742\u5ea6\uff0c\u5305\u62ec\u63a8\u7b97\u65b9\u6cd5\u3001\u5e38\u89c1\u7c7b\u578b\u3001\u793a\u4f8b\u7b49\u3002
    • \u6570\u636e\u7ed3\u6784\uff1a\u5e38\u89c1\u57fa\u672c\u6570\u636e\u7c7b\u578b\uff0c\u6570\u636e\u5728\u5185\u5b58\u4e2d\u7684\u5b58\u50a8\u5f62\u5f0f\u3001\u6570\u636e\u7ed3\u6784\u7684\u5206\u7c7b\u65b9\u6cd5\u3002\u6d89\u53ca\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\u3001\u6563\u5217\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\u7b49\u6570\u636e\u7ed3\u6784\uff0c\u5185\u5bb9\u5305\u62ec\u5b9a\u4e49\u3001\u4f18\u7f3a\u70b9\u3001\u5e38\u7528\u64cd\u4f5c\u3001\u5e38\u89c1\u7c7b\u578b\u3001\u5178\u578b\u5e94\u7528\u3001\u5b9e\u73b0\u65b9\u6cd5\u7b49\u3002
    • \u7b97\u6cd5\uff1a\u67e5\u627e\u7b97\u6cd5\u3001\u6392\u5e8f\u7b97\u6cd5\u3001\u641c\u7d22\u4e0e\u56de\u6eaf\u3001\u52a8\u6001\u89c4\u5212\u3001\u5206\u6cbb\u7b97\u6cd5\u7b49\uff0c\u5185\u5bb9\u6db5\u76d6\u5b9a\u4e49\u3001\u5e94\u7528\u573a\u666f\u3001\u4f18\u7f3a\u70b9\u3001\u65f6\u7a7a\u6548\u7387\u3001\u5b9e\u73b0\u65b9\u6cd5\u3001\u793a\u4f8b\u9898\u76ee\u7b49\u3002

    Fig. Hello \u7b97\u6cd5\u5185\u5bb9\u7ed3\u6784

    "},{"location":"chapter_preface/about_the_book/#013","title":"0.1.3. \u00a0 \u81f4\u8c22","text":"

    \u5728\u672c\u4e66\u7684\u521b\u4f5c\u8fc7\u7a0b\u4e2d\uff0c\u6211\u5f97\u5230\u4e86\u8bb8\u591a\u4eba\u7684\u5e2e\u52a9\uff0c\u5305\u62ec\u4f46\u4e0d\u9650\u4e8e\uff1a

    • \u611f\u8c22\u6211\u5728\u516c\u53f8\u7684\u5bfc\u5e08\u674e\u6c50\u535a\u58eb\uff0c\u5728\u4e00\u6b21\u7545\u8c08\u4e2d\u60a8\u9f13\u52b1\u6211\u201c\u884c\u52a8\u8d77\u6765\u201d\uff0c\u575a\u5b9a\u4e86\u6211\u5199\u8fd9\u672c\u4e66\u7684\u51b3\u5fc3\u3002
    • \u611f\u8c22\u6211\u7684\u5973\u670b\u53cb\u6ce1\u6ce1\u4f5c\u4e3a\u672c\u4e66\u7684\u9996\u4f4d\u8bfb\u8005\uff0c\u4ece\u7b97\u6cd5\u5c0f\u767d\u7684\u89d2\u5ea6\u63d0\u51fa\u8bb8\u591a\u5b9d\u8d35\u5efa\u8bae\uff0c\u4f7f\u5f97\u672c\u4e66\u66f4\u9002\u5408\u65b0\u624b\u9605\u8bfb\u3002
    • \u611f\u8c22\u817e\u5b9d\u3001\u7426\u5b9d\u3001\u98de\u5b9d\u4e3a\u672c\u4e66\u8d77\u4e86\u4e00\u4e2a\u5bcc\u6709\u521b\u610f\u7684\u540d\u5b57\uff0c\u5524\u8d77\u5927\u5bb6\u5199\u4e0b\u7b2c\u4e00\u884c\u4ee3\u7801 \"Hello World!\" \u7684\u7f8e\u597d\u56de\u5fc6\u3002
    • \u611f\u8c22\u82cf\u6f7c\u4e3a\u672c\u4e66\u8bbe\u8ba1\u4e86\u7cbe\u7f8e\u7684\u5c01\u9762\u548c LOGO\uff0c\u5e76\u5728\u6211\u7684\u5f3a\u8feb\u75c7\u4e0b\u591a\u6b21\u8010\u5fc3\u4fee\u6539\u3002
    • \u611f\u8c22 @squidfunk \u63d0\u4f9b\u7684\u5199\u4f5c\u6392\u7248\u5efa\u8bae\uff0c\u4ee5\u53ca\u6770\u51fa\u7684\u5f00\u6e90\u9879\u76ee Material-for-MkDocs \u3002

    \u5728\u5199\u4f5c\u8fc7\u7a0b\u4e2d\uff0c\u6211\u9605\u8bfb\u4e86\u8bb8\u591a\u5173\u4e8e\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u6559\u6750\u548c\u6587\u7ae0\u3002\u8fd9\u4e9b\u4f5c\u54c1\u4e3a\u672c\u4e66\u63d0\u4f9b\u4e86\u4f18\u79c0\u7684\u8303\u672c\uff0c\u786e\u4fdd\u4e86\u672c\u4e66\u5185\u5bb9\u7684\u51c6\u786e\u6027\u4e0e\u54c1\u8d28\u3002\u5728\u6b64\u611f\u8c22\u6240\u6709\u8001\u5e08\u548c\u524d\u8f88\u4eec\u7684\u6770\u51fa\u8d21\u732e\uff01

    \u672c\u4e66\u5021\u5bfc\u624b\u8111\u5e76\u7528\u7684\u5b66\u4e60\u65b9\u5f0f\uff0c\u5728\u8fd9\u4e00\u70b9\u4e0a\u6df1\u53d7\u300a\u52a8\u624b\u5b66\u6df1\u5ea6\u5b66\u4e60\u300b\u7684\u542f\u53d1\u3002\u5728\u6b64\u5411\u5404\u4f4d\u8bfb\u8005\u5f3a\u70c8\u63a8\u8350\u8fd9\u672c\u4f18\u79c0\u8457\u4f5c\u3002

    \u8877\u5fc3\u611f\u8c22\u6211\u7684\u7236\u6bcd\uff0c\u6b63\u662f\u4f60\u4eec\u4e00\u76f4\u4ee5\u6765\u7684\u652f\u6301\u4e0e\u9f13\u52b1\uff0c\u8ba9\u6211\u6709\u673a\u4f1a\u505a\u8fd9\u4e9b\u5bcc\u6709\u8da3\u5473\u7684\u4e8b\u3002

    "},{"location":"chapter_preface/suggestions/","title":"0.2. \u00a0 \u5982\u4f55\u4f7f\u7528\u672c\u4e66","text":"

    Tip

    \u4e3a\u4e86\u83b7\u5f97\u6700\u4f73\u7684\u9605\u8bfb\u4f53\u9a8c\uff0c\u5efa\u8bae\u60a8\u901a\u8bfb\u672c\u8282\u5185\u5bb9\u3002

    "},{"location":"chapter_preface/suggestions/#021","title":"0.2.1. \u00a0 \u884c\u6587\u98ce\u683c\u7ea6\u5b9a","text":"
    • \u6807\u9898\u540e\u6807\u6ce8 * \u7684\u662f\u9009\u8bfb\u7ae0\u8282\uff0c\u5185\u5bb9\u76f8\u5bf9\u56f0\u96be\u3002\u5982\u679c\u4f60\u7684\u65f6\u95f4\u6709\u9650\uff0c\u5efa\u8bae\u53ef\u4ee5\u5148\u8df3\u8fc7\u3002
    • \u6587\u7ae0\u4e2d\u7684\u91cd\u8981\u540d\u8bcd\u4f1a\u7528 \u300c \u300d \u62ec\u53f7\u6807\u6ce8\uff0c\u4f8b\u5982 \u300c\u6570\u7ec4 Array\u300d \u3002\u8bf7\u52a1\u5fc5\u8bb0\u4f4f\u8fd9\u4e9b\u540d\u8bcd\uff0c\u5305\u62ec\u82f1\u6587\u7ffb\u8bd1\uff0c\u4ee5\u4fbf\u540e\u7eed\u9605\u8bfb\u6587\u732e\u65f6\u4f7f\u7528\u3002
    • \u52a0\u7c97\u7684\u6587\u5b57 \u8868\u793a\u91cd\u70b9\u5185\u5bb9\u6216\u603b\u7ed3\u6027\u8bed\u53e5\uff0c\u8fd9\u7c7b\u6587\u5b57\u503c\u5f97\u7279\u522b\u5173\u6ce8\u3002
    • \u4e13\u6709\u540d\u8bcd\u548c\u6709\u7279\u6307\u542b\u4e49\u7684\u8bcd\u53e5\u4f1a\u4f7f\u7528 \u201c\u53cc\u5f15\u53f7\u201d \u6807\u6ce8\uff0c\u4ee5\u907f\u514d\u6b67\u4e49\u3002
    • \u6d89\u53ca\u5230\u7f16\u7a0b\u8bed\u8a00\u4e4b\u95f4\u4e0d\u4e00\u81f4\u7684\u540d\u8bcd\uff0c\u672c\u4e66\u5747\u4ee5 Python \u4e3a\u51c6\uff0c\u4f8b\u5982\u4f7f\u7528 \\(\\text{None}\\) \u6765\u8868\u793a\u201c\u7a7a\u201d\u3002
    • \u672c\u4e66\u90e8\u5206\u653e\u5f03\u4e86\u7f16\u7a0b\u8bed\u8a00\u7684\u6ce8\u91ca\u89c4\u8303\uff0c\u4ee5\u6362\u53d6\u66f4\u52a0\u7d27\u51d1\u7684\u5185\u5bb9\u6392\u7248\u3002\u6ce8\u91ca\u4e3b\u8981\u5206\u4e3a\u4e09\u79cd\u7c7b\u578b\uff1a\u6807\u9898\u6ce8\u91ca\u3001\u5185\u5bb9\u6ce8\u91ca\u3001\u591a\u884c\u6ce8\u91ca\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    \"\"\"\u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49\"\"\"\n# \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\"\"\"\n\u591a\u884c\n\u6ce8\u91ca\n\"\"\"\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    // \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n// \u591a\u884c\n// \u6ce8\u91ca\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    "},{"location":"chapter_preface/suggestions/#022","title":"0.2.2. \u00a0 \u5728\u52a8\u753b\u56fe\u89e3\u4e2d\u9ad8\u6548\u5b66\u4e60","text":"

    \u76f8\u8f83\u4e8e\u6587\u5b57\uff0c\u89c6\u9891\u548c\u56fe\u7247\u5177\u6709\u66f4\u9ad8\u7684\u4fe1\u606f\u5bc6\u5ea6\u548c\u7ed3\u6784\u5316\u7a0b\u5ea6\uff0c\u56e0\u6b64\u66f4\u6613\u4e8e\u7406\u89e3\u3002\u5728\u672c\u4e66\u4e2d\uff0c\u91cd\u70b9\u548c\u96be\u70b9\u77e5\u8bc6\u5c06\u4e3b\u8981\u901a\u8fc7\u52a8\u753b\u548c\u56fe\u89e3\u5f62\u5f0f\u5c55\u793a\uff0c\u800c\u6587\u5b57\u5219\u4f5c\u4e3a\u52a8\u753b\u548c\u56fe\u7247\u7684\u89e3\u91ca\u4e0e\u8865\u5145\u3002

    \u5728\u9605\u8bfb\u672c\u4e66\u65f6\uff0c\u5982\u679c\u53d1\u73b0\u67d0\u6bb5\u5185\u5bb9\u63d0\u4f9b\u4e86\u52a8\u753b\u6216\u56fe\u89e3\uff0c\u5efa\u8bae\u4ee5\u56fe\u4e3a\u4e3b\u7ebf\uff0c\u4ee5\u6587\u5b57\uff08\u901a\u5e38\u4f4d\u4e8e\u56fe\u50cf\u4e0a\u65b9\uff09\u4e3a\u8f85\uff0c\u7efc\u5408\u4e24\u8005\u6765\u7406\u89e3\u5185\u5bb9\u3002

    Fig. \u52a8\u753b\u56fe\u89e3\u793a\u4f8b

    "},{"location":"chapter_preface/suggestions/#023","title":"0.2.3. \u00a0 \u5728\u4ee3\u7801\u5b9e\u8df5\u4e2d\u52a0\u6df1\u7406\u89e3","text":"

    \u672c\u4e66\u7684\u914d\u5957\u4ee3\u7801\u6258\u7ba1\u5728GitHub \u4ed3\u5e93\uff0c\u6e90\u4ee3\u7801\u5305\u542b\u8be6\u7ec6\u6ce8\u91ca\uff0c\u5e76\u9644\u6709\u6d4b\u8bd5\u6837\u4f8b\uff0c\u53ef\u76f4\u63a5\u8fd0\u884c\u3002

    \u5982\u679c\u5b66\u4e60\u65f6\u95f4\u6709\u9650\uff0c\u5efa\u8bae\u4f60\u81f3\u5c11\u901a\u8bfb\u5e76\u8fd0\u884c\u6240\u6709\u4ee3\u7801\u3002\u5982\u679c\u65f6\u95f4\u5145\u88d5\uff0c\u5efa\u8bae\u53c2\u7167\u4ee3\u7801\u81ea\u884c\u6572\u4e00\u904d\u3002\u4e0e\u4ec5\u9605\u8bfb\u4ee3\u7801\u76f8\u6bd4\uff0c\u7f16\u5199\u4ee3\u7801\u7684\u8fc7\u7a0b\u5f80\u5f80\u80fd\u5e26\u6765\u66f4\u591a\u6536\u83b7\u3002

    Fig. \u8fd0\u884c\u4ee3\u7801\u793a\u4f8b

    \u7b2c\u4e00\u6b65\uff1a\u5b89\u88c5\u672c\u5730\u7f16\u7a0b\u73af\u5883\u3002\u8bf7\u53c2\u7167\u9644\u5f55\u6559\u7a0b\u8fdb\u884c\u5b89\u88c5\uff0c\u5982\u679c\u5df2\u5b89\u88c5\u5219\u53ef\u8df3\u8fc7\u6b64\u6b65\u9aa4\u3002

    \u7b2c\u4e8c\u6b65\uff1a\u4e0b\u8f7d\u4ee3\u7801\u4ed3\u3002\u5982\u679c\u5df2\u7ecf\u5b89\u88c5 Git \uff0c\u53ef\u4ee5\u901a\u8fc7\u4ee5\u4e0b\u547d\u4ee4\u514b\u9686\u672c\u4ed3\u5e93\u3002

    git clone https://github.com/krahets/hello-algo.git\n

    \u5f53\u7136\uff0c\u4f60\u4e5f\u53ef\u4ee5\u70b9\u51fb\u201cDownload ZIP\u201d\u76f4\u63a5\u4e0b\u8f7d\u4ee3\u7801\u538b\u7f29\u5305\uff0c\u7136\u540e\u5728\u672c\u5730\u89e3\u538b\u5373\u53ef\u3002

    Fig. \u514b\u9686\u4ed3\u5e93\u4e0e\u4e0b\u8f7d\u4ee3\u7801

    \u7b2c\u4e09\u6b65\uff1a\u8fd0\u884c\u6e90\u4ee3\u7801\u3002\u5982\u679c\u4ee3\u7801\u5757\u9876\u90e8\u6807\u6709\u6587\u4ef6\u540d\u79f0\uff0c\u5219\u53ef\u4ee5\u5728\u4ed3\u5e93\u7684 codes \u6587\u4ef6\u5939\u4e2d\u627e\u5230\u76f8\u5e94\u7684\u6e90\u4ee3\u7801\u6587\u4ef6\u3002\u6e90\u4ee3\u7801\u6587\u4ef6\u5c06\u5e2e\u52a9\u4f60\u8282\u7701\u4e0d\u5fc5\u8981\u7684\u8c03\u8bd5\u65f6\u95f4\uff0c\u8ba9\u4f60\u80fd\u591f\u4e13\u6ce8\u4e8e\u5b66\u4e60\u5185\u5bb9\u3002

    Fig. \u4ee3\u7801\u5757\u4e0e\u5bf9\u5e94\u7684\u6e90\u4ee3\u7801\u6587\u4ef6

    "},{"location":"chapter_preface/suggestions/#024","title":"0.2.4. \u00a0 \u5728\u63d0\u95ee\u8ba8\u8bba\u4e2d\u5171\u540c\u6210\u957f","text":"

    \u9605\u8bfb\u672c\u4e66\u65f6\uff0c\u8bf7\u4e0d\u8981\u201c\u60ef\u7740\u201d\u90a3\u4e9b\u6ca1\u5b66\u660e\u767d\u7684\u77e5\u8bc6\u70b9\u3002\u6b22\u8fce\u5728\u8bc4\u8bba\u533a\u63d0\u51fa\u4f60\u7684\u95ee\u9898\uff0c\u6211\u548c\u5176\u4ed6\u5c0f\u4f19\u4f34\u4eec\u5c06\u7aed\u8bda\u4e3a\u4f60\u89e3\u7b54\uff0c\u4e00\u822c\u60c5\u51b5\u4e0b\u53ef\u5728\u4e24\u5929\u5185\u5f97\u5230\u56de\u590d\u3002

    \u540c\u65f6\uff0c\u4e5f\u5e0c\u671b\u60a8\u80fd\u5728\u8bc4\u8bba\u533a\u591a\u82b1\u4e9b\u65f6\u95f4\u3002\u4e00\u65b9\u9762\uff0c\u60a8\u53ef\u4ee5\u4e86\u89e3\u5927\u5bb6\u9047\u5230\u7684\u95ee\u9898\uff0c\u4ece\u800c\u67e5\u6f0f\u8865\u7f3a\uff0c\u8fd9\u5c06\u6709\u52a9\u4e8e\u6fc0\u53d1\u66f4\u6df1\u5165\u7684\u601d\u8003\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u5e0c\u671b\u60a8\u80fd\u6177\u6168\u5730\u56de\u7b54\u5176\u4ed6\u5c0f\u4f19\u4f34\u7684\u95ee\u9898\u3001\u5206\u4eab\u60a8\u7684\u89c1\u89e3\uff0c\u8ba9\u5927\u5bb6\u5171\u540c\u5b66\u4e60\u548c\u8fdb\u6b65\u3002

    Fig. \u8bc4\u8bba\u533a\u793a\u4f8b

    "},{"location":"chapter_preface/suggestions/#025","title":"0.2.5. \u00a0 \u7b97\u6cd5\u5b66\u4e60\u8def\u7ebf","text":"

    \u4ece\u603b\u4f53\u4e0a\u770b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5b66\u4e60\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u8fc7\u7a0b\u5212\u5206\u4e3a\u4e09\u4e2a\u9636\u6bb5\uff1a

    1. \u7b97\u6cd5\u5165\u95e8\u3002\u6211\u4eec\u9700\u8981\u719f\u6089\u5404\u79cd\u6570\u636e\u7ed3\u6784\u7684\u7279\u70b9\u548c\u7528\u6cd5\uff0c\u5b66\u4e60\u4e0d\u540c\u7b97\u6cd5\u7684\u539f\u7406\u3001\u6d41\u7a0b\u3001\u7528\u9014\u548c\u6548\u7387\u7b49\u65b9\u9762\u5185\u5bb9\u3002
    2. \u5237\u7b97\u6cd5\u9898\u3002\u5efa\u8bae\u4ece\u70ed\u95e8\u9898\u76ee\u5f00\u5237\uff0c\u5982\u5251\u6307 Offer\u548cLeetCode Hot 100\uff0c\u5148\u79ef\u7d2f\u81f3\u5c11 100 \u9053\u9898\u76ee\uff0c\u719f\u6089\u4e3b\u6d41\u7684\u7b97\u6cd5\u95ee\u9898\u3002\u521d\u6b21\u5237\u9898\u65f6\uff0c\u201c\u77e5\u8bc6\u9057\u5fd8\u201d\u53ef\u80fd\u662f\u4e00\u4e2a\u6311\u6218\uff0c\u4f46\u8bf7\u653e\u5fc3\uff0c\u8fd9\u662f\u5f88\u6b63\u5e38\u7684\u3002\u6211\u4eec\u53ef\u4ee5\u6309\u7167\u201c\u827e\u5bbe\u6d69\u65af\u9057\u5fd8\u66f2\u7ebf\u201d\u6765\u590d\u4e60\u9898\u76ee\uff0c\u901a\u5e38\u5728\u8fdb\u884c 3-5 \u8f6e\u7684\u91cd\u590d\u540e\uff0c\u5c31\u80fd\u5c06\u5176\u7262\u8bb0\u5728\u5fc3\u3002
    3. \u642d\u5efa\u77e5\u8bc6\u4f53\u7cfb\u3002\u5728\u5b66\u4e60\u65b9\u9762\uff0c\u6211\u4eec\u53ef\u4ee5\u9605\u8bfb\u7b97\u6cd5\u4e13\u680f\u6587\u7ae0\u3001\u89e3\u9898\u6846\u67b6\u548c\u7b97\u6cd5\u6559\u6750\uff0c\u4ee5\u4e0d\u65ad\u4e30\u5bcc\u77e5\u8bc6\u4f53\u7cfb\u3002\u5728\u5237\u9898\u65b9\u9762\uff0c\u53ef\u4ee5\u5c1d\u8bd5\u91c7\u7528\u8fdb\u9636\u5237\u9898\u7b56\u7565\uff0c\u5982\u6309\u4e13\u9898\u5206\u7c7b\u3001\u4e00\u9898\u591a\u89e3\u3001\u4e00\u89e3\u591a\u9898\u7b49\uff0c\u76f8\u5173\u7684\u5237\u9898\u5fc3\u5f97\u53ef\u4ee5\u5728\u5404\u4e2a\u793e\u533a\u627e\u5230\u3002

    \u4f5c\u4e3a\u4e00\u672c\u5165\u95e8\u6559\u7a0b\uff0c\u672c\u4e66\u5185\u5bb9\u4e3b\u8981\u6db5\u76d6\u201c\u7b2c\u4e00\u9636\u6bb5\u201d\uff0c\u65e8\u5728\u5e2e\u52a9\u4f60\u66f4\u9ad8\u6548\u5730\u5c55\u5f00\u7b2c\u4e8c\u548c\u7b2c\u4e09\u9636\u6bb5\u7684\u5b66\u4e60\u3002

    Fig. \u7b97\u6cd5\u5b66\u4e60\u8def\u7ebf

    "},{"location":"chapter_preface/summary/","title":"0.3. \u00a0 \u5c0f\u7ed3","text":"
    • \u672c\u4e66\u7684\u4e3b\u8981\u53d7\u4f17\u662f\u7b97\u6cd5\u521d\u5b66\u8005\u3002\u5982\u679c\u5df2\u6709\u4e00\u5b9a\u57fa\u7840\uff0c\u672c\u4e66\u80fd\u5e2e\u52a9\u60a8\u7cfb\u7edf\u56de\u987e\u7b97\u6cd5\u77e5\u8bc6\uff0c\u4e66\u5185\u6e90\u4ee3\u7801\u4e5f\u53ef\u4f5c\u4e3a\u201c\u5237\u9898\u5de5\u5177\u5e93\u201d\u4f7f\u7528\u3002
    • \u4e66\u4e2d\u5185\u5bb9\u4e3b\u8981\u5305\u62ec\u590d\u6742\u5ea6\u5206\u6790\u3001\u6570\u636e\u7ed3\u6784\u3001\u7b97\u6cd5\u4e09\u90e8\u5206\uff0c\u6db5\u76d6\u4e86\u8be5\u9886\u57df\u7684\u5927\u90e8\u5206\u4e3b\u9898\u3002
    • \u5bf9\u4e8e\u7b97\u6cd5\u65b0\u624b\uff0c\u5728\u521d\u5b66\u9636\u6bb5\u9605\u8bfb\u4e00\u672c\u5165\u95e8\u4e66\u7c4d\u81f3\u5173\u91cd\u8981\uff0c\u53ef\u4ee5\u5c11\u8d70\u8bb8\u591a\u5f2f\u8def\u3002
    • \u4e66\u5185\u7684\u52a8\u753b\u548c\u56fe\u89e3\u901a\u5e38\u7528\u4e8e\u4ecb\u7ecd\u91cd\u70b9\u548c\u96be\u70b9\u77e5\u8bc6\u3002\u9605\u8bfb\u672c\u4e66\u65f6\uff0c\u5e94\u7ed9\u4e88\u8fd9\u4e9b\u5185\u5bb9\u66f4\u591a\u5173\u6ce8\u3002
    • \u5b9e\u8df5\u4e43\u5b66\u4e60\u7f16\u7a0b\u4e4b\u6700\u4f73\u9014\u5f84\u3002\u5f3a\u70c8\u5efa\u8bae\u8fd0\u884c\u6e90\u4ee3\u7801\u5e76\u4eb2\u81ea\u6572\u6253\u4ee3\u7801\u3002
    • \u672c\u4e66\u7f51\u9875\u7248\u7684\u6bcf\u4e2a\u7ae0\u8282\u90fd\u8bbe\u6709\u8ba8\u8bba\u533a\uff0c\u6b22\u8fce\u968f\u65f6\u5206\u4eab\u4f60\u7684\u7591\u60d1\u4e0e\u89c1\u89e3\u3002
    "},{"location":"chapter_reference/","title":"\u53c2\u8003\u6587\u732e","text":"

    [1] Thomas H. Cormen, et al. Introduction to Algorithms (3rd Edition).

    [2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1st Edition).

    [3] \u4e25\u851a\u654f. \u6570\u636e\u7ed3\u6784\uff08C \u8bed\u8a00\u7248\uff09.

    [4] \u9093\u4fca\u8f89. \u6570\u636e\u7ed3\u6784\uff08C++ \u8bed\u8a00\u7248\uff0c\u7b2c\u4e09\u7248\uff09.

    [5] \u9a6c\u514b \u827e\u4f26 \u7ef4\u65af\u8457\uff0c\u9648\u8d8a\u8bd1. \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u5206\u6790\uff1aJava\u8bed\u8a00\u63cf\u8ff0\uff08\u7b2c\u4e09\u7248\uff09.

    [6] \u7a0b\u6770. \u5927\u8bdd\u6570\u636e\u7ed3\u6784.

    [7] \u738b\u4e89. \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u4e4b\u7f8e.

    [8] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6th Edition).

    [9] Aston Zhang, et al. Dive into Deep Learning.

    "},{"location":"chapter_searching/","title":"10. \u00a0 \u641c\u7d22","text":""},{"location":"chapter_searching/binary_search/","title":"10.1. \u00a0 \u4e8c\u5206\u67e5\u627e","text":"

    \u300c\u4e8c\u5206\u67e5\u627e Binary Search\u300d\u662f\u4e00\u79cd\u57fa\u4e8e\u5206\u6cbb\u601d\u60f3\u7684\u9ad8\u6548\u641c\u7d22\u7b97\u6cd5\u3002\u5b83\u5229\u7528\u6570\u636e\u7684\u6709\u5e8f\u6027\uff0c\u6bcf\u8f6e\u51cf\u5c11\u4e00\u534a\u641c\u7d22\u8303\u56f4\uff0c\u76f4\u81f3\u627e\u5230\u76ee\u6807\u5143\u7d20\u6216\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u4e3a\u6b62\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4 nums \uff0c\u5143\u7d20\u6309\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\u6392\u5217\uff0c\u6570\u7ec4\u4e0d\u5305\u542b\u91cd\u590d\u5143\u7d20\u3002\u8bf7\u67e5\u627e\u5e76\u8fd4\u56de\u5143\u7d20 target \u5728\u8be5\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15\u3002\u82e5\u6570\u7ec4\u4e0d\u5305\u542b\u8be5\u5143\u7d20\uff0c\u5219\u8fd4\u56de \\(-1\\) \u3002

    \u5bf9\u4e8e\u4e0a\u8ff0\u95ee\u9898\uff0c\u6211\u4eec\u5148\u521d\u59cb\u5316\u6307\u9488 \\(i = 0\\) \u548c \\(j = n - 1\\) \uff0c\u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u548c\u5c3e\u5143\u7d20\uff0c\u4ee3\u8868\u641c\u7d22\u533a\u95f4 \\([0, n - 1]\\) \u3002\u5176\u4e2d\uff0c\u4e2d\u62ec\u53f7\u8868\u793a\u201c\u95ed\u533a\u95f4\u201d\uff0c\u5373\u5305\u542b\u8fb9\u754c\u503c\u672c\u8eab\u3002

    \u63a5\u4e0b\u6765\uff0c\u5faa\u73af\u6267\u884c\u4ee5\u4e0b\u4e24\u4e2a\u6b65\u9aa4\uff1a

    1. \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 \\(m = \\lfloor {(i + j) / 2} \\rfloor\\) \uff0c\u5176\u4e2d \\(\\lfloor \\space \\rfloor\\) \u8868\u793a\u5411\u4e0b\u53d6\u6574\u64cd\u4f5c\u3002
    2. \u5224\u65ad nums[m] \u548c target \u7684\u5927\u5c0f\u5173\u7cfb\uff0c\u5206\u4e3a\u4e09\u79cd\u60c5\u51b5\uff1a
      1. \u5f53 nums[m] < target \u65f6\uff0c\u8bf4\u660e target \u5728\u533a\u95f4 \\([m + 1, j]\\) \u4e2d\uff0c\u56e0\u6b64\u6267\u884c \\(i = m + 1\\) \uff1b
      2. \u5f53 nums[m] > target \u65f6\uff0c\u8bf4\u660e target \u5728\u533a\u95f4 \\([i, m - 1]\\) \u4e2d\uff0c\u56e0\u6b64\u6267\u884c \\(j = m - 1\\) \uff1b
      3. \u5f53 nums[m] = target \u65f6\uff0c\u8bf4\u660e\u627e\u5230 target \uff0c\u56e0\u6b64\u8fd4\u56de\u7d22\u5f15 \\(m\\) \uff1b

    \u82e5\u6570\u7ec4\u4e0d\u5305\u542b\u76ee\u6807\u5143\u7d20\uff0c\u641c\u7d22\u533a\u95f4\u6700\u7ec8\u4f1a\u7f29\u5c0f\u4e3a\u7a7a\u3002\u6b64\u65f6\u8fd4\u56de \\(-1\\) \u3002

    <0><1><2><3><4><5><6><7>

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u7531\u4e8e \\(i\\) \u548c \\(j\\) \u90fd\u662f int \u7c7b\u578b\uff0c\u56e0\u6b64 \\(i + j\\) \u53ef\u80fd\u4f1a\u8d85\u51fa int \u7c7b\u578b\u7684\u53d6\u503c\u8303\u56f4\u3002\u4e3a\u4e86\u907f\u514d\u5927\u6570\u8d8a\u754c\uff0c\u6211\u4eec\u901a\u5e38\u91c7\u7528\u516c\u5f0f \\(m = \\lfloor {i + (j - i) / 2} \\rfloor\\) \u6765\u8ba1\u7b97\u4e2d\u70b9\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search.java
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nint binarySearch(int[] nums, int target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nint i = 0, j = nums.length - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.cpp
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nint binarySearch(vector<int> &nums, int target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nint i = 0, j = nums.size() - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.py
    def binary_search(nums: list[int], target: int) -> int:\n\"\"\"\u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09\"\"\"\n# \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\ni, j = 0, len(nums) - 1\n# \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile i <= j:\n# \u7406\u8bba\u4e0a Python \u7684\u6570\u5b57\u53ef\u4ee5\u65e0\u9650\u5927\uff08\u53d6\u51b3\u4e8e\u5185\u5b58\u5927\u5c0f\uff09\uff0c\u65e0\u9700\u8003\u8651\u5927\u6570\u8d8a\u754c\u95ee\u9898\nm = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target:\ni = m + 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelif nums[m] > target:\nj = m - 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse:\nreturn m  # \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n
    binary_search.go
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfunc binarySearch(nums []int, target int) int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\ni, j := 0, len(nums)-1\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nfor i <= j {\nm := i + (j-i)/2      // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1\n} else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1\n} else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\n
    binary_search.js
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfunction binarySearch(nums, target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nlet i = 0,\nj = nums.length - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m \uff0c\u4f7f\u7528 parseInt() \u5411\u4e0b\u53d6\u6574\nconst m = parseInt(i + (j - i) / 2);\nif (nums[m] < target)\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\nelse if (nums[m] > target)\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\nelse return m; // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.ts
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfunction binarySearch(nums: number[], target: number): number {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nlet i = 0,\nj = nums.length - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nconst m = Math.floor(i + (j - i) / 2);\nif (nums[m] < target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\n} else if (nums[m] > target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\n} else {\n// \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n}\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\n
    binary_search.c
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nint binarySearch(int *nums, int len, int target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nint i = 0, j = len - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.cs
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nint binarySearch(int[] nums, int target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nint i = 0, j = nums.Length - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nint m = i + (j - i) / 2;   // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\nelse                       // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.swift
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfunc binarySearch(nums: [Int], target: Int) -> Int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nvar i = 0\nvar j = nums.count - 1\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile i <= j {\nlet m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1\n} else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1\n} else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\n
    binary_search.zig
    // \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09\nfn binarySearch(comptime T: type, nums: std.ArrayList(T), target: T) T {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nvar i: usize = 0;\nvar j: usize = nums.items.len - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nvar m = i + (j - i) / 2;                // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums.items[m] < target) {           // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\n} else if (nums.items[m] > target) {    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\n} else {                                // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn @intCast(m);\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.dart
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nint binarySearch(List<int> nums, int target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nint i = 0, j = nums.length - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nint m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\n} else if (nums[m] > target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\n} else {\n// \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n

    \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u3002\u6bcf\u8f6e\u7f29\u5c0f\u4e00\u534a\u533a\u95f4\uff0c\u56e0\u6b64\u4e8c\u5206\u5faa\u73af\u6b21\u6570\u4e3a \\(\\log_2 n\\) \u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002\u6307\u9488 i , j \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7a7a\u95f4\u3002

    "},{"location":"chapter_searching/binary_search/#1011","title":"10.1.1. \u00a0 \u533a\u95f4\u8868\u793a\u65b9\u6cd5","text":"

    \u9664\u4e86\u4e0a\u8ff0\u7684\u53cc\u95ed\u533a\u95f4\u5916\uff0c\u5e38\u89c1\u7684\u533a\u95f4\u8868\u793a\u8fd8\u6709\u201c\u5de6\u95ed\u53f3\u5f00\u201d\u533a\u95f4\uff0c\u5b9a\u4e49\u4e3a \\([0, n)\\) \uff0c\u5373\u5de6\u8fb9\u754c\u5305\u542b\u81ea\u8eab\uff0c\u53f3\u8fb9\u754c\u4e0d\u5305\u542b\u81ea\u8eab\u3002\u5728\u8be5\u8868\u793a\u4e0b\uff0c\u533a\u95f4 \\([i, j]\\) \u5728 \\(i = j\\) \u65f6\u4e3a\u7a7a\u3002

    \u6211\u4eec\u53ef\u4ee5\u57fa\u4e8e\u8be5\u8868\u793a\u5b9e\u73b0\u5177\u6709\u76f8\u540c\u529f\u80fd\u7684\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search.java
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nint binarySearchLCRO(int[] nums, int target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nint i = 0, j = nums.length;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.cpp
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nint binarySearchLCRO(vector<int> &nums, int target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nint i = 0, j = nums.size();\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.py
    def binary_search_lcro(nums: list[int], target: int) -> int:\n\"\"\"\u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09\"\"\"\n# \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\ni, j = 0, len(nums)\n# \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile i < j:\nm = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target:\ni = m + 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\nelif nums[m] > target:\nj = m  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nelse:\nreturn m  # \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n
    binary_search.go
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nfunc binarySearchLCRO(nums []int, target int) int {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\ni, j := 0, len(nums)\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nfor i < j {\nm := i + (j-i)/2      // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1\n} else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m\n} else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\n
    binary_search.js
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nfunction binarySearchLCRO(nums, target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nlet i = 0,\nj = nums.length;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m \uff0c\u4f7f\u7528 parseInt() \u5411\u4e0b\u53d6\u6574\nconst m = parseInt(i + (j - i) / 2);\nif (nums[m] < target)\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\nelse if (nums[m] > target)\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\n// \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nelse return m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.ts
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nlet i = 0,\nj = nums.length;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nconst m = Math.floor(i + (j - i) / 2);\nif (nums[m] < target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\n} else if (nums[m] > target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\n} else {\n// \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n}\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\n
    binary_search.c
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nint binarySearchLCRO(int *nums, int len, int target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nint i = 0, j = len;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.cs
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nint binarySearchLCRO(int[] nums, int target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nint i = 0, j = nums.Length;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\nint m = i + (j - i) / 2;   // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\nelse                       // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.swift
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nfunc binarySearchLCRO(nums: [Int], target: Int) -> Int {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nvar i = 0\nvar j = nums.count\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile i < j {\nlet m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1\n} else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m\n} else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\n
    binary_search.zig
    // \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09\nfn binarySearchLCRO(comptime T: type, nums: std.ArrayList(T), target: T) T {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nvar i: usize = 0;\nvar j: usize = nums.items.len;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nvar m = i + (j - i) / 2;                // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums.items[m] < target) {           // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\n} else if (nums.items[m] > target) {    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\n} else {                                // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn @intCast(m);\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.dart
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nint binarySearchLCRO(List<int> nums, int target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nint i = 0, j = nums.length;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\nint m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\n} else if (nums[m] > target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\n} else {\n// \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5728\u4e24\u79cd\u533a\u95f4\u8868\u793a\u4e0b\uff0c\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u7684\u521d\u59cb\u5316\u3001\u5faa\u73af\u6761\u4ef6\u548c\u7f29\u5c0f\u533a\u95f4\u64cd\u4f5c\u7686\u6709\u6240\u4e0d\u540c\u3002

    \u5728\u201c\u53cc\u95ed\u533a\u95f4\u201d\u8868\u793a\u6cd5\u4e2d\uff0c\u7531\u4e8e\u5de6\u53f3\u8fb9\u754c\u90fd\u88ab\u5b9a\u4e49\u4e3a\u95ed\u533a\u95f4\uff0c\u56e0\u6b64\u6307\u9488 \\(i\\) \u548c \\(j\\) \u7f29\u5c0f\u533a\u95f4\u64cd\u4f5c\u4e5f\u662f\u5bf9\u79f0\u7684\u3002\u8fd9\u6837\u66f4\u4e0d\u5bb9\u6613\u51fa\u9519\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u901a\u5e38\u91c7\u7528\u201c\u53cc\u95ed\u533a\u95f4\u201d\u7684\u5199\u6cd5\u3002

    Fig. \u4e24\u79cd\u533a\u95f4\u5b9a\u4e49

    "},{"location":"chapter_searching/binary_search/#1012","title":"10.1.2. \u00a0 \u4f18\u70b9\u4e0e\u5c40\u9650\u6027","text":"

    \u4e8c\u5206\u67e5\u627e\u5728\u65f6\u95f4\u548c\u7a7a\u95f4\u65b9\u9762\u90fd\u6709\u8f83\u597d\u7684\u6027\u80fd\uff1a

    • \u4e8c\u5206\u67e5\u627e\u7684\u65f6\u95f4\u6548\u7387\u9ad8\u3002\u5728\u5927\u6570\u636e\u91cf\u4e0b\uff0c\u5bf9\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5177\u6709\u663e\u8457\u4f18\u52bf\u3002\u4f8b\u5982\uff0c\u5f53\u6570\u636e\u5927\u5c0f \\(n = 2^{20}\\) \u65f6\uff0c\u7ebf\u6027\u67e5\u627e\u9700\u8981 \\(2^{20} = 1048576\\) \u8f6e\u5faa\u73af\uff0c\u800c\u4e8c\u5206\u67e5\u627e\u4ec5\u9700 \\(\\log_2 2^{20} = 20\\) \u8f6e\u5faa\u73af\u3002
    • \u4e8c\u5206\u67e5\u627e\u65e0\u9700\u989d\u5916\u7a7a\u95f4\u3002\u76f8\u8f83\u4e8e\u9700\u8981\u501f\u52a9\u989d\u5916\u7a7a\u95f4\u7684\u641c\u7d22\u7b97\u6cd5\uff08\u4f8b\u5982\u54c8\u5e0c\u67e5\u627e\uff09\uff0c\u4e8c\u5206\u67e5\u627e\u66f4\u52a0\u8282\u7701\u7a7a\u95f4\u3002

    \u7136\u800c\uff0c\u4e8c\u5206\u67e5\u627e\u5e76\u975e\u9002\u7528\u4e8e\u6240\u6709\u60c5\u51b5\uff0c\u539f\u56e0\u5982\u4e0b\uff1a

    • \u4e8c\u5206\u67e5\u627e\u4ec5\u9002\u7528\u4e8e\u6709\u5e8f\u6570\u636e\u3002\u82e5\u8f93\u5165\u6570\u636e\u65e0\u5e8f\uff0c\u4e3a\u4e86\u4f7f\u7528\u4e8c\u5206\u67e5\u627e\u800c\u4e13\u95e8\u8fdb\u884c\u6392\u5e8f\uff0c\u5f97\u4e0d\u507f\u5931\u3002\u56e0\u4e3a\u6392\u5e8f\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u901a\u5e38\u4e3a \\(O(n \\log n)\\) \uff0c\u6bd4\u7ebf\u6027\u67e5\u627e\u548c\u4e8c\u5206\u67e5\u627e\u90fd\u66f4\u9ad8\u3002\u5bf9\u4e8e\u9891\u7e41\u63d2\u5165\u5143\u7d20\u7684\u573a\u666f\uff0c\u4e3a\u4fdd\u6301\u6570\u7ec4\u6709\u5e8f\u6027\uff0c\u9700\u8981\u5c06\u5143\u7d20\u63d2\u5165\u5230\u7279\u5b9a\u4f4d\u7f6e\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u4e5f\u662f\u975e\u5e38\u6602\u8d35\u7684\u3002
    • \u4e8c\u5206\u67e5\u627e\u4ec5\u9002\u7528\u4e8e\u6570\u7ec4\u3002\u4e8c\u5206\u67e5\u627e\u9700\u8981\u8df3\u8dc3\u5f0f\uff08\u975e\u8fde\u7eed\u5730\uff09\u8bbf\u95ee\u5143\u7d20\uff0c\u800c\u5728\u94fe\u8868\u4e2d\u6267\u884c\u8df3\u8dc3\u5f0f\u8bbf\u95ee\u7684\u6548\u7387\u8f83\u4f4e\uff0c\u56e0\u6b64\u4e0d\u9002\u5408\u5e94\u7528\u5728\u94fe\u8868\u6216\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u3002
    • \u5c0f\u6570\u636e\u91cf\u4e0b\uff0c\u7ebf\u6027\u67e5\u627e\u6027\u80fd\u66f4\u4f73\u3002\u5728\u7ebf\u6027\u67e5\u627e\u4e2d\uff0c\u6bcf\u8f6e\u53ea\u9700\u8981 1 \u6b21\u5224\u65ad\u64cd\u4f5c\uff1b\u800c\u5728\u4e8c\u5206\u67e5\u627e\u4e2d\uff0c\u9700\u8981 1 \u6b21\u52a0\u6cd5\u30011 \u6b21\u9664\u6cd5\u30011 ~ 3 \u6b21\u5224\u65ad\u64cd\u4f5c\u30011 \u6b21\u52a0\u6cd5\uff08\u51cf\u6cd5\uff09\uff0c\u5171 4 ~ 6 \u4e2a\u5355\u5143\u64cd\u4f5c\uff1b\u56e0\u6b64\uff0c\u5f53\u6570\u636e\u91cf \\(n\\) \u8f83\u5c0f\u65f6\uff0c\u7ebf\u6027\u67e5\u627e\u53cd\u800c\u6bd4\u4e8c\u5206\u67e5\u627e\u66f4\u5feb\u3002
    "},{"location":"chapter_searching/binary_search_edge/","title":"10.2. \u00a0 \u4e8c\u5206\u67e5\u627e\u8fb9\u754c","text":"

    \u5728\u4e0a\u4e00\u8282\u4e2d\uff0c\u9898\u76ee\u89c4\u5b9a\u6570\u7ec4\u4e2d\u6240\u6709\u5143\u7d20\u90fd\u662f\u552f\u4e00\u7684\u3002\u5982\u679c\u76ee\u6807\u5143\u7d20\u5728\u6570\u7ec4\u4e2d\u591a\u6b21\u51fa\u73b0\uff0c\u4e0a\u8282\u4ecb\u7ecd\u7684\u65b9\u6cd5\u53ea\u80fd\u4fdd\u8bc1\u8fd4\u56de\u5176\u4e2d\u4e00\u4e2a\u76ee\u6807\u5143\u7d20\u7684\u7d22\u5f15\uff0c\u800c\u65e0\u6cd5\u786e\u5b9a\u8be5\u7d22\u5f15\u7684\u5de6\u8fb9\u548c\u53f3\u8fb9\u8fd8\u6709\u591a\u5c11\u76ee\u6807\u5143\u7d20\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6709\u5e8f\u6570\u7ec4 nums \uff0c\u6570\u7ec4\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\u3002\u8bf7\u67e5\u627e\u5e76\u8fd4\u56de\u5143\u7d20 target \u5728\u6570\u7ec4\u4e2d\u9996\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\u3002\u82e5\u6570\u7ec4\u4e2d\u4e0d\u5305\u542b\u8be5\u5143\u7d20\uff0c\u5219\u8fd4\u56de \\(-1\\) \u3002

    "},{"location":"chapter_searching/binary_search_edge/#1021","title":"10.2.1. \u00a0 \u7ebf\u6027\u65b9\u6cd5","text":"

    \u4e3a\u4e86\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5de6\u8fb9\u7684 target \uff0c\u6211\u4eec\u53ef\u4ee5\u5206\u4e3a\u4e24\u6b65\uff1a

    1. \u8fdb\u884c\u4e8c\u5206\u67e5\u627e\uff0c\u5b9a\u4f4d\u5230\u4efb\u610f\u4e00\u4e2a target \u7684\u7d22\u5f15\uff0c\u8bb0\u4e3a \\(k\\) \uff1b
    2. \u4ee5\u7d22\u5f15 \\(k\\) \u4e3a\u8d77\u59cb\u70b9\uff0c\u5411\u5de6\u8fdb\u884c\u7ebf\u6027\u904d\u5386\uff0c\u627e\u5230\u6700\u5de6\u8fb9\u7684 target \u8fd4\u56de\u5373\u53ef\u3002

    Fig. \u7ebf\u6027\u67e5\u627e\u6700\u5de6\u8fb9\u7684\u5143\u7d20

    \u8fd9\u4e2a\u65b9\u6cd5\u867d\u7136\u6709\u6548\uff0c\u4f46\u7531\u4e8e\u5305\u542b\u7ebf\u6027\u67e5\u627e\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u5f53\u5b58\u5728\u5f88\u591a\u91cd\u590d\u7684 target \u65f6\u6548\u7387\u8f83\u4f4e\u3002

    "},{"location":"chapter_searching/binary_search_edge/#1022","title":"10.2.2. \u00a0 \u4e8c\u5206\u65b9\u6cd5","text":"

    \u8003\u8651\u4ec5\u4f7f\u7528\u4e8c\u5206\u67e5\u627e\u89e3\u51b3\u8be5\u95ee\u9898\u3002\u6574\u4f53\u7b97\u6cd5\u6d41\u7a0b\u4e0d\u53d8\uff0c\u5148\u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 \\(m\\) \uff0c\u518d\u5224\u65ad target \u548c nums[m] \u5927\u5c0f\u5173\u7cfb\uff1a

    • \u5f53 nums[m] < target \u6216 nums[m] > target \u65f6\uff0c\u8bf4\u660e\u8fd8\u6ca1\u6709\u627e\u5230 target \uff0c\u56e0\u6b64\u91c7\u53d6\u4e0e\u4e0a\u8282\u4ee3\u7801\u76f8\u540c\u7684\u7f29\u5c0f\u533a\u95f4\u64cd\u4f5c\uff0c\u4ece\u800c\u4f7f\u6307\u9488 \\(i\\) \u548c \\(j\\) \u5411 target \u9760\u8fd1\u3002
    • \u5f53 nums[m] == target \u65f6\uff0c\u8bf4\u660e\u201c\u5c0f\u4e8e target \u7684\u5143\u7d20\u201d\u5728\u533a\u95f4 \\([i, m - 1]\\) \u4e2d\uff0c\u56e0\u6b64\u91c7\u7528 \\(j = m - 1\\) \u6765\u7f29\u5c0f\u533a\u95f4\uff0c\u4ece\u800c\u4f7f\u6307\u9488 \\(j\\) \u5411\u5c0f\u4e8e target \u7684\u5143\u7d20\u9760\u8fd1\u3002

    \u4e8c\u5206\u67e5\u627e\u5b8c\u6210\u540e\uff0c\\(i\\) \u6307\u5411\u6700\u5de6\u8fb9\u7684 target \uff0c\\(j\\) \u6307\u5411\u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\uff0c\u56e0\u6b64\u8fd4\u56de\u7d22\u5f15 \\(i\\) \u5373\u53ef\u3002

    <1><2><3><4><5><6><7><8>

    \u6ce8\u610f\uff0c\u6570\u7ec4\u53ef\u80fd\u4e0d\u5305\u542b\u76ee\u6807\u5143\u7d20 target \u3002\u56e0\u6b64\u5728\u51fd\u6570\u8fd4\u56de\u524d\uff0c\u6211\u4eec\u9700\u8981\u5148\u5224\u65ad nums[i] \u4e0e target \u662f\u5426\u76f8\u7b49\uff0c\u4ee5\u53ca\u7d22\u5f15 \\(i\\) \u662f\u5426\u8d8a\u754c\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search_edge.java
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchLeftEdge(int[] nums, int target) {\nint i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\nif (i == nums.length || nums[i] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i;\n}\n
    binary_search_edge.cpp
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchLeftEdge(vector<int> &nums, int target) {\nint i = 0, j = nums.size() - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\nif (i == nums.size() || nums[i] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i;\n}\n
    binary_search_edge.py
    def binary_search_left_edge(nums: list[int], target: int) -> int:\n\"\"\"\u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20\"\"\"\ni, j = 0, len(nums) - 1  # \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile i <= j:\nm = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target:\ni = m + 1  # target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelif nums[m] > target:\nj = m - 1  # target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse:\nj = m - 1  # \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\nif i == len(nums) or nums[i] != target:\nreturn -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i\n
    binary_search_edge.go
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\ni, j := 0, len(nums)-1\nfor i <= j {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nm := i + (j-i)/2\nif nums[m] < target {\n// target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1\n} else if nums[m] > target {\n// target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1\n} else {\n// \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1\n}\n}\nif i == len(nums) || nums[i] != target {\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\nreturn i\n}\n
    binary_search_edge.js
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nfunction binarySearchLeftEdge(nums, target) {\nlet i = 0,\nj = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nlet m = Math.floor((i + j) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if (nums[m] > target) {\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\n}\nif (i == nums.length || nums[i] != target) {\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn i;\n}\n
    binary_search_edge.ts
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nfunction binarySearchLeftEdge(nums: number[], target: number): number {\nlet i = 0, j = nums.length - 1;  // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nlet m = Math.floor((i + j) / 2);  // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\ni = m + 1;  // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if (nums[m] > target) {\nj = m - 1;  // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\nj = m - 1;  // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\n}\nif (i == nums.length || nums[i] != target) {\nreturn -1;  // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn i;\n}\n
    binary_search_edge.c
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchLeftEdge(int *nums, int size, int target) {\nint i = 0, j = size - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\nif (i == size || nums[i] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i;\n}\n
    binary_search_edge.cs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchLeftEdge(int[] nums, int target) {\nint i = 0, j = nums.Length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\nif (i == nums.Length || nums[i] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i;\n}\n
    binary_search_edge.swift
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -> Int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nvar i = 0\nvar j = nums.count - 1\nwhile i <= j {\nlet m = i + (j - 1) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target {\ni = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if nums[m] > target {\nj = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\nj = m - 1 // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\n}\nif i == nums.count || nums[i] != target {\nreturn -1 // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn i\n}\n
    binary_search_edge.zig
    [class]{}-[func]{binarySearchLeftEdge}\n
    binary_search_edge.dart
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchLeftEdge(List<int> nums, int target) {\nint i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u95f4\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\nif (i == nums.length || nums[i] != target) return -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i;\n}\n
    "},{"location":"chapter_searching/binary_search_edge/#1023","title":"10.2.3. \u00a0 \u67e5\u627e\u53f3\u8fb9\u754c","text":"

    \u7c7b\u4f3c\u5730\uff0c\u6211\u4eec\u4e5f\u53ef\u4ee5\u4e8c\u5206\u67e5\u627e\u6700\u53f3\u8fb9\u7684 target \u3002\u5f53 nums[m] == target \u65f6\uff0c\u8bf4\u660e\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 \\([m + 1, j]\\) \u4e2d\uff0c\u56e0\u6b64\u6267\u884c i = m + 1 \uff0c\u4f7f\u5f97\u6307\u9488 \\(i\\) \u5411\u5927\u4e8e target \u7684\u5143\u7d20\u9760\u8fd1\u3002

    \u5b8c\u6210\u4e8c\u5206\u540e\uff0c\\(i\\) \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\uff0c\\(j\\) \u6307\u5411\u6700\u53f3\u8fb9\u7684 target \uff0c\u56e0\u6b64\u8fd4\u56de\u7d22\u5f15 \\(j\\) \u5373\u53ef\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search_edge.java
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchRightEdge(int[] nums, int target) {\nint i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\nif (j < 0 || nums[j] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j;\n}\n
    binary_search_edge.cpp
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchRightEdge(vector<int> &nums, int target) {\nint i = 0, j = nums.size() - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\nif (j < 0 || nums[j] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j;\n}\n
    binary_search_edge.py
    def binary_search_right_edge(nums: list[int], target: int) -> int:\n\"\"\"\u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20\"\"\"\ni, j = 0, len(nums) - 1  # \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile i <= j:\nm = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target:\ni = m + 1  # target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelif nums[m] > target:\nj = m - 1  # target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse:\ni = m + 1  # \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\nif j < 0 or nums[j] != target:\nreturn -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j\n
    binary_search_edge.go
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nfunc binarySearchRightEdge(nums []int, target int) int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\ni, j := 0, len(nums)-1\nfor i <= j {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nm := i + (j-i)/2\nif nums[m] < target {\n// target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1\n} else if nums[m] > target {\n// target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1\n} else {\n// \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1\n}\n}\nif j < 0 || nums[j] != target {\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\nreturn j\n}\n
    binary_search_edge.js
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nfunction binarySearchRightEdge(nums, target) {\nlet i = 0,\nj = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nlet m = Math.floor((i + j) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if (nums[m] > target) {\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\n}\nif (j < 0 || nums[j] != target) {\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn j;\n}\n
    binary_search_edge.ts
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nfunction binarySearchRightEdge(nums: number[], target: number): number {\nlet i = 0, j = nums.length - 1;  // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nlet m = Math.floor((i + j) / 2);  // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\ni = m + 1;  // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if (nums[m] > target) {\nj = m - 1;  // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\ni = m + 1;  // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\n}\nif (j < 0 || nums[j] != target) {\nreturn -1;  // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn j;\n}\n
    binary_search_edge.c
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchRightEdge(int *nums, int size, int target) {\nint i = 0, j = size - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\nif (j < 0 || nums[j] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j;\n}\n
    binary_search_edge.cs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchRightEdge(int[] nums, int target) {\nint i = 0, j = nums.Length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\nif (j < 0 || nums[j] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j;\n}\n
    binary_search_edge.swift
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -> Int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nvar i = 0\nvar j = nums.count - 1\nwhile i <= j {\nlet m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target {\ni = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if nums[m] > target {\nj = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\ni = m + 1 // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\n}\nif j < 0 || nums[j] != target {\nreturn -1 // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn j\n}\n
    binary_search_edge.zig
    [class]{}-[func]{binarySearchRightEdge}\n
    binary_search_edge.dart
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchRightEdge(List<int> nums, int target) {\nint i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u95f4\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\nif (j < 0 || nums[j] != target) return -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j;\n}\n

    \u89c2\u5bdf\u4e0b\u56fe\uff0c\u641c\u7d22\u6700\u53f3\u8fb9\u5143\u7d20\u65f6\u6307\u9488 \\(j\\) \u7684\u4f5c\u7528\u4e0e\u641c\u7d22\u6700\u5de6\u8fb9\u5143\u7d20\u65f6\u6307\u9488 \\(i\\) \u7684\u4f5c\u7528\u4e00\u81f4\uff0c\u53cd\u4e4b\u4ea6\u7136\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u641c\u7d22\u6700\u5de6\u8fb9\u5143\u7d20\u548c\u6700\u53f3\u8fb9\u5143\u7d20\u7684\u5b9e\u73b0\u662f\u955c\u50cf\u5bf9\u79f0\u7684\u3002

    Fig. \u67e5\u627e\u6700\u5de6\u8fb9\u548c\u6700\u53f3\u8fb9\u5143\u7d20\u7684\u5bf9\u79f0\u6027

    Tip

    \u4ee5\u4e0a\u4ee3\u7801\u91c7\u53d6\u7684\u90fd\u662f\u201c\u53cc\u95ed\u533a\u95f4\u201d\u5199\u6cd5\u3002\u6709\u5174\u8da3\u7684\u8bfb\u8005\u53ef\u4ee5\u81ea\u884c\u5b9e\u73b0\u201c\u5de6\u95ed\u53f3\u5f00\u201d\u5199\u6cd5\u3002

    "},{"location":"chapter_searching/replace_linear_by_hashing/","title":"10.3. \u00a0 \u54c8\u5e0c\u4f18\u5316\u7b56\u7565","text":"

    \u5728\u7b97\u6cd5\u9898\u4e2d\uff0c\u6211\u4eec\u5e38\u901a\u8fc7\u5c06\u7ebf\u6027\u67e5\u627e\u66ff\u6362\u4e3a\u54c8\u5e0c\u67e5\u627e\u6765\u964d\u4f4e\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u3002\u6211\u4eec\u501f\u52a9\u4e00\u4e2a\u7b97\u6cd5\u9898\u6765\u52a0\u6df1\u7406\u89e3\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u6574\u6570\u6570\u7ec4 nums \u548c\u4e00\u4e2a\u76ee\u6807\u5143\u7d20 target \uff0c\u8bf7\u5728\u6570\u7ec4\u4e2d\u641c\u7d22\u201c\u548c\u201d\u4e3a target \u7684\u4e24\u4e2a\u5143\u7d20\uff0c\u5e76\u8fd4\u56de\u5b83\u4eec\u7684\u6570\u7ec4\u7d22\u5f15\u3002\u8fd4\u56de\u4efb\u610f\u4e00\u4e2a\u89e3\u5373\u53ef\u3002

    "},{"location":"chapter_searching/replace_linear_by_hashing/#1031","title":"10.3.1. \u00a0 \u7ebf\u6027\u67e5\u627e\uff1a\u4ee5\u65f6\u95f4\u6362\u7a7a\u95f4","text":"

    \u8003\u8651\u76f4\u63a5\u904d\u5386\u6240\u6709\u53ef\u80fd\u7684\u7ec4\u5408\u3002\u5f00\u542f\u4e00\u4e2a\u4e24\u5c42\u5faa\u73af\uff0c\u5728\u6bcf\u8f6e\u4e2d\u5224\u65ad\u4e24\u4e2a\u6574\u6570\u7684\u548c\u662f\u5426\u4e3a target \uff0c\u82e5\u662f\uff0c\u5219\u8fd4\u56de\u5b83\u4eec\u7684\u7d22\u5f15\u3002

    Fig. \u7ebf\u6027\u67e5\u627e\u6c42\u89e3\u4e24\u6570\u4e4b\u548c

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart two_sum.java
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint[] twoSumBruteForce(int[] nums, int target) {\nint size = nums.length;\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor (int i = 0; i < size - 1; i++) {\nfor (int j = i + 1; j < size; j++) {\nif (nums[i] + nums[j] == target)\nreturn new int[] { i, j };\n}\n}\nreturn new int[0];\n}\n
    two_sum.cpp
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nvector<int> twoSumBruteForce(vector<int> &nums, int target) {\nint size = nums.size();\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor (int i = 0; i < size - 1; i++) {\nfor (int j = i + 1; j < size; j++) {\nif (nums[i] + nums[j] == target)\nreturn {i, j};\n}\n}\nreturn {};\n}\n
    two_sum.py
    def two_sum_brute_force(nums: list[int], target: int) -> list[int]:\n\"\"\"\u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e\"\"\"\n# \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor i in range(len(nums) - 1):\nfor j in range(i + 1, len(nums)):\nif nums[i] + nums[j] == target:\nreturn [i, j]\nreturn []\n
    two_sum.go
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunc twoSumBruteForce(nums []int, target int) []int {\nsize := len(nums)\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor i := 0; i < size-1; i++ {\nfor j := i + 1; i < size; j++ {\nif nums[i]+nums[j] == target {\nreturn []int{i, j}\n}\n}\n}\nreturn nil\n}\n
    two_sum.js
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunction twoSumBruteForce(nums, target) {\nconst n = nums.length;\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor (let i = 0; i < n; i++) {\nfor (let j = i + 1; j < n; j++) {\nif (nums[i] + nums[j] === target) {\nreturn [i, j];\n}\n}\n}\nreturn [];\n}\n
    two_sum.ts
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\nconst n = nums.length;\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor (let i = 0; i < n; i++) {\nfor (let j = i + 1; j < n; j++) {\nif (nums[i] + nums[j] === target) {\nreturn [i, j];\n}\n}\n}\nreturn [];\n}\n
    two_sum.c
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\nfor (int i = 0; i < numsSize; ++i) {\nfor (int j = i + 1; j < numsSize; ++j) {\nif (nums[i] + nums[j] == target) {\nint *res = malloc(sizeof(int) * 2);\nres[0] = i, res[1] = j;\n*returnSize = 2;\nreturn res;\n}\n}\n}\n*returnSize = 0;\nreturn NULL;\n}\n
    two_sum.cs
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint[] twoSumBruteForce(int[] nums, int target) {\nint size = nums.Length;\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor (int i = 0; i < size - 1; i++) {\nfor (int j = i + 1; j < size; j++) {\nif (nums[i] + nums[j] == target)\nreturn new int[] { i, j };\n}\n}\nreturn new int[0];\n}\n
    two_sum.swift
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunc twoSumBruteForce(nums: [Int], target: Int) -> [Int] {\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor i in nums.indices.dropLast() {\nfor j in nums.indices.dropFirst(i + 1) {\nif nums[i] + nums[j] == target {\nreturn [i, j]\n}\n}\n}\nreturn [0]\n}\n
    two_sum.zig
    // \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e\nfn twoSumBruteForce(nums: []i32, target: i32) ?[2]i32 {\nvar size: usize = nums.len;\nvar i: usize = 0;\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nwhile (i < size - 1) : (i += 1) {\nvar j = i + 1;\nwhile (j < size) : (j += 1) {\nif (nums[i] + nums[j] == target) {\nreturn [_]i32{@intCast(i), @intCast(j)};\n}\n}\n}\nreturn null;\n}\n
    two_sum.dart
    /* \u65b9\u6cd5\u4e00\uff1a \u66b4\u529b\u679a\u4e3e */\nList<int> twoSumBruteForce(List<int> nums, int target) {\nint size = nums.length;\nfor (var i = 0; i < size - 1; i++) {\nfor (var j = i + 1; j < size; j++) {\nif (nums[i] + nums[j] == target) return [i, j];\n}\n}\nreturn [0];\n}\n

    \u6b64\u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \uff0c\u5728\u5927\u6570\u636e\u91cf\u4e0b\u975e\u5e38\u8017\u65f6\u3002

    "},{"location":"chapter_searching/replace_linear_by_hashing/#1032","title":"10.3.2. \u00a0 \u54c8\u5e0c\u67e5\u627e\uff1a\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4","text":"

    \u8003\u8651\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868\uff0c\u952e\u503c\u5bf9\u5206\u522b\u4e3a\u6570\u7ec4\u5143\u7d20\u548c\u5143\u7d20\u7d22\u5f15\u3002\u5faa\u73af\u904d\u5386\u6570\u7ec4\uff0c\u6bcf\u8f6e\u6267\u884c\uff1a

    1. \u5224\u65ad\u6570\u5b57 target - nums[i] \u662f\u5426\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u82e5\u662f\u5219\u76f4\u63a5\u8fd4\u56de\u8fd9\u4e24\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\uff1b
    2. \u5c06\u952e\u503c\u5bf9 nums[i] \u548c\u7d22\u5f15 i \u6dfb\u52a0\u8fdb\u54c8\u5e0c\u8868\uff1b
    <1><2><3>

    \u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff0c\u4ec5\u9700\u5355\u5c42\u5faa\u73af\u5373\u53ef\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart two_sum.java
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint[] twoSumHashTable(int[] nums, int target) {\nint size = nums.length;\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nMap<Integer, Integer> dic = new HashMap<>();\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor (int i = 0; i < size; i++) {\nif (dic.containsKey(target - nums[i])) {\nreturn new int[] { dic.get(target - nums[i]), i };\n}\ndic.put(nums[i], i);\n}\nreturn new int[0];\n}\n
    two_sum.cpp
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nvector<int> twoSumHashTable(vector<int> &nums, int target) {\nint size = nums.size();\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nunordered_map<int, int> dic;\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor (int i = 0; i < size; i++) {\nif (dic.find(target - nums[i]) != dic.end()) {\nreturn {dic[target - nums[i]], i};\n}\ndic.emplace(nums[i], i);\n}\nreturn {};\n}\n
    two_sum.py
    def two_sum_hash_table(nums: list[int], target: int) -> list[int]:\n\"\"\"\u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868\"\"\"\n# \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\ndic = {}\n# \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor i in range(len(nums)):\nif target - nums[i] in dic:\nreturn [dic[target - nums[i]], i]\ndic[nums[i]] = i\nreturn []\n
    two_sum.go
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nfunc twoSumHashTable(nums []int, target int) []int {\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nhashTable := map[int]int{}\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor idx, val := range nums {\nif preIdx, ok := hashTable[target-val]; ok {\nreturn []int{preIdx, idx}\n}\nhashTable[val] = idx\n}\nreturn nil\n}\n
    two_sum.js
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nfunction twoSumHashTable(nums, target) {\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nlet m = {};\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor (let i = 0; i < nums.length; i++) {\nif (m[target - nums[i]] !== undefined) {\nreturn [m[target-nums[i]], i];\n} else {\nm[nums[i]] = i;\n}\n}\nreturn [];\n}\n
    two_sum.ts
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nfunction twoSumHashTable(nums: number[], target: number): number[] {\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nlet m: Map<number, number> = new Map();\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor (let i = 0; i < nums.length; i++) {\nlet index = m.get(target - nums[i]);\nif (index !== undefined) {\nreturn [index, i];\n} else {\nm.set(nums[i], i);\n}\n}\nreturn [];\n}\n
    two_sum.c
    /* \u54c8\u5e0c\u8868 */\nstruct hashTable {\nint key;\nint val;\nUT_hash_handle hh; // \u57fa\u4e8e uthash.h \u5b9e\u73b0\n};\ntypedef struct hashTable hashTable;\n/* \u54c8\u5e0c\u8868\u67e5\u8be2 */\nhashTable *find(hashTable *h, int key) {\nhashTable *tmp;\nHASH_FIND_INT(h, &key, tmp);\nreturn tmp;\n}\n/* \u54c8\u5e0c\u8868\u5143\u7d20\u63d2\u5165 */\nvoid insert(hashTable *h, int key, int val) {\nhashTable *t = find(h, key);\nif (t == NULL) {\nhashTable *tmp = malloc(sizeof(hashTable));\ntmp->key = key, tmp->val = val;\nHASH_ADD_INT(h, key, tmp);\n} else {\nt->val = val;\n}\n}\n/* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\nhashTable *hashtable = NULL;\nfor (int i = 0; i < numsSize; i++) {\nhashTable *t = find(hashtable, target - nums[i]);\nif (t != NULL) {\nint *res = malloc(sizeof(int) * 2);\nres[0] = t->val, res[1] = i;\n*returnSize = 2;\nreturn res;\n}\ninsert(hashtable, nums[i], i);\n}\n*returnSize = 0;\nreturn NULL;\n}\n
    two_sum.cs
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint[] twoSumHashTable(int[] nums, int target) {\nint size = nums.Length;\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nDictionary<int, int> dic = new();\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor (int i = 0; i < size; i++) {\nif (dic.ContainsKey(target - nums[i])) {\nreturn new int[] { dic[target - nums[i]], i };\n}\ndic.Add(nums[i], i);\n}\nreturn new int[0];\n}\n
    two_sum.swift
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nfunc twoSumHashTable(nums: [Int], target: Int) -> [Int] {\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nvar dic: [Int: Int] = [:]\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor i in nums.indices {\nif let j = dic[target - nums[i]] {\nreturn [j, i]\n}\ndic[nums[i]] = i\n}\nreturn [0]\n}\n
    two_sum.zig
    // \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868\nfn twoSumHashTable(nums: []i32, target: i32) !?[2]i32 {\nvar size: usize = nums.len;\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nvar dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);\ndefer dic.deinit();\nvar i: usize = 0;\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nwhile (i < size) : (i += 1) {\nif (dic.contains(target - nums[i])) {\nreturn [_]i32{dic.get(target - nums[i]).?, @intCast(i)};\n}\ntry dic.put(nums[i], @intCast(i));\n}\nreturn null;\n}\n
    two_sum.dart
    /* \u65b9\u6cd5\u4e8c\uff1a \u8f85\u52a9\u54c8\u5e0c\u8868 */\nList<int> twoSumHashTable(List<int> nums, int target) {\nint size = nums.length;\nMap<int, int> dic = HashMap();\nfor (var i = 0; i < size; i++) {\nif (dic.containsKey(target - nums[i])) {\nreturn [dic[target - nums[i]]!, i];\n}\ndic.putIfAbsent(nums[i], () => i);\n}\nreturn [0];\n}\n

    \u6b64\u65b9\u6cd5\u901a\u8fc7\u54c8\u5e0c\u67e5\u627e\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n^2)\\) \u964d\u4f4e\u81f3 \\(O(n)\\) \uff0c\u5927\u5e45\u63d0\u5347\u8fd0\u884c\u6548\u7387\u3002

    \u7531\u4e8e\u9700\u8981\u7ef4\u62a4\u4e00\u4e2a\u989d\u5916\u7684\u54c8\u5e0c\u8868\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002\u5c3d\u7ba1\u5982\u6b64\uff0c\u8be5\u65b9\u6cd5\u7684\u6574\u4f53\u65f6\u7a7a\u6548\u7387\u66f4\u4e3a\u5747\u8861\uff0c\u56e0\u6b64\u5b83\u662f\u672c\u9898\u7684\u6700\u4f18\u89e3\u6cd5\u3002

    "},{"location":"chapter_searching/searching_algorithm_revisited/","title":"10.4. \u00a0 \u91cd\u8bc6\u641c\u7d22\u7b97\u6cd5","text":"

    \u300c\u641c\u7d22\u7b97\u6cd5 Searching Algorithm\u300d\u7528\u4e8e\u5728\u6570\u636e\u7ed3\u6784\uff08\u4f8b\u5982\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6811\u6216\u56fe\uff09\u4e2d\u641c\u7d22\u4e00\u4e2a\u6216\u4e00\u7ec4\u6ee1\u8db3\u7279\u5b9a\u6761\u4ef6\u7684\u5143\u7d20\u3002

    \u6839\u636e\u5b9e\u73b0\u601d\u8def\uff0c\u641c\u7d22\u7b97\u6cd5\u603b\u4f53\u53ef\u5206\u4e3a\u4e24\u79cd\uff1a

    • \u901a\u8fc7\u904d\u5386\u6570\u636e\u7ed3\u6784\u6765\u5b9a\u4f4d\u76ee\u6807\u5143\u7d20\uff0c\u4f8b\u5982\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6811\u548c\u56fe\u7684\u904d\u5386\u7b49\u3002
    • \u5229\u7528\u6570\u636e\u7ec4\u7ec7\u7ed3\u6784\u6216\u6570\u636e\u5305\u542b\u7684\u5148\u9a8c\u4fe1\u606f\uff0c\u5b9e\u73b0\u9ad8\u6548\u5143\u7d20\u67e5\u627e\uff0c\u4f8b\u5982\u4e8c\u5206\u67e5\u627e\u3001\u54c8\u5e0c\u67e5\u627e\u548c\u4e8c\u53c9\u641c\u7d22\u6811\u67e5\u627e\u7b49\u3002

    \u4e0d\u96be\u53d1\u73b0\uff0c\u8fd9\u4e9b\u77e5\u8bc6\u70b9\u90fd\u5df2\u5728\u524d\u9762\u7684\u7ae0\u8282\u4e2d\u4ecb\u7ecd\u8fc7\uff0c\u56e0\u6b64\u641c\u7d22\u7b97\u6cd5\u5bf9\u4e8e\u6211\u4eec\u6765\u8bf4\u5e76\u4e0d\u964c\u751f\u3002\u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u5c06\u4ece\u66f4\u52a0\u7cfb\u7edf\u7684\u89c6\u89d2\u5207\u5165\uff0c\u91cd\u65b0\u5ba1\u89c6\u641c\u7d22\u7b97\u6cd5\u3002

    "},{"location":"chapter_searching/searching_algorithm_revisited/#1041","title":"10.4.1. \u00a0 \u66b4\u529b\u641c\u7d22","text":"

    \u66b4\u529b\u641c\u7d22\u901a\u8fc7\u904d\u5386\u6570\u636e\u7ed3\u6784\u7684\u6bcf\u4e2a\u5143\u7d20\u6765\u5b9a\u4f4d\u76ee\u6807\u5143\u7d20\u3002

    • \u300c\u7ebf\u6027\u641c\u7d22\u300d\u9002\u7528\u4e8e\u6570\u7ec4\u548c\u94fe\u8868\u7b49\u7ebf\u6027\u6570\u636e\u7ed3\u6784\u3002\u5b83\u4ece\u6570\u636e\u7ed3\u6784\u7684\u4e00\u7aef\u5f00\u59cb\uff0c\u9010\u4e2a\u8bbf\u95ee\u5143\u7d20\uff0c\u76f4\u5230\u627e\u5230\u76ee\u6807\u5143\u7d20\u6216\u5230\u8fbe\u53e6\u4e00\u7aef\u4ecd\u6ca1\u6709\u627e\u5230\u76ee\u6807\u5143\u7d20\u4e3a\u6b62\u3002
    • \u300c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22\u300d\u548c\u300c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u300d\u662f\u56fe\u548c\u6811\u7684\u4e24\u79cd\u904d\u5386\u7b56\u7565\u3002\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22\u4ece\u521d\u59cb\u8282\u70b9\u5f00\u59cb\u9010\u5c42\u641c\u7d22\uff0c\u7531\u8fd1\u53ca\u8fdc\u5730\u8bbf\u95ee\u5404\u4e2a\u8282\u70b9\u3002\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u662f\u4ece\u521d\u59cb\u8282\u70b9\u5f00\u59cb\uff0c\u6cbf\u7740\u4e00\u6761\u8def\u5f84\u8d70\u5230\u5934\u4e3a\u6b62\uff0c\u518d\u56de\u6eaf\u5e76\u5c1d\u8bd5\u5176\u4ed6\u8def\u5f84\uff0c\u76f4\u5230\u904d\u5386\u5b8c\u6574\u4e2a\u6570\u636e\u7ed3\u6784\u3002

    \u66b4\u529b\u641c\u7d22\u7684\u4f18\u70b9\u662f\u7b80\u5355\u4e14\u901a\u7528\u6027\u597d\uff0c\u65e0\u9700\u5bf9\u6570\u636e\u505a\u9884\u5904\u7406\u548c\u501f\u52a9\u989d\u5916\u7684\u6570\u636e\u7ed3\u6784\u3002

    \u7136\u800c\uff0c\u6b64\u7c7b\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u5176\u4e2d \\(n\\) \u4e3a\u5143\u7d20\u6570\u91cf\uff0c\u56e0\u6b64\u5728\u6570\u636e\u91cf\u8f83\u5927\u7684\u60c5\u51b5\u4e0b\u6027\u80fd\u8f83\u5dee\u3002

    "},{"location":"chapter_searching/searching_algorithm_revisited/#1042","title":"10.4.2. \u00a0 \u81ea\u9002\u5e94\u641c\u7d22","text":"

    \u81ea\u9002\u5e94\u641c\u7d22\u5229\u7528\u6570\u636e\u7684\u7279\u6709\u5c5e\u6027\uff08\u4f8b\u5982\u6709\u5e8f\u6027\uff09\u6765\u4f18\u5316\u641c\u7d22\u8fc7\u7a0b\uff0c\u4ece\u800c\u66f4\u9ad8\u6548\u5730\u5b9a\u4f4d\u76ee\u6807\u5143\u7d20\u3002

    • \u300c\u4e8c\u5206\u67e5\u627e\u300d\u5229\u7528\u6570\u636e\u7684\u6709\u5e8f\u6027\u5b9e\u73b0\u9ad8\u6548\u67e5\u627e\uff0c\u4ec5\u9002\u7528\u4e8e\u6570\u7ec4\u3002
    • \u300c\u54c8\u5e0c\u67e5\u627e\u300d\u5229\u7528\u54c8\u5e0c\u8868\u5c06\u641c\u7d22\u6570\u636e\u548c\u76ee\u6807\u6570\u636e\u5efa\u7acb\u4e3a\u952e\u503c\u5bf9\u6620\u5c04\uff0c\u4ece\u800c\u5b9e\u73b0\u67e5\u8be2\u64cd\u4f5c\u3002
    • \u300c\u6811\u67e5\u627e\u300d\u5728\u7279\u5b9a\u7684\u6811\u7ed3\u6784\uff08\u4f8b\u5982\u4e8c\u53c9\u641c\u7d22\u6811\uff09\u4e2d\uff0c\u57fa\u4e8e\u6bd4\u8f83\u8282\u70b9\u503c\u6765\u5feb\u901f\u6392\u9664\u8282\u70b9\uff0c\u4ece\u800c\u5b9a\u4f4d\u76ee\u6807\u5143\u7d20\u3002

    \u6b64\u7c7b\u7b97\u6cd5\u7684\u4f18\u70b9\u662f\u6548\u7387\u9ad8\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u8fbe\u5230 \\(O(\\log n)\\) \u751a\u81f3 \\(O(1)\\) \u3002

    \u7136\u800c\uff0c\u4f7f\u7528\u8fd9\u4e9b\u7b97\u6cd5\u5f80\u5f80\u9700\u8981\u5bf9\u6570\u636e\u8fdb\u884c\u9884\u5904\u7406\u3002\u4f8b\u5982\uff0c\u4e8c\u5206\u67e5\u627e\u9700\u8981\u9884\u5148\u5bf9\u6570\u7ec4\u8fdb\u884c\u6392\u5e8f\uff0c\u54c8\u5e0c\u67e5\u627e\u548c\u6811\u67e5\u627e\u90fd\u9700\u8981\u501f\u52a9\u989d\u5916\u7684\u6570\u636e\u7ed3\u6784\uff0c\u7ef4\u62a4\u8fd9\u4e9b\u6570\u636e\u7ed3\u6784\u4e5f\u9700\u8981\u989d\u5916\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u5f00\u652f\u3002

    Note

    \u81ea\u9002\u5e94\u641c\u7d22\u7b97\u6cd5\u5e38\u88ab\u79f0\u4e3a\u67e5\u627e\u7b97\u6cd5\uff0c\u4e3b\u8981\u5173\u6ce8\u5728\u7279\u5b9a\u6570\u636e\u7ed3\u6784\u4e2d\u5feb\u901f\u68c0\u7d22\u76ee\u6807\u5143\u7d20\u3002

    "},{"location":"chapter_searching/searching_algorithm_revisited/#1043","title":"10.4.3. \u00a0 \u641c\u7d22\u65b9\u6cd5\u9009\u53d6","text":"

    \u7ed9\u5b9a\u5927\u5c0f\u4e3a \\(n\\) \u7684\u4e00\u7ec4\u6570\u636e\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u7ebf\u6027\u641c\u7d22\u3001\u4e8c\u5206\u67e5\u627e\u3001\u6811\u67e5\u627e\u3001\u54c8\u5e0c\u67e5\u627e\u7b49\u591a\u79cd\u65b9\u6cd5\u5728\u8be5\u6570\u636e\u4e2d\u641c\u7d22\u76ee\u6807\u5143\u7d20\u3002\u5404\u4e2a\u65b9\u6cd5\u7684\u5de5\u4f5c\u539f\u7406\u5982\u4e0b\u56fe\u6240\u793a\u3002

    Fig. \u591a\u79cd\u641c\u7d22\u7b56\u7565

    \u4e0a\u8ff0\u51e0\u79cd\u65b9\u6cd5\u7684\u64cd\u4f5c\u6548\u7387\u4e0e\u7279\u6027\u5982\u4e0b\u8868\u6240\u793a\u3002

    \u7ebf\u6027\u641c\u7d22 \u4e8c\u5206\u67e5\u627e \u6811\u67e5\u627e \u54c8\u5e0c\u67e5\u627e \u67e5\u627e\u5143\u7d20 \\(O(n)\\) \\(O(\\log n)\\) \\(O(\\log n)\\) \\(O(1)\\) \u63d2\u5165\u5143\u7d20 \\(O(1)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) \u5220\u9664\u5143\u7d20 \\(O(n)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) \u989d\u5916\u7a7a\u95f4 \\(O(1)\\) \\(O(1)\\) \\(O(n)\\) \\(O(n)\\) \u6570\u636e\u9884\u5904\u7406 / \u6392\u5e8f \\(O(n \\log n)\\) \u5efa\u6811 \\(O(n \\log n)\\) \u5efa\u54c8\u5e0c\u8868 \\(O(n)\\) \u6570\u636e\u662f\u5426\u6709\u5e8f \u65e0\u5e8f \u6709\u5e8f \u6709\u5e8f \u65e0\u5e8f

    \u9664\u4e86\u4ee5\u4e0a\u8868\u683c\u5185\u5bb9\uff0c\u641c\u7d22\u7b97\u6cd5\u7684\u9009\u62e9\u8fd8\u53d6\u51b3\u4e8e\u6570\u636e\u4f53\u91cf\u3001\u641c\u7d22\u6027\u80fd\u8981\u6c42\u3001\u6570\u636e\u67e5\u8be2\u4e0e\u66f4\u65b0\u9891\u7387\u7b49\u3002

    \u7ebf\u6027\u641c\u7d22

    • \u901a\u7528\u6027\u8f83\u597d\uff0c\u65e0\u9700\u4efb\u4f55\u6570\u636e\u9884\u5904\u7406\u64cd\u4f5c\u3002\u5047\u5982\u6211\u4eec\u4ec5\u9700\u67e5\u8be2\u4e00\u6b21\u6570\u636e\uff0c\u90a3\u4e48\u5176\u4ed6\u4e09\u79cd\u65b9\u6cd5\u7684\u6570\u636e\u9884\u5904\u7406\u7684\u65f6\u95f4\u6bd4\u7ebf\u6027\u641c\u7d22\u7684\u65f6\u95f4\u8fd8\u8981\u66f4\u957f\u3002
    • \u9002\u7528\u4e8e\u4f53\u91cf\u8f83\u5c0f\u7684\u6570\u636e\uff0c\u6b64\u60c5\u51b5\u4e0b\u65f6\u95f4\u590d\u6742\u5ea6\u5bf9\u6548\u7387\u5f71\u54cd\u8f83\u5c0f\u3002
    • \u9002\u7528\u4e8e\u6570\u636e\u66f4\u65b0\u9891\u7387\u8f83\u9ad8\u7684\u573a\u666f\uff0c\u56e0\u4e3a\u8be5\u65b9\u6cd5\u4e0d\u9700\u8981\u5bf9\u6570\u636e\u8fdb\u884c\u4efb\u4f55\u989d\u5916\u7ef4\u62a4\u3002

    \u4e8c\u5206\u67e5\u627e

    • \u9002\u7528\u4e8e\u5927\u6570\u636e\u91cf\u7684\u60c5\u51b5\uff0c\u6548\u7387\u8868\u73b0\u7a33\u5b9a\uff0c\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u3002
    • \u6570\u636e\u91cf\u4e0d\u80fd\u8fc7\u5927\uff0c\u56e0\u4e3a\u5b58\u50a8\u6570\u7ec4\u9700\u8981\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u3002
    • \u4e0d\u9002\u7528\u4e8e\u9ad8\u9891\u589e\u5220\u6570\u636e\u7684\u573a\u666f\uff0c\u56e0\u4e3a\u7ef4\u62a4\u6709\u5e8f\u6570\u7ec4\u7684\u5f00\u9500\u8f83\u5927\u3002

    \u54c8\u5e0c\u67e5\u627e

    • \u9002\u5408\u5bf9\u67e5\u8be2\u6027\u80fd\u8981\u6c42\u5f88\u9ad8\u7684\u573a\u666f\uff0c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002
    • \u4e0d\u9002\u5408\u9700\u8981\u6709\u5e8f\u6570\u636e\u6216\u8303\u56f4\u67e5\u627e\u7684\u573a\u666f\uff0c\u56e0\u4e3a\u54c8\u5e0c\u8868\u65e0\u6cd5\u7ef4\u62a4\u6570\u636e\u7684\u6709\u5e8f\u6027\u3002
    • \u5bf9\u54c8\u5e0c\u51fd\u6570\u548c\u54c8\u5e0c\u51b2\u7a81\u5904\u7406\u7b56\u7565\u7684\u4f9d\u8d56\u6027\u8f83\u9ad8\uff0c\u5177\u6709\u8f83\u5927\u7684\u6027\u80fd\u52a3\u5316\u98ce\u9669\u3002
    • \u4e0d\u9002\u5408\u6570\u636e\u91cf\u8fc7\u5927\u7684\u60c5\u51b5\uff0c\u56e0\u4e3a\u54c8\u5e0c\u8868\u9700\u8981\u989d\u5916\u7a7a\u95f4\u6765\u6700\u5927\u7a0b\u5ea6\u5730\u51cf\u5c11\u51b2\u7a81\uff0c\u4ece\u800c\u63d0\u4f9b\u826f\u597d\u7684\u67e5\u8be2\u6027\u80fd\u3002

    \u6811\u67e5\u627e

    • \u9002\u7528\u4e8e\u6d77\u91cf\u6570\u636e\uff0c\u56e0\u4e3a\u6811\u8282\u70b9\u5728\u5185\u5b58\u4e2d\u662f\u79bb\u6563\u5b58\u50a8\u7684\u3002
    • \u9002\u5408\u9700\u8981\u7ef4\u62a4\u6709\u5e8f\u6570\u636e\u6216\u8303\u56f4\u67e5\u627e\u7684\u573a\u666f\u3002
    • \u5728\u6301\u7eed\u589e\u5220\u8282\u70b9\u7684\u8fc7\u7a0b\u4e2d\uff0c\u4e8c\u53c9\u641c\u7d22\u6811\u53ef\u80fd\u4ea7\u751f\u503e\u659c\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u52a3\u5316\u81f3 \\(O(n)\\) \u3002
    • \u82e5\u4f7f\u7528 AVL \u6811\u6216\u7ea2\u9ed1\u6811\uff0c\u5219\u5404\u9879\u64cd\u4f5c\u53ef\u5728 \\(O(\\log n)\\) \u6548\u7387\u4e0b\u7a33\u5b9a\u8fd0\u884c\uff0c\u4f46\u7ef4\u62a4\u6811\u5e73\u8861\u7684\u64cd\u4f5c\u4f1a\u589e\u52a0\u989d\u5916\u5f00\u9500\u3002
    "},{"location":"chapter_searching/summary/","title":"10.5. \u00a0 \u5c0f\u7ed3","text":"
    • \u4e8c\u5206\u67e5\u627e\u4f9d\u8d56\u4e8e\u6570\u636e\u7684\u6709\u5e8f\u6027\uff0c\u901a\u8fc7\u5faa\u73af\u9010\u6b65\u7f29\u51cf\u4e00\u534a\u641c\u7d22\u533a\u95f4\u6765\u5b9e\u73b0\u67e5\u627e\u3002\u5b83\u8981\u6c42\u8f93\u5165\u6570\u636e\u6709\u5e8f\uff0c\u4e14\u4ec5\u9002\u7528\u4e8e\u6570\u7ec4\u6216\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u3002
    • \u66b4\u529b\u641c\u7d22\u901a\u8fc7\u904d\u5386\u6570\u636e\u7ed3\u6784\u6765\u5b9a\u4f4d\u6570\u636e\u3002\u7ebf\u6027\u641c\u7d22\u9002\u7528\u4e8e\u6570\u7ec4\u548c\u94fe\u8868\uff0c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22\u548c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u9002\u7528\u4e8e\u56fe\u548c\u6811\u3002\u6b64\u7c7b\u7b97\u6cd5\u901a\u7528\u6027\u597d\uff0c\u65e0\u9700\u5bf9\u6570\u636e\u9884\u5904\u7406\uff0c\u4f46\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n)\\) \u8f83\u9ad8\u3002
    • \u54c8\u5e0c\u67e5\u627e\u3001\u6811\u67e5\u627e\u548c\u4e8c\u5206\u67e5\u627e\u5c5e\u4e8e\u9ad8\u6548\u641c\u7d22\u65b9\u6cd5\uff0c\u53ef\u5728\u7279\u5b9a\u6570\u636e\u7ed3\u6784\u4e2d\u5feb\u901f\u5b9a\u4f4d\u76ee\u6807\u5143\u7d20\u3002\u6b64\u7c7b\u7b97\u6cd5\u6548\u7387\u9ad8\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u8fbe \\(O(\\log n)\\) \u751a\u81f3 \\(O(1)\\) \uff0c\u4f46\u901a\u5e38\u9700\u8981\u501f\u52a9\u989d\u5916\u6570\u636e\u7ed3\u6784\u3002
    • \u5b9e\u9645\u4e2d\uff0c\u6211\u4eec\u9700\u8981\u5bf9\u6570\u636e\u4f53\u91cf\u3001\u641c\u7d22\u6027\u80fd\u8981\u6c42\u3001\u6570\u636e\u67e5\u8be2\u548c\u66f4\u65b0\u9891\u7387\u7b49\u56e0\u7d20\u8fdb\u884c\u5177\u4f53\u5206\u6790\uff0c\u4ece\u800c\u9009\u62e9\u5408\u9002\u7684\u641c\u7d22\u65b9\u6cd5\u3002
    • \u7ebf\u6027\u641c\u7d22\u9002\u7528\u4e8e\u5c0f\u578b\u6216\u9891\u7e41\u66f4\u65b0\u7684\u6570\u636e\uff1b\u4e8c\u5206\u67e5\u627e\u9002\u7528\u4e8e\u5927\u578b\u3001\u6392\u5e8f\u7684\u6570\u636e\uff1b\u54c8\u5e0c\u67e5\u627e\u9002\u5408\u5bf9\u67e5\u8be2\u6548\u7387\u8981\u6c42\u8f83\u9ad8\u4e14\u65e0\u9700\u8303\u56f4\u67e5\u8be2\u7684\u6570\u636e\uff1b\u6811\u67e5\u627e\u9002\u7528\u4e8e\u9700\u8981\u7ef4\u62a4\u987a\u5e8f\u548c\u652f\u6301\u8303\u56f4\u67e5\u8be2\u7684\u5927\u578b\u52a8\u6001\u6570\u636e\u3002
    • \u7528\u54c8\u5e0c\u67e5\u627e\u66ff\u6362\u7ebf\u6027\u67e5\u627e\u662f\u4e00\u79cd\u5e38\u7528\u7684\u4f18\u5316\u8fd0\u884c\u65f6\u95f4\u7684\u7b56\u7565\uff0c\u53ef\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n)\\) \u964d\u4f4e\u81f3 \\(O(1)\\) \u3002
    "},{"location":"chapter_sorting/","title":"11. \u00a0 \u6392\u5e8f","text":""},{"location":"chapter_sorting/bubble_sort/","title":"11.3. \u00a0 \u5192\u6ce1\u6392\u5e8f","text":"

    \u300c\u5192\u6ce1\u6392\u5e8f Bubble Sort\u300d\u901a\u8fc7\u8fde\u7eed\u5730\u6bd4\u8f83\u4e0e\u4ea4\u6362\u76f8\u90bb\u5143\u7d20\u5b9e\u73b0\u6392\u5e8f\u3002\u8fd9\u4e2a\u8fc7\u7a0b\u5c31\u50cf\u6c14\u6ce1\u4ece\u5e95\u90e8\u5347\u5230\u9876\u90e8\u4e00\u6837\uff0c\u56e0\u6b64\u5f97\u540d\u5192\u6ce1\u6392\u5e8f\u3002

    \u6211\u4eec\u53ef\u4ee5\u5229\u7528\u5143\u7d20\u4ea4\u6362\u64cd\u4f5c\u6a21\u62df\u4e0a\u8ff0\u8fc7\u7a0b\uff1a\u4ece\u6570\u7ec4\u6700\u5de6\u7aef\u5f00\u59cb\u5411\u53f3\u904d\u5386\uff0c\u4f9d\u6b21\u6bd4\u8f83\u76f8\u90bb\u5143\u7d20\u5927\u5c0f\uff0c\u5982\u679c\u201c\u5de6\u5143\u7d20 > \u53f3\u5143\u7d20\u201d\u5c31\u4ea4\u6362\u5b83\u4fe9\u3002\u904d\u5386\u5b8c\u6210\u540e\uff0c\u6700\u5927\u7684\u5143\u7d20\u4f1a\u88ab\u79fb\u52a8\u5230\u6570\u7ec4\u7684\u6700\u53f3\u7aef\u3002

    <1><2><3><4><5><6><7>

    "},{"location":"chapter_sorting/bubble_sort/#1131","title":"11.3.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u8bbe\u6570\u7ec4\u7684\u957f\u5ea6\u4e3a \\(n\\) \uff0c\u5192\u6ce1\u6392\u5e8f\u7684\u6b65\u9aa4\u4e3a\uff1a

    1. \u9996\u5148\uff0c\u5bf9 \\(n\\) \u4e2a\u5143\u7d20\u6267\u884c\u201c\u5192\u6ce1\u201d\uff0c\u5c06\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u6b63\u786e\u4f4d\u7f6e\uff0c
    2. \u63a5\u4e0b\u6765\uff0c\u5bf9\u5269\u4f59 \\(n - 1\\) \u4e2a\u5143\u7d20\u6267\u884c\u201c\u5192\u6ce1\u201d\uff0c\u5c06\u7b2c\u4e8c\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u6b63\u786e\u4f4d\u7f6e\u3002
    3. \u4ee5\u6b64\u7c7b\u63a8\uff0c\u7ecf\u8fc7 \\(n - 1\\) \u8f6e\u201c\u5192\u6ce1\u201d\u540e\uff0c\u524d \\(n - 1\\) \u5927\u7684\u5143\u7d20\u90fd\u88ab\u4ea4\u6362\u81f3\u6b63\u786e\u4f4d\u7f6e\u3002
    4. \u4ec5\u5269\u7684\u4e00\u4e2a\u5143\u7d20\u5fc5\u5b9a\u662f\u6700\u5c0f\u5143\u7d20\uff0c\u65e0\u9700\u6392\u5e8f\uff0c\u56e0\u6b64\u6570\u7ec4\u6392\u5e8f\u5b8c\u6210\u3002

    Fig. \u5192\u6ce1\u6392\u5e8f\u6d41\u7a0b

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart bubble_sort.java
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    bubble_sort.cpp
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(vector<int> &nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.size() - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n// \u8fd9\u91cc\u4f7f\u7528\u4e86 std::swap() \u51fd\u6570\nswap(nums[j], nums[j + 1]);\n}\n}\n}\n}\n
    bubble_sort.py
    def bubble_sort(nums: list[int]) -> None:\n\"\"\"\u5192\u6ce1\u6392\u5e8f\"\"\"\nn = len(nums)\n# \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in range(n - 1, 0, -1):\n# \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor j in range(i):\nif nums[j] > nums[j + 1]:\n# \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nnums[j], nums[j + 1] = nums[j + 1], nums[j]\n
    bubble_sort.go
    /* \u5192\u6ce1\u6392\u5e8f */\nfunc bubbleSort(nums []int) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i := len(nums) - 1; i > 0; i-- {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef\nfor j := 0; j < i; j++ {\nif nums[j] > nums[j+1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nnums[j], nums[j+1] = nums[j+1], nums[j]\n}\n}\n}\n}\n
    bubble_sort.js
    /* \u5192\u6ce1\u6392\u5e8f */\nfunction bubbleSort(nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    bubble_sort.ts
    /* \u5192\u6ce1\u6392\u5e8f */\nfunction bubbleSort(nums: number[]): void {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    bubble_sort.c
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(int nums[], int size) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = 0; i < size - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < size - 1 - i; j++) {\nif (nums[j] > nums[j + 1]) {\nint temp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = temp;\n}\n}\n}\n}\n
    bubble_sort.cs
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.Length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    bubble_sort.swift
    /* \u5192\u6ce1\u6392\u5e8f */\nfunc bubbleSort(nums: inout [Int]) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in stride(from: nums.count - 1, to: 0, by: -1) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor j in stride(from: 0, to: i, by: 1) {\nif nums[j] > nums[j + 1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j]\nnums[j] = nums[j + 1]\nnums[j + 1] = tmp\n}\n}\n}\n}\n
    bubble_sort.zig
    // \u5192\u6ce1\u6392\u5e8f\nfn bubbleSort(nums: []i32) void {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nvar i: usize = nums.len - 1;\nwhile (i > 0) : (i -= 1) {\nvar j: usize = 0;\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nwhile (j < i) : (j += 1) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nvar tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    bubble_sort.dart
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(List<int> nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    "},{"location":"chapter_sorting/bubble_sort/#1132","title":"11.3.2. \u00a0 \u6548\u7387\u4f18\u5316","text":"

    \u6211\u4eec\u53d1\u73b0\uff0c\u5982\u679c\u67d0\u8f6e\u201c\u5192\u6ce1\u201d\u4e2d\u6ca1\u6709\u6267\u884c\u4efb\u4f55\u4ea4\u6362\u64cd\u4f5c\uff0c\u8bf4\u660e\u6570\u7ec4\u5df2\u7ecf\u5b8c\u6210\u6392\u5e8f\uff0c\u53ef\u76f4\u63a5\u8fd4\u56de\u7ed3\u679c\u3002\u56e0\u6b64\uff0c\u53ef\u4ee5\u589e\u52a0\u4e00\u4e2a\u6807\u5fd7\u4f4d flag \u6765\u76d1\u6d4b\u8fd9\u79cd\u60c5\u51b5\uff0c\u4e00\u65e6\u51fa\u73b0\u5c31\u7acb\u5373\u8fd4\u56de\u3002

    \u7ecf\u8fc7\u4f18\u5316\uff0c\u5192\u6ce1\u6392\u5e8f\u7684\u6700\u5dee\u548c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(n^2)\\) \uff1b\u4f46\u5f53\u8f93\u5165\u6570\u7ec4\u5b8c\u5168\u6709\u5e8f\u65f6\uff0c\u53ef\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart bubble_sort.java
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09 */\nvoid bubbleSortWithFlag(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.length - 1; i > 0; i--) {\nboolean flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag)\nbreak; // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.cpp
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nvoid bubbleSortWithFlag(vector<int> &nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.size() - 1; i > 0; i--) {\nbool flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n// \u8fd9\u91cc\u4f7f\u7528\u4e86 std::swap() \u51fd\u6570\nswap(nums[j], nums[j + 1]);\nflag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag)\nbreak; // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.py
    def bubble_sort_with_flag(nums: list[int]) -> None:\n\"\"\"\u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09\"\"\"\nn = len(nums)\n# \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in range(n - 1, 0, -1):\nflag = False  # \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n# \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor j in range(i):\nif nums[j] > nums[j + 1]:\n# \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nnums[j], nums[j + 1] = nums[j + 1], nums[j]\nflag = True  # \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\nif not flag:\nbreak  # \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n
    bubble_sort.go
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nfunc bubbleSortWithFlag(nums []int) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i := len(nums) - 1; i > 0; i-- {\nflag := false // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef\nfor j := 0; j < i; j++ {\nif nums[j] > nums[j+1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nnums[j], nums[j+1] = nums[j+1], nums[j]\nflag = true // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif flag == false { // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\nbreak\n}\n}\n}\n
    bubble_sort.js
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nfunction bubbleSortWithFlag(nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\nlet flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag) break; // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.ts
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nfunction bubbleSortWithFlag(nums: number[]): void {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\nlet flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag) break; // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.c
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nvoid bubbleSortWithFlag(int nums[], int size) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = 0; i < size - 1; i++) {\nbool flag = false;\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < size - 1 - i; j++) {\nif (nums[j] > nums[j + 1]) {\nint temp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = temp;\nflag = true;\n}\n}\nif (!flag)\nbreak;\n}\n}\n
    bubble_sort.cs
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nvoid bubbleSortWithFlag(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.Length - 1; i > 0; i--) {\nbool flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true;  // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag) break;     // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.swift
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nfunc bubbleSortWithFlag(nums: inout [Int]) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in stride(from: nums.count - 1, to: 0, by: -1) {\nvar flag = false // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\nfor j in stride(from: 0, to: i, by: 1) {\nif nums[j] > nums[j + 1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j]\nnums[j] = nums[j + 1]\nnums[j + 1] = tmp\nflag = true // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif !flag { // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\nbreak\n}\n}\n}\n
    bubble_sort.zig
    // \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09\nfn bubbleSortWithFlag(nums: []i32) void {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nvar i: usize = nums.len - 1;\nwhile (i > 0) : (i -= 1) {\nvar flag = false;   // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\nvar j: usize = 0;\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nwhile (j < i) : (j += 1) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nvar tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true;\n}\n}\nif (!flag) break;   // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.dart
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nvoid bubbleSortWithFlag(List<int> nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.length - 1; i > 0; i--) {\nbool flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag) break; // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    "},{"location":"chapter_sorting/bubble_sort/#1133","title":"11.3.3. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3001\u81ea\u9002\u5e94\u6392\u5e8f \uff1a\u5404\u8f6e\u201c\u5192\u6ce1\u201d\u904d\u5386\u7684\u6570\u7ec4\u957f\u5ea6\u4f9d\u6b21\u4e3a \\(n - 1\\) , \\(n - 2\\) , \\(\\cdots\\) , \\(2\\) , \\(1\\) \uff0c\u603b\u548c\u4e3a \\(\\frac{(n - 1) n}{2}\\) \u3002\u5728\u5f15\u5165 flag \u4f18\u5316\u540e\uff0c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u8fbe\u5230 \\(O(n)\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3001\u539f\u5730\u6392\u5e8f\uff1a\u6307\u9488 \\(i\\) , \\(j\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u7a33\u5b9a\u6392\u5e8f\uff1a\u7531\u4e8e\u5728\u201c\u5192\u6ce1\u201d\u4e2d\u9047\u5230\u76f8\u7b49\u5143\u7d20\u4e0d\u4ea4\u6362\u3002
    "},{"location":"chapter_sorting/bucket_sort/","title":"11.8. \u00a0 \u6876\u6392\u5e8f","text":"

    \u524d\u8ff0\u7684\u51e0\u79cd\u6392\u5e8f\u7b97\u6cd5\u90fd\u5c5e\u4e8e\u201c\u57fa\u4e8e\u6bd4\u8f83\u7684\u6392\u5e8f\u7b97\u6cd5\u201d\uff0c\u5b83\u4eec\u901a\u8fc7\u6bd4\u8f83\u5143\u7d20\u95f4\u7684\u5927\u5c0f\u6765\u5b9e\u73b0\u6392\u5e8f\u3002\u6b64\u7c7b\u6392\u5e8f\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u65e0\u6cd5\u8d85\u8d8a \\(O(n \\log n)\\) \u3002\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c06\u63a2\u8ba8\u51e0\u79cd\u201c\u975e\u6bd4\u8f83\u6392\u5e8f\u7b97\u6cd5\u201d\uff0c\u5b83\u4eec\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u8fbe\u5230\u7ebf\u6027\u6c34\u5e73\u3002

    \u300c\u6876\u6392\u5e8f Bucket Sort\u300d\u662f\u5206\u6cbb\u601d\u60f3\u7684\u4e00\u4e2a\u5178\u578b\u5e94\u7528\u3002\u5b83\u901a\u8fc7\u8bbe\u7f6e\u4e00\u4e9b\u5177\u6709\u5927\u5c0f\u987a\u5e8f\u7684\u6876\uff0c\u6bcf\u4e2a\u6876\u5bf9\u5e94\u4e00\u4e2a\u6570\u636e\u8303\u56f4\uff0c\u5c06\u6570\u636e\u5e73\u5747\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\uff1b\u7136\u540e\uff0c\u5728\u6bcf\u4e2a\u6876\u5185\u90e8\u5206\u522b\u6267\u884c\u6392\u5e8f\uff1b\u6700\u7ec8\u6309\u7167\u6876\u7684\u987a\u5e8f\u5c06\u6240\u6709\u6570\u636e\u5408\u5e76\u3002

    "},{"location":"chapter_sorting/bucket_sort/#1181","title":"11.8.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u8003\u8651\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4\uff0c\u5143\u7d20\u662f\u8303\u56f4 \\([0, 1)\\) \u7684\u6d6e\u70b9\u6570\u3002\u6876\u6392\u5e8f\u7684\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u521d\u59cb\u5316 \\(k\\) \u4e2a\u6876\uff0c\u5c06 \\(n\\) \u4e2a\u5143\u7d20\u5206\u914d\u5230 \\(k\\) \u4e2a\u6876\u4e2d\uff1b
    2. \u5bf9\u6bcf\u4e2a\u6876\u5206\u522b\u6267\u884c\u6392\u5e8f\uff08\u672c\u6587\u91c7\u7528\u7f16\u7a0b\u8bed\u8a00\u7684\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff09\uff1b
    3. \u6309\u7167\u6876\u7684\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\uff0c\u5408\u5e76\u7ed3\u679c\uff1b

    Fig. \u6876\u6392\u5e8f\u7b97\u6cd5\u6d41\u7a0b

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart bucket_sort.java
    /* \u6876\u6392\u5e8f */\nvoid bucketSort(float[] nums) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nint k = nums.length / 2;\nList<List<Float>> buckets = new ArrayList<>();\nfor (int i = 0; i < k; i++) {\nbuckets.add(new ArrayList<>());\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (float num : nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nint i = (int) (num * k);\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets.get(i).add(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (List<Float> bucket : buckets) {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nCollections.sort(bucket);\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nint i = 0;\nfor (List<Float> bucket : buckets) {\nfor (float num : bucket) {\nnums[i++] = num;\n}\n}\n}\n
    bucket_sort.cpp
    /* \u6876\u6392\u5e8f */\nvoid bucketSort(vector<float> &nums) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nint k = nums.size() / 2;\nvector<vector<float>> buckets(k);\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (float num : nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nint i = num * k;\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 bucket_idx\nbuckets[i].push_back(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (vector<float> &bucket : buckets) {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nsort(bucket.begin(), bucket.end());\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nint i = 0;\nfor (vector<float> &bucket : buckets) {\nfor (float num : bucket) {\nnums[i++] = num;\n}\n}\n}\n
    bucket_sort.py
    def bucket_sort(nums: list[float]) -> None:\n\"\"\"\u6876\u6392\u5e8f\"\"\"\n# \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nk = len(nums) // 2\nbuckets = [[] for _ in range(k)]\n# 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor num in nums:\n# \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\ni = int(num * k)\n# \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i].append(num)\n# 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor bucket in buckets:\n# \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nbucket.sort()\n# 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\ni = 0\nfor bucket in buckets:\nfor num in bucket:\nnums[i] = num\ni += 1\n
    bucket_sort.go
    /* \u6876\u6392\u5e8f */\nfunc bucketSort(nums []float64) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nk := len(nums) / 2\nbuckets := make([][]float64, k)\nfor i := 0; i < k; i++ {\nbuckets[i] = make([]float64, 0)\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor _, num := range nums {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\ni := int(num * float64(k))\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i] = append(buckets[i], num)\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor i := 0; i < k; i++ {\n// \u4f7f\u7528\u5185\u7f6e\u5207\u7247\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nsort.Float64s(buckets[i])\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\ni := 0\nfor _, bucket := range buckets {\nfor _, num := range bucket {\nnums[i] = num\ni++\n}\n}\n}\n
    bucket_sort.js
    /* \u6876\u6392\u5e8f */\nfunction bucketSort(nums) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nconst k = nums.length / 2;\nconst buckets = [];\nfor (let i = 0; i < k; i++) {\nbuckets.push([]);\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (const num of nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nconst i = Math.floor(num * k);\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i].push(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (const bucket of buckets) {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nbucket.sort((a, b) => a - b);\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nlet i = 0;\nfor (const bucket of buckets) {\nfor (const num of bucket) {\nnums[i++] = num;\n}\n}\n}\n
    bucket_sort.ts
    /* \u6876\u6392\u5e8f */\nfunction bucketSort(nums: number[]): void {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nconst k = nums.length / 2;\nconst buckets: number[][] = [];\nfor (let i = 0; i < k; i++) {\nbuckets.push([]);\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (const num of nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nconst i = Math.floor(num * k);\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i].push(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (const bucket of buckets) {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nbucket.sort((a, b) => a - b);\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nlet i = 0;\nfor (const bucket of buckets) {\nfor (const num of bucket) {\nnums[i++] = num;\n}\n}\n}\n
    bucket_sort.c
    /* \u6876\u6392\u5e8f */\nvoid bucketSort(float nums[], int size) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nint k = size / 2;\nfloat **buckets = calloc(k, sizeof(float *));\nfor (int i = 0; i < k; i++) {\n// \u6bcf\u4e2a\u6876\u6700\u591a\u53ef\u4ee5\u5206\u914d k \u4e2a\u5143\u7d20\nbuckets[i] = calloc(ARRAY_SIZE, sizeof(float));\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (int i = 0; i < size; i++) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nint bucket_idx = nums[i] * k;\nint j = 0;\n// \u5982\u679c\u6876\u4e2d\u6709\u6570\u636e\u4e14\u6570\u636e\u5c0f\u4e8e\u5f53\u524d\u503c nums[i], \u8981\u5c06\u5176\u653e\u5230\u5f53\u524d\u6876\u7684\u540e\u9762\uff0c\u76f8\u5f53\u4e8e cpp \u4e2d\u7684 push_back\nwhile (buckets[bucket_idx][j] > 0 && buckets[bucket_idx][j] < nums[i]) {\nj++;\n}\nfloat temp = nums[i];\nwhile (j < ARRAY_SIZE && buckets[bucket_idx][j] > 0) {\nswap(&temp, &buckets[bucket_idx][j]);\nj++;\n}\nbuckets[bucket_idx][j] = temp;\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (int i = 0; i < k; i++) {\nqsort(buckets[i], ARRAY_SIZE, sizeof(float), compare_float);\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nfor (int i = 0, j = 0; j < k; j++) {\nfor (int l = 0; l < ARRAY_SIZE; l++) {\nif (buckets[j][l] > 0) {\nnums[i++] = buckets[j][l];\n}\n}\n}\n// \u91ca\u653e\u4e0a\u8ff0\u5206\u914d\u7684\u5185\u5b58\nfor (int i = 0; i < k; i++) {\nfree(buckets[i]);\n}\nfree(buckets);\n}\n
    bucket_sort.cs
    /* \u6876\u6392\u5e8f */\nvoid bucketSort(float[] nums) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nint k = nums.Length / 2;\nList<List<float>> buckets = new List<List<float>>();\nfor (int i = 0; i < k; i++) {\nbuckets.Add(new List<float>());\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nforeach (float num in nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nint i = (int) (num * k);\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i].Add(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nforeach (List<float> bucket in buckets) {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nbucket.Sort();\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nint j = 0;\nforeach (List<float> bucket in buckets) {\nforeach (float num in bucket) {\nnums[j++] = num;\n}\n}\n}\n
    bucket_sort.swift
    /* \u6876\u6392\u5e8f */\nfunc bucketSort(nums: inout [Double]) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nlet k = nums.count / 2\nvar buckets = (0 ..< k).map { _ in [Double]() }\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor num in nums {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nlet i = Int(num * Double(k))\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i].append(num)\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor i in buckets.indices {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nbuckets[i].sort()\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nvar i = nums.startIndex\nfor bucket in buckets {\nfor num in bucket {\nnums[i] = num\nnums.formIndex(after: &i)\n}\n}\n}\n
    bucket_sort.zig
    [class]{}-[func]{bucketSort}\n
    bucket_sort.dart
    /* \u6876\u6392\u5e8f */\nvoid bucketSort(List<double> nums) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nint k = nums.length ~/ 2;\nList<List<double>> buckets = List.generate(k, (index) => []);\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (double num in nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nint i = (num * k).toInt();\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 bucket_idx\nbuckets[i].add(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (List<double> bucket in buckets) {\nbucket.sort();\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nint i = 0;\nfor (List<double> bucket in buckets) {\nfor (double num in bucket) {\nnums[i++] = num;\n}\n}\n}\n

    \u6876\u6392\u5e8f\u7684\u9002\u7528\u573a\u666f\u662f\u4ec0\u4e48\uff1f

    \u6876\u6392\u5e8f\u9002\u7528\u4e8e\u5904\u7406\u4f53\u91cf\u5f88\u5927\u7684\u6570\u636e\u3002\u4f8b\u5982\uff0c\u8f93\u5165\u6570\u636e\u5305\u542b 100 \u4e07\u4e2a\u5143\u7d20\uff0c\u7531\u4e8e\u7a7a\u95f4\u9650\u5236\uff0c\u7cfb\u7edf\u5185\u5b58\u65e0\u6cd5\u4e00\u6b21\u6027\u52a0\u8f7d\u6240\u6709\u6570\u636e\u3002\u6b64\u65f6\uff0c\u53ef\u4ee5\u5c06\u6570\u636e\u5206\u6210 1000 \u4e2a\u6876\uff0c\u7136\u540e\u5206\u522b\u5bf9\u6bcf\u4e2a\u6876\u8fdb\u884c\u6392\u5e8f\uff0c\u6700\u540e\u5c06\u7ed3\u679c\u5408\u5e76\u3002

    "},{"location":"chapter_sorting/bucket_sort/#1182","title":"11.8.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n + k)\\) \uff1a\u5047\u8bbe\u5143\u7d20\u5728\u5404\u4e2a\u6876\u5185\u5e73\u5747\u5206\u5e03\uff0c\u90a3\u4e48\u6bcf\u4e2a\u6876\u5185\u7684\u5143\u7d20\u6570\u91cf\u4e3a \\(\\frac{n}{k}\\) \u3002\u5047\u8bbe\u6392\u5e8f\u5355\u4e2a\u6876\u4f7f\u7528 \\(O(\\frac{n}{k} \\log\\frac{n}{k})\\) \u65f6\u95f4\uff0c\u5219\u6392\u5e8f\u6240\u6709\u6876\u4f7f\u7528 \\(O(n \\log\\frac{n}{k})\\) \u65f6\u95f4\u3002\u5f53\u6876\u6570\u91cf \\(k\\) \u6bd4\u8f83\u5927\u65f6\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u5219\u8d8b\u5411\u4e8e \\(O(n)\\) \u3002\u5408\u5e76\u7ed3\u679c\u65f6\u9700\u8981\u904d\u5386 \\(n\\) \u4e2a\u6876\uff0c\u82b1\u8d39 \\(O(k)\\) \u65f6\u95f4\u3002
    • \u81ea\u9002\u5e94\u6392\u5e8f\uff1a\u5728\u6700\u574f\u60c5\u51b5\u4e0b\uff0c\u6240\u6709\u6570\u636e\u88ab\u5206\u914d\u5230\u4e00\u4e2a\u6876\u4e2d\uff0c\u4e14\u6392\u5e8f\u8be5\u6876\u4f7f\u7528 \\(O(n^2)\\) \u65f6\u95f4\u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(n + k)\\) \u3001\u975e\u539f\u5730\u6392\u5e8f \uff1a\u9700\u8981\u501f\u52a9 \\(k\\) \u4e2a\u6876\u548c\u603b\u5171 \\(n\\) \u4e2a\u5143\u7d20\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u6876\u6392\u5e8f\u662f\u5426\u7a33\u5b9a\u53d6\u51b3\u4e8e\u6392\u5e8f\u6876\u5185\u5143\u7d20\u7684\u7b97\u6cd5\u662f\u5426\u7a33\u5b9a\u3002
    "},{"location":"chapter_sorting/bucket_sort/#1183","title":"11.8.3. \u00a0 \u5982\u4f55\u5b9e\u73b0\u5e73\u5747\u5206\u914d","text":"

    \u6876\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u7406\u8bba\u4e0a\u53ef\u4ee5\u8fbe\u5230 \\(O(n)\\) \uff0c\u5173\u952e\u5728\u4e8e\u5c06\u5143\u7d20\u5747\u5300\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\uff0c\u56e0\u4e3a\u5b9e\u9645\u6570\u636e\u5f80\u5f80\u4e0d\u662f\u5747\u5300\u5206\u5e03\u7684\u3002\u4f8b\u5982\uff0c\u6211\u4eec\u60f3\u8981\u5c06\u6dd8\u5b9d\u4e0a\u7684\u6240\u6709\u5546\u54c1\u6309\u4ef7\u683c\u8303\u56f4\u5e73\u5747\u5206\u914d\u5230 10 \u4e2a\u6876\u4e2d\uff0c\u4f46\u5546\u54c1\u4ef7\u683c\u5206\u5e03\u4e0d\u5747\uff0c\u4f4e\u4e8e 100 \u5143\u7684\u975e\u5e38\u591a\uff0c\u9ad8\u4e8e 1000 \u5143\u7684\u975e\u5e38\u5c11\u3002\u82e5\u5c06\u4ef7\u683c\u533a\u95f4\u5e73\u5747\u5212\u5206\u4e3a 10 \u4efd\uff0c\u5404\u4e2a\u6876\u4e2d\u7684\u5546\u54c1\u6570\u91cf\u5dee\u8ddd\u4f1a\u975e\u5e38\u5927\u3002

    \u4e3a\u5b9e\u73b0\u5e73\u5747\u5206\u914d\uff0c\u6211\u4eec\u53ef\u4ee5\u5148\u8bbe\u5b9a\u4e00\u4e2a\u5927\u81f4\u7684\u5206\u754c\u7ebf\uff0c\u5c06\u6570\u636e\u7c97\u7565\u5730\u5206\u5230 3 \u4e2a\u6876\u4e2d\u3002\u5206\u914d\u5b8c\u6bd5\u540e\uff0c\u518d\u5c06\u5546\u54c1\u8f83\u591a\u7684\u6876\u7ee7\u7eed\u5212\u5206\u4e3a 3 \u4e2a\u6876\uff0c\u76f4\u81f3\u6240\u6709\u6876\u4e2d\u7684\u5143\u7d20\u6570\u91cf\u5927\u81f4\u76f8\u7b49\u3002\u8fd9\u79cd\u65b9\u6cd5\u672c\u8d28\u4e0a\u662f\u521b\u5efa\u4e00\u4e2a\u9012\u5f52\u6811\uff0c\u4f7f\u53f6\u8282\u70b9\u7684\u503c\u5c3d\u53ef\u80fd\u5e73\u5747\u3002\u5f53\u7136\uff0c\u4e0d\u4e00\u5b9a\u8981\u6bcf\u8f6e\u5c06\u6570\u636e\u5212\u5206\u4e3a 3 \u4e2a\u6876\uff0c\u5177\u4f53\u5212\u5206\u65b9\u5f0f\u53ef\u6839\u636e\u6570\u636e\u7279\u70b9\u7075\u6d3b\u9009\u62e9\u3002

    Fig. \u9012\u5f52\u5212\u5206\u6876

    \u5982\u679c\u6211\u4eec\u63d0\u524d\u77e5\u9053\u5546\u54c1\u4ef7\u683c\u7684\u6982\u7387\u5206\u5e03\uff0c\u5219\u53ef\u4ee5\u6839\u636e\u6570\u636e\u6982\u7387\u5206\u5e03\u8bbe\u7f6e\u6bcf\u4e2a\u6876\u7684\u4ef7\u683c\u5206\u754c\u7ebf\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u6570\u636e\u5206\u5e03\u5e76\u4e0d\u4e00\u5b9a\u9700\u8981\u7279\u610f\u7edf\u8ba1\uff0c\u4e5f\u53ef\u4ee5\u6839\u636e\u6570\u636e\u7279\u70b9\u91c7\u7528\u67d0\u79cd\u6982\u7387\u6a21\u578b\u8fdb\u884c\u8fd1\u4f3c\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u6211\u4eec\u5047\u8bbe\u5546\u54c1\u4ef7\u683c\u670d\u4ece\u6b63\u6001\u5206\u5e03\uff0c\u8fd9\u6837\u5c31\u53ef\u4ee5\u5408\u7406\u5730\u8bbe\u5b9a\u4ef7\u683c\u533a\u95f4\uff0c\u4ece\u800c\u5c06\u5546\u54c1\u5e73\u5747\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\u3002

    Fig. \u6839\u636e\u6982\u7387\u5206\u5e03\u5212\u5206\u6876

    "},{"location":"chapter_sorting/counting_sort/","title":"11.9. \u00a0 \u8ba1\u6570\u6392\u5e8f","text":"

    \u300c\u8ba1\u6570\u6392\u5e8f Counting Sort\u300d\u901a\u8fc7\u7edf\u8ba1\u5143\u7d20\u6570\u91cf\u6765\u5b9e\u73b0\u6392\u5e8f\uff0c\u901a\u5e38\u5e94\u7528\u4e8e\u6574\u6570\u6570\u7ec4\u3002

    "},{"location":"chapter_sorting/counting_sort/#1191","title":"11.9.1. \u00a0 \u7b80\u5355\u5b9e\u73b0","text":"

    \u5148\u6765\u770b\u4e00\u4e2a\u7b80\u5355\u7684\u4f8b\u5b50\u3002\u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4 nums \uff0c\u5176\u4e2d\u7684\u5143\u7d20\u90fd\u662f\u201c\u975e\u8d1f\u6574\u6570\u201d\u3002\u8ba1\u6570\u6392\u5e8f\u7684\u6574\u4f53\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u904d\u5386\u6570\u7ec4\uff0c\u627e\u51fa\u6570\u7ec4\u4e2d\u7684\u6700\u5927\u6570\u5b57\uff0c\u8bb0\u4e3a \\(m\\) \uff0c\u7136\u540e\u521b\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(m + 1\\) \u7684\u8f85\u52a9\u6570\u7ec4 counter \uff1b
    2. \u501f\u52a9 counter \u7edf\u8ba1 nums \u4e2d\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\uff0c\u5176\u4e2d counter[num] \u5bf9\u5e94\u6570\u5b57 num \u7684\u51fa\u73b0\u6b21\u6570\u3002\u7edf\u8ba1\u65b9\u6cd5\u5f88\u7b80\u5355\uff0c\u53ea\u9700\u904d\u5386 nums\uff08\u8bbe\u5f53\u524d\u6570\u5b57\u4e3a num\uff09\uff0c\u6bcf\u8f6e\u5c06 counter[num] \u589e\u52a0 \\(1\\) \u5373\u53ef\u3002
    3. \u7531\u4e8e counter \u7684\u5404\u4e2a\u7d22\u5f15\u5929\u7136\u6709\u5e8f\uff0c\u56e0\u6b64\u76f8\u5f53\u4e8e\u6240\u6709\u6570\u5b57\u5df2\u7ecf\u88ab\u6392\u5e8f\u597d\u4e86\u3002\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u904d\u5386 counter \uff0c\u6839\u636e\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\uff0c\u5c06\u5b83\u4eec\u6309\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\u586b\u5165 nums \u5373\u53ef\u3002

    Fig. \u8ba1\u6570\u6392\u5e8f\u6d41\u7a0b

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart counting_sort.java
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nvoid countingSortNaive(int[] nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num : nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint[] counter = new int[m + 1];\nfor (int num : nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nint i = 0;\nfor (int num = 0; num < m + 1; num++) {\nfor (int j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.cpp
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nvoid countingSortNaive(vector<int> &nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num : nums) {\nm = max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nvector<int> counter(m + 1, 0);\nfor (int num : nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nint i = 0;\nfor (int num = 0; num < m + 1; num++) {\nfor (int j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.py
    def counting_sort_naive(nums: list[int]) -> None:\n\"\"\"\u8ba1\u6570\u6392\u5e8f\"\"\"\n# \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\n# 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nm = 0\nfor num in nums:\nm = max(m, num)\n# 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n# counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\ncounter = [0] * (m + 1)\nfor num in nums:\ncounter[num] += 1\n# 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\ni = 0\nfor num in range(m + 1):\nfor _ in range(counter[num]):\nnums[i] = num\ni += 1\n
    counting_sort.go
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfunc countingSortNaive(nums []int) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nm := 0\nfor _, num := range nums {\nif num > m {\nm = num\n}\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\ncounter := make([]int, m+1)\nfor _, num := range nums {\ncounter[num]++\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nfor i, num := 0, 0; num < m+1; num++ {\nfor j := 0; j < counter[num]; j++ {\nnums[i] = num\ni++\n}\n}\n}\n
    counting_sort.js
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfunction countingSortNaive(nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = 0;\nfor (const num of nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nconst counter = new Array(m + 1).fill(0);\nfor (const num of nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nlet i = 0;\nfor (let num = 0; num < m + 1; num++) {\nfor (let j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.ts
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfunction countingSortNaive(nums: number[]): void {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = 0;\nfor (const num of nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nconst counter: number[] = new Array<number>(m + 1).fill(0);\nfor (const num of nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nlet i = 0;\nfor (let num = 0; num < m + 1; num++) {\nfor (let j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.c
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nvoid countingSortNaive(int nums[], int size) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int i = 0; i < size; i++) {\nif (nums[i] > m) {\nm = nums[i];\n}\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint *counter = malloc(sizeof(int) * m);\nfor (int i = 0; i < size; i++) {\ncounter[nums[i]]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nint i = 0;\nfor (int num = 0; num < m + 1; num++) {\nfor (int j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.cs
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nvoid countingSortNaive(int[] nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nforeach (int num in nums) {\nm = Math.Max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint[] counter = new int[m + 1];\nforeach (int num in nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nint i = 0;\nfor (int num = 0; num < m + 1; num++) {\nfor (int j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.swift
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfunc countingSortNaive(nums: inout [Int]) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = nums.max()!\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nvar counter = Array(repeating: 0, count: m + 1)\nfor num in nums {\ncounter[num] += 1\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nvar i = 0\nfor num in stride(from: 0, to: m + 1, by: 1) {\nfor _ in stride(from: 0, to: counter[num], by: 1) {\nnums[i] = num\ni += 1\n}\n}\n}\n
    counting_sort.zig
    [class]{}-[func]{countingSortNaive}\n
    counting_sort.dart
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nvoid countingSortNaive(List<int> nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num in nums) {\nm = max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nList<int> counter = List.filled(m + 1, 0);\nfor (int num in nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nint i = 0;\nfor (int num = 0; num < m + 1; num++) {\nfor (int j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n

    \u8ba1\u6570\u6392\u5e8f\u4e0e\u6876\u6392\u5e8f\u7684\u8054\u7cfb

    \u4ece\u6876\u6392\u5e8f\u7684\u89d2\u5ea6\u770b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u8ba1\u6570\u6392\u5e8f\u4e2d\u7684\u8ba1\u6570\u6570\u7ec4 counter \u7684\u6bcf\u4e2a\u7d22\u5f15\u89c6\u4e3a\u4e00\u4e2a\u6876\uff0c\u5c06\u7edf\u8ba1\u6570\u91cf\u7684\u8fc7\u7a0b\u770b\u4f5c\u662f\u5c06\u5404\u4e2a\u5143\u7d20\u5206\u914d\u5230\u5bf9\u5e94\u7684\u6876\u4e2d\u3002\u672c\u8d28\u4e0a\uff0c\u8ba1\u6570\u6392\u5e8f\u662f\u6876\u6392\u5e8f\u5728\u6574\u578b\u6570\u636e\u4e0b\u7684\u4e00\u4e2a\u7279\u4f8b\u3002

    "},{"location":"chapter_sorting/counting_sort/#1192","title":"11.9.2. \u00a0 \u5b8c\u6574\u5b9e\u73b0","text":"

    \u7ec6\u5fc3\u7684\u540c\u5b66\u53ef\u80fd\u53d1\u73b0\uff0c\u5982\u679c\u8f93\u5165\u6570\u636e\u662f\u5bf9\u8c61\uff0c\u4e0a\u8ff0\u6b65\u9aa4 3. \u5c31\u5931\u6548\u4e86\u3002\u4f8b\u5982\uff0c\u8f93\u5165\u6570\u636e\u662f\u5546\u54c1\u5bf9\u8c61\uff0c\u6211\u4eec\u60f3\u8981\u6309\u7167\u5546\u54c1\u4ef7\u683c\uff08\u7c7b\u7684\u6210\u5458\u53d8\u91cf\uff09\u5bf9\u5546\u54c1\u8fdb\u884c\u6392\u5e8f\uff0c\u800c\u4e0a\u8ff0\u7b97\u6cd5\u53ea\u80fd\u7ed9\u51fa\u4ef7\u683c\u7684\u6392\u5e8f\u7ed3\u679c\u3002

    \u90a3\u4e48\u5982\u4f55\u624d\u80fd\u5f97\u5230\u539f\u6570\u636e\u7684\u6392\u5e8f\u7ed3\u679c\u5462\uff1f\u6211\u4eec\u9996\u5148\u8ba1\u7b97 counter \u7684\u300c\u524d\u7f00\u548c\u300d\u3002\u987e\u540d\u601d\u4e49\uff0c\u7d22\u5f15 i \u5904\u7684\u524d\u7f00\u548c prefix[i] \u7b49\u4e8e\u6570\u7ec4\u524d i \u4e2a\u5143\u7d20\u4e4b\u548c\uff0c\u5373

    \\[ \\text{prefix}[i] = \\sum_{j=0}^i \\text{counter[j]} \\]

    \u524d\u7f00\u548c\u5177\u6709\u660e\u786e\u7684\u610f\u4e49\uff0cprefix[num] - 1 \u4ee3\u8868\u5143\u7d20 num \u5728\u7ed3\u679c\u6570\u7ec4 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\u3002\u8fd9\u4e2a\u4fe1\u606f\u975e\u5e38\u5173\u952e\uff0c\u56e0\u4e3a\u5b83\u544a\u8bc9\u6211\u4eec\u5404\u4e2a\u5143\u7d20\u5e94\u8be5\u51fa\u73b0\u5728\u7ed3\u679c\u6570\u7ec4\u7684\u54ea\u4e2a\u4f4d\u7f6e\u3002\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5012\u5e8f\u904d\u5386\u539f\u6570\u7ec4 nums \u7684\u6bcf\u4e2a\u5143\u7d20 num \uff0c\u5728\u6bcf\u8f6e\u8fed\u4ee3\u4e2d\u6267\u884c\uff1a

    1. \u5c06 num \u586b\u5165\u6570\u7ec4 res \u7684\u7d22\u5f15 prefix[num] - 1 \u5904\uff1b
    2. \u4ee4\u524d\u7f00\u548c prefix[num] \u51cf\u5c0f \\(1\\) \uff0c\u4ece\u800c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\uff1b

    \u904d\u5386\u5b8c\u6210\u540e\uff0c\u6570\u7ec4 res \u4e2d\u5c31\u662f\u6392\u5e8f\u597d\u7684\u7ed3\u679c\uff0c\u6700\u540e\u4f7f\u7528 res \u8986\u76d6\u539f\u6570\u7ec4 nums \u5373\u53ef\u3002

    <1><2><3><4><5><6><7><8>

    \u8ba1\u6570\u6392\u5e8f\u7684\u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart counting_sort.java
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nvoid countingSort(int[] nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num : nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint[] counter = new int[m + 1];\nfor (int num : nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (int i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nint n = nums.length;\nint[] res = new int[n];\nfor (int i = n - 1; i >= 0; i--) {\nint num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--; // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n
    counting_sort.cpp
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nvoid countingSort(vector<int> &nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num : nums) {\nm = max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nvector<int> counter(m + 1, 0);\nfor (int num : nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (int i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nint n = nums.size();\nvector<int> res(n);\nfor (int i = n - 1; i >= 0; i--) {\nint num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--;              // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nnums = res;\n}\n
    counting_sort.py
    def counting_sort(nums: list[int]) -> None:\n\"\"\"\u8ba1\u6570\u6392\u5e8f\"\"\"\n# \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\n# 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nm = max(nums)\n# 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n# counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\ncounter = [0] * (m + 1)\nfor num in nums:\ncounter[num] += 1\n# 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n# \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor i in range(m):\ncounter[i + 1] += counter[i]\n# 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n# \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nn = len(nums)\nres = [0] * n\nfor i in range(n - 1, -1, -1):\nnum = nums[i]\nres[counter[num] - 1] = num  # \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num] -= 1  # \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n# \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor i in range(n):\nnums[i] = res[i]\n
    counting_sort.go
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfunc countingSort(nums []int) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nm := 0\nfor _, num := range nums {\nif num > m {\nm = num\n}\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\ncounter := make([]int, m+1)\nfor _, num := range nums {\ncounter[num]++\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor i := 0; i < m; i++ {\ncounter[i+1] += counter[i]\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nn := len(nums)\nres := make([]int, n)\nfor i := n - 1; i >= 0; i-- {\nnum := nums[i]\n// \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\nres[counter[num]-1] = num\n// \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\ncounter[num]--\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\ncopy(nums, res)\n}\n
    counting_sort.js
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfunction countingSort(nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = 0;\nfor (const num of nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nconst counter = new Array(m + 1).fill(0);\nfor (const num of nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (let i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nconst n = nums.length;\nconst res = new Array(n);\nfor (let i = n - 1; i >= 0; i--) {\nconst num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--; // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (let i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n
    counting_sort.ts
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfunction countingSort(nums: number[]): void {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = 0;\nfor (const num of nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nconst counter: number[] = new Array<number>(m + 1).fill(0);\nfor (const num of nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (let i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nconst n = nums.length;\nconst res: number[] = new Array<number>(n);\nfor (let i = n - 1; i >= 0; i--) {\nconst num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--; // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (let i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n
    counting_sort.c
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nvoid countingSort(int nums[], int size) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int i = 0; i < size; i++) {\nif (nums[i] > m) {\nm = nums[i];\n}\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint *counter = malloc(sizeof(int) * m);\nfor (int i = 0; i < size; i++) {\ncounter[nums[i]]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (int i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nint *res = malloc(sizeof(int) * size);\nfor (int i = size - 1; i >= 0; i--) {\nint num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--;              // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nmemcpy(nums, res, size * sizeof(int));\n}\n
    counting_sort.cs
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nvoid countingSort(int[] nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nforeach (int num in nums) {\nm = Math.Max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint[] counter = new int[m + 1];\nforeach (int num in nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (int i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nint n = nums.Length;\nint[] res = new int[n];\nfor (int i = n - 1; i >= 0; i--) {\nint num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--; // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n
    counting_sort.swift
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfunc countingSort(nums: inout [Int]) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = nums.max()!\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nvar counter = Array(repeating: 0, count: m + 1)\nfor num in nums {\ncounter[num] += 1\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor i in stride(from: 0, to: m, by: 1) {\ncounter[i + 1] += counter[i]\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nvar res = Array(repeating: 0, count: nums.count)\nfor i in stride(from: nums.count - 1, through: 0, by: -1) {\nlet num = nums[i]\nres[counter[num] - 1] = num // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num] -= 1 // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor i in stride(from: 0, to: nums.count, by: 1) {\nnums[i] = res[i]\n}\n}\n
    counting_sort.zig
    [class]{}-[func]{countingSort}\n
    counting_sort.dart
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nvoid countingSort(List<int> nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num in nums) {\nm = max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nList<int> counter = List.filled(m + 1, 0);\nfor (int num in nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (int i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nint n = nums.length;\nList<int> res = List.filled(n, 0);\nfor (int i = n - 1; i >= 0; i--) {\nint num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--;              // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nnums.setAll(0, res);\n}\n
    "},{"location":"chapter_sorting/counting_sort/#1193","title":"11.9.3. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n + m)\\) \uff1a\u6d89\u53ca\u904d\u5386 nums \u548c\u904d\u5386 counter \uff0c\u90fd\u4f7f\u7528\u7ebf\u6027\u65f6\u95f4\u3002\u4e00\u822c\u60c5\u51b5\u4e0b \\(n \\gg m\\) \uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u8d8b\u4e8e \\(O(n)\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(n + m)\\) \u3001\u975e\u539f\u5730\u6392\u5e8f \uff1a\u501f\u52a9\u4e86\u957f\u5ea6\u5206\u522b\u4e3a \\(n\\) \u548c \\(m\\) \u7684\u6570\u7ec4 res \u548c counter \u3002
    • \u7a33\u5b9a\u6392\u5e8f\uff1a\u7531\u4e8e\u5411 res \u4e2d\u586b\u5145\u5143\u7d20\u7684\u987a\u5e8f\u662f\u201c\u4ece\u53f3\u5411\u5de6\u201d\u7684\uff0c\u56e0\u6b64\u5012\u5e8f\u904d\u5386 nums \u53ef\u4ee5\u907f\u514d\u6539\u53d8\u76f8\u7b49\u5143\u7d20\u4e4b\u95f4\u7684\u76f8\u5bf9\u4f4d\u7f6e\uff0c\u4ece\u800c\u5b9e\u73b0\u7a33\u5b9a\u6392\u5e8f\u3002\u5b9e\u9645\u4e0a\uff0c\u6b63\u5e8f\u904d\u5386 nums \u4e5f\u53ef\u4ee5\u5f97\u5230\u6b63\u786e\u7684\u6392\u5e8f\u7ed3\u679c\uff0c\u4f46\u7ed3\u679c\u662f\u975e\u7a33\u5b9a\u7684\u3002
    "},{"location":"chapter_sorting/counting_sort/#1194","title":"11.9.4. \u00a0 \u5c40\u9650\u6027","text":"

    \u770b\u5230\u8fd9\u91cc\uff0c\u4f60\u4e5f\u8bb8\u4f1a\u89c9\u5f97\u8ba1\u6570\u6392\u5e8f\u975e\u5e38\u5de7\u5999\uff0c\u4ec5\u901a\u8fc7\u7edf\u8ba1\u6570\u91cf\u5c31\u53ef\u4ee5\u5b9e\u73b0\u9ad8\u6548\u7684\u6392\u5e8f\u5de5\u4f5c\u3002\u7136\u800c\uff0c\u4f7f\u7528\u8ba1\u6570\u6392\u5e8f\u7684\u524d\u7f6e\u6761\u4ef6\u76f8\u5bf9\u8f83\u4e3a\u4e25\u683c\u3002

    \u8ba1\u6570\u6392\u5e8f\u53ea\u9002\u7528\u4e8e\u975e\u8d1f\u6574\u6570\u3002\u82e5\u60f3\u8981\u5c06\u5176\u7528\u4e8e\u5176\u4ed6\u7c7b\u578b\u7684\u6570\u636e\uff0c\u9700\u8981\u786e\u4fdd\u8fd9\u4e9b\u6570\u636e\u53ef\u4ee5\u88ab\u8f6c\u6362\u4e3a\u975e\u8d1f\u6574\u6570\uff0c\u5e76\u4e14\u5728\u8f6c\u6362\u8fc7\u7a0b\u4e2d\u4e0d\u80fd\u6539\u53d8\u5404\u4e2a\u5143\u7d20\u4e4b\u95f4\u7684\u76f8\u5bf9\u5927\u5c0f\u5173\u7cfb\u3002\u4f8b\u5982\uff0c\u5bf9\u4e8e\u5305\u542b\u8d1f\u6570\u7684\u6574\u6570\u6570\u7ec4\uff0c\u53ef\u4ee5\u5148\u7ed9\u6240\u6709\u6570\u5b57\u52a0\u4e0a\u4e00\u4e2a\u5e38\u6570\uff0c\u5c06\u5168\u90e8\u6570\u5b57\u8f6c\u5316\u4e3a\u6b63\u6570\uff0c\u6392\u5e8f\u5b8c\u6210\u540e\u518d\u8f6c\u6362\u56de\u53bb\u5373\u53ef\u3002

    \u8ba1\u6570\u6392\u5e8f\u9002\u7528\u4e8e\u6570\u636e\u91cf\u5927\u4f46\u6570\u636e\u8303\u56f4\u8f83\u5c0f\u7684\u60c5\u51b5\u3002\u6bd4\u5982\uff0c\u5728\u4e0a\u8ff0\u793a\u4f8b\u4e2d \\(m\\) \u4e0d\u80fd\u592a\u5927\uff0c\u5426\u5219\u4f1a\u5360\u7528\u8fc7\u591a\u7a7a\u95f4\u3002\u800c\u5f53 \\(n \\ll m\\) \u65f6\uff0c\u8ba1\u6570\u6392\u5e8f\u4f7f\u7528 \\(O(m)\\) \u65f6\u95f4\uff0c\u53ef\u80fd\u6bd4 \\(O(n \\log n)\\) \u7684\u6392\u5e8f\u7b97\u6cd5\u8fd8\u8981\u6162\u3002

    "},{"location":"chapter_sorting/heap_sort/","title":"11.7. \u00a0 \u5806\u6392\u5e8f","text":"

    Tip

    \u9605\u8bfb\u672c\u8282\u524d\uff0c\u8bf7\u786e\u4fdd\u5df2\u5b66\u5b8c\u300c\u5806\u300d\u7ae0\u8282\u3002

    \u300c\u5806\u6392\u5e8f Heap Sort\u300d\u662f\u4e00\u79cd\u57fa\u4e8e\u5806\u6570\u636e\u7ed3\u6784\u5b9e\u73b0\u7684\u9ad8\u6548\u6392\u5e8f\u7b97\u6cd5\u3002\u6211\u4eec\u53ef\u4ee5\u5229\u7528\u5df2\u7ecf\u5b66\u8fc7\u7684\u201c\u5efa\u5806\u64cd\u4f5c\u201d\u548c\u201c\u5143\u7d20\u51fa\u5806\u64cd\u4f5c\u201d\u5b9e\u73b0\u5806\u6392\u5e8f\uff1a

    1. \u8f93\u5165\u6570\u7ec4\u5e76\u5efa\u7acb\u5c0f\u9876\u5806\uff0c\u6b64\u65f6\u6700\u5c0f\u5143\u7d20\u4f4d\u4e8e\u5806\u9876\u3002
    2. \u4e0d\u65ad\u6267\u884c\u51fa\u5806\u64cd\u4f5c\uff0c\u4f9d\u6b21\u8bb0\u5f55\u51fa\u5806\u5143\u7d20\uff0c\u5373\u53ef\u5f97\u5230\u4ece\u5c0f\u5230\u5927\u6392\u5e8f\u7684\u5e8f\u5217\u3002

    \u4ee5\u4e0a\u65b9\u6cd5\u867d\u7136\u53ef\u884c\uff0c\u4f46\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u989d\u5916\u6570\u7ec4\u6765\u4fdd\u5b58\u5f39\u51fa\u7684\u5143\u7d20\uff0c\u6bd4\u8f83\u6d6a\u8d39\u7a7a\u95f4\u3002\u5728\u5b9e\u9645\u4e2d\uff0c\u6211\u4eec\u901a\u5e38\u4f7f\u7528\u4e00\u79cd\u66f4\u52a0\u4f18\u96c5\u7684\u5b9e\u73b0\u65b9\u5f0f\u3002

    "},{"location":"chapter_sorting/heap_sort/#1171","title":"11.7.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u8bbe\u6570\u7ec4\u7684\u957f\u5ea6\u4e3a \\(n\\) \uff0c\u5806\u6392\u5e8f\u7684\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u8f93\u5165\u6570\u7ec4\u5e76\u5efa\u7acb\u5927\u9876\u5806\u3002\u5b8c\u6210\u540e\uff0c\u6700\u5927\u5143\u7d20\u4f4d\u4e8e\u5806\u9876\u3002
    2. \u5c06\u5806\u9876\u5143\u7d20\uff08\u7b2c\u4e00\u4e2a\u5143\u7d20\uff09\u4e0e\u5806\u5e95\u5143\u7d20\uff08\u6700\u540e\u4e00\u4e2a\u5143\u7d20\uff09\u4ea4\u6362\u3002\u5b8c\u6210\u4ea4\u6362\u540e\uff0c\u5806\u7684\u957f\u5ea6\u51cf \\(1\\) \uff0c\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u52a0 \\(1\\) \u3002
    3. \u4ece\u5806\u9876\u5143\u7d20\u5f00\u59cb\uff0c\u4ece\u9876\u5230\u5e95\u6267\u884c\u5806\u5316\u64cd\u4f5c\uff08Sift Down\uff09\u3002\u5b8c\u6210\u5806\u5316\u540e\uff0c\u5806\u7684\u6027\u8d28\u5f97\u5230\u4fee\u590d\u3002
    4. \u5faa\u73af\u6267\u884c\u7b2c 2. \u548c 3. \u6b65\u3002\u5faa\u73af \\(n - 1\\) \u8f6e\u540e\uff0c\u5373\u53ef\u5b8c\u6210\u6570\u7ec4\u6392\u5e8f\u3002

    \u5b9e\u9645\u4e0a\uff0c\u5143\u7d20\u51fa\u5806\u64cd\u4f5c\u4e2d\u4e5f\u5305\u542b\u7b2c 2. \u548c 3. \u6b65\uff0c\u53ea\u662f\u591a\u4e86\u4e00\u4e2a\u5f39\u51fa\u5143\u7d20\u7684\u6b65\u9aa4\u3002

    <1><2><3><4><5><6><7><8><9><10><11><12>

    \u5728\u4ee3\u7801\u5b9e\u73b0\u4e2d\uff0c\u6211\u4eec\u4f7f\u7528\u4e86\u4e0e\u5806\u7ae0\u8282\u76f8\u540c\u7684\u4ece\u9876\u81f3\u5e95\u5806\u5316\uff08Sift Down\uff09\u7684\u51fd\u6570\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u7531\u4e8e\u5806\u7684\u957f\u5ea6\u4f1a\u968f\u7740\u63d0\u53d6\u6700\u5927\u5143\u7d20\u800c\u51cf\u5c0f\uff0c\u56e0\u6b64\u6211\u4eec\u9700\u8981\u7ed9 Sift Down \u51fd\u6570\u6dfb\u52a0\u4e00\u4e2a\u957f\u5ea6\u53c2\u6570 \\(n\\) \uff0c\u7528\u4e8e\u6307\u5b9a\u5806\u7684\u5f53\u524d\u6709\u6548\u957f\u5ea6\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart heap_sort.java
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int[] nums, int n, int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = 2 * i + 1;\nint r = 2 * i + 2;\nint ma = i;\nif (l < n && nums[l] > nums[ma])\nma = l;\nif (r < n && nums[r] > nums[ma])\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i)\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nint temp = nums[i];\nnums[i] = nums[ma];\nnums[ma] = temp;\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nvoid heapSort(int[] nums) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = nums.length / 2 - 1; i >= 0; i--) {\nsiftDown(nums, nums.length, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (int i = nums.length - 1; i > 0; i--) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nint tmp = nums[0];\nnums[0] = nums[i];\nnums[i] = tmp;\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.cpp
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(vector<int> &nums, int n, int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = 2 * i + 1;\nint r = 2 * i + 2;\nint ma = i;\nif (l < n && nums[l] > nums[ma])\nma = l;\nif (r < n && nums[r] > nums[ma])\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(nums[i], nums[ma]);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nvoid heapSort(vector<int> &nums) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = nums.size() / 2 - 1; i >= 0; --i) {\nsiftDown(nums, nums.size(), i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (int i = nums.size() - 1; i > 0; --i) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(nums[0], nums[i]);\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.py
    def sift_down(nums: list[int], n: int, i: int):\n\"\"\"\u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\"\"\"\nwhile True:\n# \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nl = 2 * i + 1\nr = 2 * i + 2\nma = i\nif l < n and nums[l] > nums[ma]:\nma = l\nif r < n and nums[r] > nums[ma]:\nma = r\n# \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif ma == i:\nbreak\n# \u4ea4\u6362\u4e24\u8282\u70b9\nnums[i], nums[ma] = nums[ma], nums[i]\n# \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma\ndef heap_sort(nums: list[int]):\n\"\"\"\u5806\u6392\u5e8f\"\"\"\n# \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor i in range(len(nums) // 2 - 1, -1, -1):\nsift_down(nums, len(nums), i)\n# \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor i in range(len(nums) - 1, 0, -1):\n# \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nnums[0], nums[i] = nums[i], nums[0]\n# \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsift_down(nums, i, 0)\n
    heap_sort.go
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc siftDown(nums *[]int, n, i int) {\nfor true {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nl := 2*i + 1\nr := 2*i + 2\nma := i\nif l < n && (*nums)[l] > (*nums)[ma] {\nma = l\n}\nif r < n && (*nums)[r] > (*nums)[ma] {\nma = r\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif ma == i {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\n(*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma\n}\n}\n/* \u5806\u6392\u5e8f */\nfunc heapSort(nums *[]int) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor i := len(*nums)/2 - 1; i >= 0; i-- {\nsiftDown(nums, len(*nums), i)\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor i := len(*nums) - 1; i > 0; i-- {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n(*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0)\n}\n}\n
    heap_sort.js
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunction siftDown(nums, n, i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nlet l = 2 * i + 1;\nlet r = 2 * i + 2;\nlet ma = i;\nif (l < n && nums[l] > nums[ma]) {\nma = l;\n}\nif (r < n && nums[r] > nums[ma]) {\nma = r;\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma === i) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\n[nums[i], nums[ma]] = [nums[ma], nums[i]];\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nfunction heapSort(nums) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {\nsiftDown(nums, nums.length, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n[nums[0], nums[i]] = [nums[i], nums[0]];\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.ts
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunction siftDown(nums: number[], n: number, i: number): void {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nlet l = 2 * i + 1;\nlet r = 2 * i + 2;\nlet ma = i;\nif (l < n && nums[l] > nums[ma]) {\nma = l;\n}\nif (r < n && nums[r] > nums[ma]) {\nma = r;\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma === i) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\n[nums[i], nums[ma]] = [nums[ma], nums[i]];\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nfunction heapSort(nums: number[]): void {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {\nsiftDown(nums, nums.length, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n[nums[0], nums[i]] = [nums[i], nums[0]];\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.c
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int nums[], int n, int i) {\nwhile (1) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = 2 * i + 1;\nint r = 2 * i + 2;\nint ma = i;\nif (l < n && nums[l] > nums[ma])\nma = l;\nif (r < n && nums[r] > nums[ma])\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nint temp = nums[i];\nnums[i] = nums[ma];\nnums[ma] = temp;\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nvoid heapSort(int nums[], int n) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = n / 2 - 1; i >= 0; --i) {\nsiftDown(nums, n, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (int i = n - 1; i > 0; --i) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nint tmp = nums[0];\nnums[0] = nums[i];\nnums[i] = tmp;\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.cs
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int[] nums, int n, int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = 2 * i + 1;\nint r = 2 * i + 2;\nint ma = i;\nif (l < n && nums[l] > nums[ma])\nma = l;\nif (r < n && nums[r] > nums[ma])\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i)\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\n(nums[ma], nums[i]) = (nums[i], nums[ma]);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nvoid heapSort(int[] nums) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = nums.Length / 2 - 1; i >= 0; i--) {\nsiftDown(nums, nums.Length, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (int i = nums.Length - 1; i > 0; i--) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n(nums[i], nums[0]) = (nums[0], nums[i]);\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.swift
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc siftDown(nums: inout [Int], n: Int, i: Int) {\nvar i = i\nwhile true {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nlet l = 2 * i + 1\nlet r = 2 * i + 2\nvar ma = i\nif l < n, nums[l] > nums[ma] {\nma = l\n}\nif r < n, nums[r] > nums[ma] {\nma = r\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif ma == i {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nnums.swapAt(i, ma)\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma\n}\n}\n/* \u5806\u6392\u5e8f */\nfunc heapSort(nums: inout [Int]) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\nsiftDown(nums: &nums, n: nums.count, i: i)\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor i in stride(from: nums.count - 1, to: 0, by: -1) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nnums.swapAt(0, i)\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums: &nums, n: i, i: 0)\n}\n}\n
    heap_sort.zig
    [class]{}-[func]{siftDown}\n[class]{}-[func]{heapSort}\n
    heap_sort.dart
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(List<int> nums, int n, int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = 2 * i + 1;\nint r = 2 * i + 2;\nint ma = i;\nif (l < n && nums[l] > nums[ma]) ma = l;\nif (r < n && nums[r] > nums[ma]) ma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nint temp = nums[i];\nnums[i] = nums[ma];\nnums[ma] = temp;\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nvoid heapSort(List<int> nums) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = nums.length ~/ 2 - 1; i >= 0; i--) {\nsiftDown(nums, nums.length, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (int i = nums.length - 1; i > 0; i--) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nint tmp = nums[0];\nnums[0] = nums[i];\nnums[i] = tmp;\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    "},{"location":"chapter_sorting/heap_sort/#1172","title":"11.7.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n \\log n)\\) \u3001\u975e\u81ea\u9002\u5e94\u6392\u5e8f \uff1a\u5efa\u5806\u64cd\u4f5c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002\u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \uff0c\u5171\u5faa\u73af \\(n - 1\\) \u8f6e\u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(1)\\) \u3001\u539f\u5730\u6392\u5e8f \uff1a\u51e0\u4e2a\u6307\u9488\u53d8\u91cf\u4f7f\u7528 \\(O(1)\\) \u7a7a\u95f4\u3002\u5143\u7d20\u4ea4\u6362\u548c\u5806\u5316\u64cd\u4f5c\u90fd\u662f\u5728\u539f\u6570\u7ec4\u4e0a\u8fdb\u884c\u7684\u3002
    • \u975e\u7a33\u5b9a\u6392\u5e8f\uff1a\u5728\u4ea4\u6362\u5806\u9876\u5143\u7d20\u548c\u5806\u5e95\u5143\u7d20\u65f6\uff0c\u76f8\u7b49\u5143\u7d20\u7684\u76f8\u5bf9\u4f4d\u7f6e\u53ef\u80fd\u53d1\u751f\u53d8\u5316\u3002
    "},{"location":"chapter_sorting/insertion_sort/","title":"11.4. \u00a0 \u63d2\u5165\u6392\u5e8f","text":"

    \u300c\u63d2\u5165\u6392\u5e8f Insertion Sort\u300d\u662f\u4e00\u79cd\u7b80\u5355\u7684\u6392\u5e8f\u7b97\u6cd5\uff0c\u5b83\u7684\u5de5\u4f5c\u539f\u7406\u4e0e\u624b\u52a8\u6574\u7406\u4e00\u526f\u724c\u7684\u8fc7\u7a0b\u975e\u5e38\u76f8\u4f3c\u3002

    \u5177\u4f53\u6765\u8bf4\uff0c\u6211\u4eec\u5728\u672a\u6392\u5e8f\u533a\u95f4\u9009\u62e9\u4e00\u4e2a\u57fa\u51c6\u5143\u7d20\uff0c\u5c06\u8be5\u5143\u7d20\u4e0e\u5176\u5de6\u4fa7\u5df2\u6392\u5e8f\u533a\u95f4\u7684\u5143\u7d20\u9010\u4e00\u6bd4\u8f83\u5927\u5c0f\uff0c\u5e76\u5c06\u8be5\u5143\u7d20\u63d2\u5165\u5230\u6b63\u786e\u7684\u4f4d\u7f6e\u3002

    \u56de\u5fc6\u6570\u7ec4\u7684\u5143\u7d20\u63d2\u5165\u64cd\u4f5c\uff0c\u8bbe\u57fa\u51c6\u5143\u7d20\u4e3a base \uff0c\u6211\u4eec\u9700\u8981\u5c06\u4ece\u76ee\u6807\u7d22\u5f15\u5230 base \u4e4b\u95f4\u7684\u6240\u6709\u5143\u7d20\u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\uff0c\u7136\u540e\u518d\u5c06 base \u8d4b\u503c\u7ed9\u76ee\u6807\u7d22\u5f15\u3002

    Fig. \u5355\u6b21\u63d2\u5165\u64cd\u4f5c

    "},{"location":"chapter_sorting/insertion_sort/#1141","title":"11.4.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u63d2\u5165\u6392\u5e8f\u7684\u6574\u4f53\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u521d\u59cb\u72b6\u6001\u4e0b\uff0c\u6570\u7ec4\u7684\u7b2c 1 \u4e2a\u5143\u7d20\u5df2\u5b8c\u6210\u6392\u5e8f\u3002
    2. \u9009\u53d6\u6570\u7ec4\u7684\u7b2c 2 \u4e2a\u5143\u7d20\u4f5c\u4e3a base \uff0c\u5c06\u5176\u63d2\u5165\u5230\u6b63\u786e\u4f4d\u7f6e\u540e\uff0c\u6570\u7ec4\u7684\u524d 2 \u4e2a\u5143\u7d20\u5df2\u6392\u5e8f\u3002
    3. \u9009\u53d6\u7b2c 3 \u4e2a\u5143\u7d20\u4f5c\u4e3a base \uff0c\u5c06\u5176\u63d2\u5165\u5230\u6b63\u786e\u4f4d\u7f6e\u540e\uff0c\u6570\u7ec4\u7684\u524d 3 \u4e2a\u5143\u7d20\u5df2\u6392\u5e8f\u3002
    4. \u4ee5\u6b64\u7c7b\u63a8\uff0c\u5728\u6700\u540e\u4e00\u8f6e\u4e2d\uff0c\u9009\u53d6\u6700\u540e\u4e00\u4e2a\u5143\u7d20\u4f5c\u4e3a base \uff0c\u5c06\u5176\u63d2\u5165\u5230\u6b63\u786e\u4f4d\u7f6e\u540e\uff0c\u6240\u6709\u5143\u7d20\u5747\u5df2\u6392\u5e8f\u3002

    Fig. \u63d2\u5165\u6392\u5e8f\u6d41\u7a0b

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart insertion_sort.java
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (int i = 1; i < nums.length; i++) {\nint base = nums[i], j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = base;        // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.cpp
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(vector<int> &nums) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (int i = 1; i < nums.size(); i++) {\nint base = nums[i], j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.py
    def insertion_sort(nums: list[int]) -> None:\n\"\"\"\u63d2\u5165\u6392\u5e8f\"\"\"\n# \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\nfor i in range(1, len(nums)):\nbase = nums[i]\nj = i - 1\n# \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u533a\u95f4 [0, i-1] \u4e2d\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile j >= 0 and nums[j] > base:\nnums[j + 1] = nums[j]  # \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj -= 1\nnums[j + 1] = base  # \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n
    insertion_sort.go
    /* \u63d2\u5165\u6392\u5e8f */\nfunc insertionSort(nums []int) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i := 1; i < len(nums); i++ {\nbase := nums[i]\nj := i - 1\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nfor j >= 0 && nums[j] > base {\nnums[j+1] = nums[j] // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--\n}\nnums[j+1] = base // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.js
    /* \u63d2\u5165\u6392\u5e8f */\nfunction insertionSort(nums) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (let i = 1; i < nums.length; i++) {\nlet base = nums[i],\nj = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.ts
    /* \u63d2\u5165\u6392\u5e8f */\nfunction insertionSort(nums: number[]): void {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (let i = 1; i < nums.length; i++) {\nconst base = nums[i];\nlet j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.c
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(int nums[], int size) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (int i = 1; i < size; i++) {\nint base = nums[i], j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\n// \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nnums[j + 1] = nums[j];\nj--;\n}\n// \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\nnums[j + 1] = base;\n}\n}\n
    insertion_sort.cs
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (int i = 1; i < nums.Length; i++) {\nint bas = nums[i], j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > bas) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = bas;         // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.swift
    /* \u63d2\u5165\u6392\u5e8f */\nfunc insertionSort(nums: inout [Int]) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor i in stride(from: 1, to: nums.count, by: 1) {\nlet base = nums[i]\nvar j = i - 1\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile j >= 0, nums[j] > base {\nnums[j + 1] = nums[j] // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj -= 1\n}\nnums[j + 1] = base // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.zig
    // \u63d2\u5165\u6392\u5e8f\nfn insertionSort(nums: []i32) void {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nvar i: usize = 1;\nwhile (i < nums.len) : (i += 1) {\nvar base = nums[i];\nvar j: usize = i;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 1 and nums[j - 1] > base) : (j -= 1) {\nnums[j] = nums[j - 1];  // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n}\nnums[j] = base;             // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.dart
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(List<int> nums) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (int i = 1; i < nums.length; i++) {\nint base = nums[i], j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    "},{"location":"chapter_sorting/insertion_sort/#1142","title":"11.4.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n^2)\\) \u3001\u81ea\u9002\u5e94\u6392\u5e8f \uff1a\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u6bcf\u6b21\u63d2\u5165\u64cd\u4f5c\u5206\u522b\u9700\u8981\u5faa\u73af \\(n - 1\\) , \\(n-2\\) , \\(\\cdots\\) , \\(2\\) , \\(1\\) \u6b21\uff0c\u6c42\u548c\u5f97\u5230 \\(\\frac{(n - 1) n}{2}\\) \uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002\u5728\u9047\u5230\u6709\u5e8f\u6570\u636e\u65f6\uff0c\u63d2\u5165\u64cd\u4f5c\u4f1a\u63d0\u524d\u7ec8\u6b62\u3002\u5f53\u8f93\u5165\u6570\u7ec4\u5b8c\u5168\u6709\u5e8f\u65f6\uff0c\u63d2\u5165\u6392\u5e8f\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n)\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(1)\\) \u3001\u539f\u5730\u6392\u5e8f \uff1a\u6307\u9488 \\(i\\) , \\(j\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u7a33\u5b9a\u6392\u5e8f\uff1a\u5728\u63d2\u5165\u64cd\u4f5c\u8fc7\u7a0b\u4e2d\uff0c\u6211\u4eec\u4f1a\u5c06\u5143\u7d20\u63d2\u5165\u5230\u76f8\u7b49\u5143\u7d20\u7684\u53f3\u4fa7\uff0c\u4e0d\u4f1a\u6539\u53d8\u5b83\u4eec\u7684\u987a\u5e8f\u3002
    "},{"location":"chapter_sorting/insertion_sort/#1143","title":"11.4.3. \u00a0 \u63d2\u5165\u6392\u5e8f\u4f18\u52bf","text":"

    \u63d2\u5165\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff0c\u800c\u6211\u4eec\u5373\u5c06\u5b66\u4e60\u7684\u5feb\u901f\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002\u5c3d\u7ba1\u63d2\u5165\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u76f8\u6bd4\u5feb\u901f\u6392\u5e8f\u66f4\u9ad8\uff0c\u4f46\u5728\u6570\u636e\u91cf\u8f83\u5c0f\u7684\u60c5\u51b5\u4e0b\uff0c\u63d2\u5165\u6392\u5e8f\u901a\u5e38\u66f4\u5feb\u3002

    \u8fd9\u4e2a\u7ed3\u8bba\u4e0e\u7ebf\u6027\u67e5\u627e\u548c\u4e8c\u5206\u67e5\u627e\u7684\u9002\u7528\u60c5\u51b5\u7684\u7ed3\u8bba\u7c7b\u4f3c\u3002\u5feb\u901f\u6392\u5e8f\u8fd9\u7c7b \\(O(n \\log n)\\) \u7684\u7b97\u6cd5\u5c5e\u4e8e\u57fa\u4e8e\u5206\u6cbb\u7684\u6392\u5e8f\u7b97\u6cd5\uff0c\u5f80\u5f80\u5305\u542b\u66f4\u591a\u5355\u5143\u8ba1\u7b97\u64cd\u4f5c\u3002\u800c\u5728\u6570\u636e\u91cf\u8f83\u5c0f\u65f6\uff0c\\(n^2\\) \u548c \\(n \\log n\\) \u7684\u6570\u503c\u6bd4\u8f83\u63a5\u8fd1\uff0c\u590d\u6742\u5ea6\u4e0d\u5360\u4e3b\u5bfc\u4f5c\u7528\uff1b\u6bcf\u8f6e\u4e2d\u7684\u5355\u5143\u8ba1\u7b97\u64cd\u4f5c\u6570\u91cf\u8d77\u5230\u51b3\u5b9a\u6027\u56e0\u7d20\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\uff08\u4f8b\u5982 Java\uff09\u7684\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\u90fd\u91c7\u7528\u4e86\u63d2\u5165\u6392\u5e8f\uff0c\u5927\u81f4\u601d\u8def\u4e3a\uff1a\u5bf9\u4e8e\u957f\u6570\u7ec4\uff0c\u91c7\u7528\u57fa\u4e8e\u5206\u6cbb\u7684\u6392\u5e8f\u7b97\u6cd5\uff0c\u4f8b\u5982\u5feb\u901f\u6392\u5e8f\uff1b\u5bf9\u4e8e\u77ed\u6570\u7ec4\uff0c\u76f4\u63a5\u4f7f\u7528\u63d2\u5165\u6392\u5e8f\u3002

    \u867d\u7136\u5192\u6ce1\u6392\u5e8f\u3001\u9009\u62e9\u6392\u5e8f\u548c\u63d2\u5165\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(n^2)\\) \uff0c\u4f46\u5728\u5b9e\u9645\u60c5\u51b5\u4e2d\uff0c\u63d2\u5165\u6392\u5e8f\u7684\u4f7f\u7528\u9891\u7387\u663e\u8457\u9ad8\u4e8e\u5192\u6ce1\u6392\u5e8f\u548c\u9009\u62e9\u6392\u5e8f\u3002\u8fd9\u662f\u56e0\u4e3a\uff1a

    • \u5192\u6ce1\u6392\u5e8f\u57fa\u4e8e\u5143\u7d20\u4ea4\u6362\u5b9e\u73b0\uff0c\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u4e34\u65f6\u53d8\u91cf\uff0c\u5171\u6d89\u53ca 3 \u4e2a\u5355\u5143\u64cd\u4f5c\uff1b\u63d2\u5165\u6392\u5e8f\u57fa\u4e8e\u5143\u7d20\u8d4b\u503c\u5b9e\u73b0\uff0c\u4ec5\u9700 1 \u4e2a\u5355\u5143\u64cd\u4f5c\u3002\u56e0\u6b64\uff0c\u5192\u6ce1\u6392\u5e8f\u7684\u8ba1\u7b97\u5f00\u9500\u901a\u5e38\u6bd4\u63d2\u5165\u6392\u5e8f\u66f4\u9ad8\u3002
    • \u9009\u62e9\u6392\u5e8f\u5728\u4efb\u4f55\u60c5\u51b5\u4e0b\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(n^2)\\) \u3002\u5982\u679c\u7ed9\u5b9a\u4e00\u7ec4\u90e8\u5206\u6709\u5e8f\u7684\u6570\u636e\uff0c\u63d2\u5165\u6392\u5e8f\u901a\u5e38\u6bd4\u9009\u62e9\u6392\u5e8f\u6548\u7387\u66f4\u9ad8\u3002
    • \u9009\u62e9\u6392\u5e8f\u4e0d\u7a33\u5b9a\uff0c\u65e0\u6cd5\u5e94\u7528\u4e8e\u591a\u7ea7\u6392\u5e8f\u3002
    "},{"location":"chapter_sorting/merge_sort/","title":"11.6. \u00a0 \u5f52\u5e76\u6392\u5e8f","text":"

    \u300c\u5f52\u5e76\u6392\u5e8f Merge Sort\u300d\u57fa\u4e8e\u5206\u6cbb\u601d\u60f3\u5b9e\u73b0\u6392\u5e8f\uff0c\u5305\u542b\u201c\u5212\u5206\u201d\u548c\u201c\u5408\u5e76\u201d\u4e24\u4e2a\u9636\u6bb5\uff1a

    1. \u5212\u5206\u9636\u6bb5\uff1a\u901a\u8fc7\u9012\u5f52\u4e0d\u65ad\u5730\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5904\u5206\u5f00\uff0c\u5c06\u957f\u6570\u7ec4\u7684\u6392\u5e8f\u95ee\u9898\u8f6c\u6362\u4e3a\u77ed\u6570\u7ec4\u7684\u6392\u5e8f\u95ee\u9898\uff1b
    2. \u5408\u5e76\u9636\u6bb5\uff1a\u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u5212\u5206\uff0c\u5f00\u59cb\u5408\u5e76\uff0c\u6301\u7eed\u5730\u5c06\u5de6\u53f3\u4e24\u4e2a\u8f83\u77ed\u7684\u6709\u5e8f\u6570\u7ec4\u5408\u5e76\u4e3a\u4e00\u4e2a\u8f83\u957f\u7684\u6709\u5e8f\u6570\u7ec4\uff0c\u76f4\u81f3\u7ed3\u675f\uff1b

    Fig. \u5f52\u5e76\u6392\u5e8f\u7684\u5212\u5206\u4e0e\u5408\u5e76\u9636\u6bb5

    "},{"location":"chapter_sorting/merge_sort/#1161","title":"11.6.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u201c\u5212\u5206\u9636\u6bb5\u201d\u4ece\u9876\u81f3\u5e95\u9012\u5f52\u5730\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5207\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u76f4\u81f3\u957f\u5ea6\u4e3a 1 \uff1b

    1. \u8ba1\u7b97\u6570\u7ec4\u4e2d\u70b9 mid \uff0c\u9012\u5f52\u5212\u5206\u5de6\u5b50\u6570\u7ec4\uff08\u533a\u95f4 [left, mid] \uff09\u548c\u53f3\u5b50\u6570\u7ec4\uff08\u533a\u95f4 [mid + 1, right] \uff09\uff1b
    2. \u9012\u5f52\u6267\u884c\u6b65\u9aa4 1. \uff0c\u76f4\u81f3\u5b50\u6570\u7ec4\u533a\u95f4\u957f\u5ea6\u4e3a 1 \u65f6\uff0c\u7ec8\u6b62\u9012\u5f52\u5212\u5206\uff1b

    \u201c\u5408\u5e76\u9636\u6bb5\u201d\u4ece\u5e95\u81f3\u9876\u5730\u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u5408\u5e76\u4e3a\u4e00\u4e2a\u6709\u5e8f\u6570\u7ec4\u3002\u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u4ece\u957f\u5ea6\u4e3a 1 \u7684\u5b50\u6570\u7ec4\u5f00\u59cb\u5408\u5e76\uff0c\u5408\u5e76\u9636\u6bb5\u4e2d\u7684\u6bcf\u4e2a\u5b50\u6570\u7ec4\u90fd\u662f\u6709\u5e8f\u7684\u3002

    <1><2><3><4><5><6><7><8><9><10>

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u5f52\u5e76\u6392\u5e8f\u7684\u9012\u5f52\u987a\u5e8f\u4e0e\u4e8c\u53c9\u6811\u7684\u540e\u5e8f\u904d\u5386\u76f8\u540c\uff0c\u5177\u4f53\u6765\u770b\uff1a

    • \u540e\u5e8f\u904d\u5386\uff1a\u5148\u9012\u5f52\u5de6\u5b50\u6811\uff0c\u518d\u9012\u5f52\u53f3\u5b50\u6811\uff0c\u6700\u540e\u5904\u7406\u6839\u8282\u70b9\u3002
    • \u5f52\u5e76\u6392\u5e8f\uff1a\u5148\u9012\u5f52\u5de6\u5b50\u6570\u7ec4\uff0c\u518d\u9012\u5f52\u53f3\u5b50\u6570\u7ec4\uff0c\u6700\u540e\u5904\u7406\u5408\u5e76\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart merge_sort.java
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nvoid merge(int[] nums, int left, int mid, int right) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nint[] tmp = Arrays.copyOfRange(nums, left, right + 1);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint leftStart = left - left, leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint rightStart = mid + 1 - left, rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nint i = leftStart, j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (int k = left; k <= right; k++) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd)\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if (j > rightEnd || tmp[i] <= tmp[j])\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse\nnums[k] = tmp[j++];\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(int[] nums, int left, int right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right)\nreturn;                      // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nint mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.cpp
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nvoid merge(vector<int> &nums, int left, int mid, int right) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nvector<int> tmp(nums.begin() + left, nums.begin() + right + 1);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint leftStart = left - left, leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint rightStart = mid + 1 - left, rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nint i = leftStart, j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (int k = left; k <= right; k++) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd)\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if (j > rightEnd || tmp[i] <= tmp[j])\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse\nnums[k] = tmp[j++];\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(vector<int> &nums, int left, int right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right)\nreturn; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nint mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.py
    def merge(nums: list[int], left: int, mid: int, right: int) -> None:\n\"\"\"\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\"\"\"\n# \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n# \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\n# \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\ntmp = list(nums[left : right + 1])\n# \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nleft_start = 0\nleft_end = mid - left\n# \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nright_start = mid + 1 - left\nright_end = right - left\n# i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\ni = left_start\nj = right_start\n# \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor k in range(left, right + 1):\n# \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif i > left_end:\nnums[k] = tmp[j]\nj += 1\n# \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelif j > right_end or tmp[i] <= tmp[j]:\nnums[k] = tmp[i]\ni += 1\n# \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse:\nnums[k] = tmp[j]\nj += 1\ndef merge_sort(nums: list[int], left: int, right: int) -> None:\n\"\"\"\u5f52\u5e76\u6392\u5e8f\"\"\"\n# \u7ec8\u6b62\u6761\u4ef6\nif left >= right:\nreturn  # \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n# \u5212\u5206\u9636\u6bb5\nmid = (left + right) // 2  # \u8ba1\u7b97\u4e2d\u70b9\nmerge_sort(nums, left, mid)  # \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmerge_sort(nums, mid + 1, right)  # \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n# \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right)\n
    merge_sort.go
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nfunc merge(nums []int, left, mid, right int) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4 \u501f\u52a9 copy \u6a21\u5757\ntmp := make([]int, right-left+1)\nfor i := left; i <= right; i++ {\ntmp[i-left] = nums[i]\n}\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nleftStart, leftEnd := left-left, mid-left\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nrightStart, rightEnd := mid+1-left, right-left\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\ni, j := leftStart, rightStart\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor k := left; k <= right; k++ {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif i > leftEnd {\nnums[k] = tmp[j]\nj++\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\n} else if j > rightEnd || tmp[i] <= tmp[j] {\nnums[k] = tmp[i]\ni++\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\n} else {\nnums[k] = tmp[j]\nj++\n}\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nfunc mergeSort(nums []int, left, right int) {\n// \u7ec8\u6b62\u6761\u4ef6\nif left >= right {\nreturn\n}\n// \u5212\u5206\u9636\u6bb5\nmid := (left + right) / 2\nmergeSort(nums, left, mid)\nmergeSort(nums, mid+1, right)\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right)\n}\n
    merge_sort.js
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nfunction merge(nums, left, mid, right) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nlet tmp = nums.slice(left, right + 1);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet leftStart = left - left,\nleftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet rightStart = mid + 1 - left,\nrightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nlet i = leftStart,\nj = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (let k = left; k <= right; k++) {\nif (i > leftEnd) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nnums[k] = tmp[j++];\n} else if (j > rightEnd || tmp[i] <= tmp[j]) {\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nnums[k] = tmp[i++];\n} else {\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nnums[k] = tmp[j++];\n}\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nfunction mergeSort(nums, left, right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nlet mid = Math.floor((left + right) / 2); // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.ts
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nlet tmp = nums.slice(left, right + 1);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet leftStart = left - left,\nleftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet rightStart = mid + 1 - left,\nrightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nlet i = leftStart,\nj = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (let k = left; k <= right; k++) {\nif (i > leftEnd) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\n} else if (j > rightEnd || tmp[i] <= tmp[j]) {\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\n} else {\nnums[k] = tmp[j++];\n}\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nlet mid = Math.floor((left + right) / 2); // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.c
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nvoid merge(int *nums, int left, int mid, int right) {\nint index;\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nint tmp[right + 1 - left];\nfor (index = left; index < right + 1; index++) {\ntmp[index - left] = nums[index];\n}\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint leftStart = left - left, leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint rightStart = mid + 1 - left, rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nint i = leftStart, j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (int k = left; k <= right; k++) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd)\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if (j > rightEnd || tmp[i] <= tmp[j])\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse\nnums[k] = tmp[j++];\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(int *nums, int left, int right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right)\nreturn; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nint mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.cs
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nvoid merge(int[] nums, int left, int mid, int right) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nint[] tmp = nums[left..(right + 1)];\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15  \nint leftStart = left - left, leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15       \nint rightStart = mid + 1 - left, rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nint i = leftStart, j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (int k = left; k <= right; k++) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd)\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if (j > rightEnd || tmp[i] <= tmp[j])\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse\nnums[k] = tmp[j++];\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(int[] nums, int left, int right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right) return;       // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nint mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.swift
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nlet tmp = Array(nums[left ..< (right + 1)])\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet leftStart = left - left\nlet leftEnd = mid - left\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet rightStart = mid + 1 - left\nlet rightEnd = right - left\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nvar i = leftStart\nvar j = rightStart\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor k in left ... right {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif i > leftEnd {\nnums[k] = tmp[j]\nj += 1\n}\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if j > rightEnd || tmp[i] <= tmp[j] {\nnums[k] = tmp[i]\ni += 1\n}\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse {\nnums[k] = tmp[j]\nj += 1\n}\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n// \u7ec8\u6b62\u6761\u4ef6\nif left >= right { // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nreturn\n}\n// \u5212\u5206\u9636\u6bb5\nlet mid = (left + right) / 2 // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums: &nums, left: left, right: mid) // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums: &nums, left: mid + 1, right: right) // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums: &nums, left: left, mid: mid, right: right)\n}\n
    merge_sort.zig
    // \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nfn merge(nums: []i32, left: usize, mid: usize, right: usize) !void {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nvar mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);\ndefer mem_arena.deinit();\nconst mem_allocator = mem_arena.allocator();\nvar tmp = try mem_allocator.alloc(i32, right + 1 - left);\nstd.mem.copy(i32, tmp, nums[left..right+1]);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15  \nvar leftStart = left - left;\nvar leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15       \nvar rightStart = mid + 1 - left;\nvar rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nvar i = leftStart;\nvar j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nvar k = left;\nwhile (k <= right) : (k += 1) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd) {\nnums[k] = tmp[j];\nj += 1;\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\n} else if  (j > rightEnd or tmp[i] <= tmp[j]) {\nnums[k] = tmp[i];\ni += 1;\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\n} else {\nnums[k] = tmp[j];\nj += 1;\n}\n}\n}\n// \u5f52\u5e76\u6392\u5e8f\nfn mergeSort(nums: []i32, left: usize, right: usize) !void {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right) return;              // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nvar mid = (left + right) / 2;           // \u8ba1\u7b97\u4e2d\u70b9\ntry mergeSort(nums, left, mid);         // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\ntry mergeSort(nums, mid + 1, right);    // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\ntry merge(nums, left, mid, right);\n}\n
    merge_sort.dart
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nvoid merge(List<int> nums, int left, int mid, int right) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nList<int> tmp = nums.sublist(left, right + 1);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint leftStart = left - left, leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint rightStart = mid + 1 - left, rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nint i = leftStart, j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (int k = left; k <= right; k++) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd)\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if (j > rightEnd || tmp[i] <= tmp[j])\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse\nnums[k] = tmp[j++];\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(List<int> nums, int left, int right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nint mid = (left + right) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n

    \u5408\u5e76\u65b9\u6cd5 merge() \u4ee3\u7801\u4e2d\u7684\u96be\u70b9\u5305\u62ec\uff1a

    • \u5728\u9605\u8bfb\u4ee3\u7801\u65f6\uff0c\u9700\u8981\u7279\u522b\u6ce8\u610f\u5404\u4e2a\u53d8\u91cf\u7684\u542b\u4e49\u3002nums \u7684\u5f85\u5408\u5e76\u533a\u95f4\u4e3a [left, right] \uff0c\u4f46\u7531\u4e8e tmp \u4ec5\u590d\u5236\u4e86 nums \u8be5\u533a\u95f4\u7684\u5143\u7d20\uff0c\u56e0\u6b64 tmp \u5bf9\u5e94\u533a\u95f4\u4e3a [0, right - left] \u3002
    • \u5728\u6bd4\u8f83 tmp[i] \u548c tmp[j] \u7684\u5927\u5c0f\u65f6\uff0c\u8fd8\u9700\u8003\u8651\u5b50\u6570\u7ec4\u904d\u5386\u5b8c\u6210\u540e\u7684\u7d22\u5f15\u8d8a\u754c\u95ee\u9898\uff0c\u5373 i > leftEnd \u548c j > rightEnd \u7684\u60c5\u51b5\u3002\u7d22\u5f15\u8d8a\u754c\u7684\u4f18\u5148\u7ea7\u662f\u6700\u9ad8\u7684\uff0c\u5982\u679c\u5de6\u5b50\u6570\u7ec4\u5df2\u7ecf\u88ab\u5408\u5e76\u5b8c\u4e86\uff0c\u90a3\u4e48\u4e0d\u9700\u8981\u7ee7\u7eed\u6bd4\u8f83\uff0c\u76f4\u63a5\u5408\u5e76\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u5373\u53ef\u3002
    "},{"location":"chapter_sorting/merge_sort/#1162","title":"11.6.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n \\log n)\\) \u3001\u975e\u81ea\u9002\u5e94\u6392\u5e8f \uff1a\u5212\u5206\u4ea7\u751f\u9ad8\u5ea6\u4e3a \\(\\log n\\) \u7684\u9012\u5f52\u6811\uff0c\u6bcf\u5c42\u5408\u5e76\u7684\u603b\u64cd\u4f5c\u6570\u91cf\u4e3a \\(n\\) \uff0c\u56e0\u6b64\u603b\u4f53\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(n)\\) \u3001\u975e\u539f\u5730\u6392\u5e8f \uff1a\u9012\u5f52\u6df1\u5ea6\u4e3a \\(\\log n\\) \uff0c\u4f7f\u7528 \\(O(\\log n)\\) \u5927\u5c0f\u7684\u6808\u5e27\u7a7a\u95f4\u3002\u5408\u5e76\u64cd\u4f5c\u9700\u8981\u501f\u52a9\u8f85\u52a9\u6570\u7ec4\u5b9e\u73b0\uff0c\u4f7f\u7528 \\(O(n)\\) \u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u7a33\u5b9a\u6392\u5e8f\uff1a\u5728\u5408\u5e76\u8fc7\u7a0b\u4e2d\uff0c\u76f8\u7b49\u5143\u7d20\u7684\u6b21\u5e8f\u4fdd\u6301\u4e0d\u53d8\u3002
    "},{"location":"chapter_sorting/merge_sort/#1163","title":"11.6.3. \u00a0 \u94fe\u8868\u6392\u5e8f *","text":"

    \u5f52\u5e76\u6392\u5e8f\u5728\u6392\u5e8f\u94fe\u8868\u65f6\u5177\u6709\u663e\u8457\u4f18\u52bf\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u4f18\u5316\u81f3 \\(O(1)\\) \uff0c\u539f\u56e0\u5982\u4e0b\uff1a

    • \u7531\u4e8e\u94fe\u8868\u4ec5\u9700\u6539\u53d8\u6307\u9488\u5c31\u53ef\u5b9e\u73b0\u8282\u70b9\u7684\u589e\u5220\u64cd\u4f5c\uff0c\u56e0\u6b64\u5408\u5e76\u9636\u6bb5\uff08\u5c06\u4e24\u4e2a\u77ed\u6709\u5e8f\u94fe\u8868\u5408\u5e76\u4e3a\u4e00\u4e2a\u957f\u6709\u5e8f\u94fe\u8868\uff09\u65e0\u9700\u521b\u5efa\u8f85\u52a9\u94fe\u8868\u3002
    • \u901a\u8fc7\u4f7f\u7528\u201c\u8fed\u4ee3\u5212\u5206\u201d\u66ff\u4ee3\u201c\u9012\u5f52\u5212\u5206\u201d\uff0c\u53ef\u7701\u53bb\u9012\u5f52\u4f7f\u7528\u7684\u6808\u5e27\u7a7a\u95f4\uff1b

    \u5177\u4f53\u5b9e\u73b0\u7ec6\u8282\u6bd4\u8f83\u590d\u6742\uff0c\u6709\u5174\u8da3\u7684\u540c\u5b66\u53ef\u4ee5\u67e5\u9605\u76f8\u5173\u8d44\u6599\u8fdb\u884c\u5b66\u4e60\u3002

    "},{"location":"chapter_sorting/quick_sort/","title":"11.5. \u00a0 \u5feb\u901f\u6392\u5e8f","text":"

    \u300c\u5feb\u901f\u6392\u5e8f Quick Sort\u300d\u662f\u4e00\u79cd\u57fa\u4e8e\u5206\u6cbb\u601d\u60f3\u7684\u6392\u5e8f\u7b97\u6cd5\uff0c\u8fd0\u884c\u9ad8\u6548\uff0c\u5e94\u7528\u5e7f\u6cdb\u3002

    \u5feb\u901f\u6392\u5e8f\u7684\u6838\u5fc3\u64cd\u4f5c\u662f\u300c\u54e8\u5175\u5212\u5206\u300d\uff0c\u5176\u76ee\u6807\u662f\uff1a\u9009\u62e9\u6570\u7ec4\u4e2d\u7684\u67d0\u4e2a\u5143\u7d20\u4f5c\u4e3a\u201c\u57fa\u51c6\u6570\u201d\uff0c\u5c06\u6240\u6709\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\u79fb\u5230\u5176\u5de6\u4fa7\uff0c\u800c\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\u79fb\u5230\u5176\u53f3\u4fa7\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u54e8\u5175\u5212\u5206\u7684\u6d41\u7a0b\u4e3a\uff1a

    1. \u9009\u53d6\u6570\u7ec4\u6700\u5de6\u7aef\u5143\u7d20\u4f5c\u4e3a\u57fa\u51c6\u6570\uff0c\u521d\u59cb\u5316\u4e24\u4e2a\u6307\u9488 i \u548c j \u5206\u522b\u6307\u5411\u6570\u7ec4\u7684\u4e24\u7aef\uff1b
    2. \u8bbe\u7f6e\u4e00\u4e2a\u5faa\u73af\uff0c\u5728\u6bcf\u8f6e\u4e2d\u4f7f\u7528 i\uff08j\uff09\u5206\u522b\u5bfb\u627e\u7b2c\u4e00\u4e2a\u6bd4\u57fa\u51c6\u6570\u5927\uff08\u5c0f\uff09\u7684\u5143\u7d20\uff0c\u7136\u540e\u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\uff1b
    3. \u5faa\u73af\u6267\u884c\u6b65\u9aa4 2. \uff0c\u76f4\u5230 i \u548c j \u76f8\u9047\u65f6\u505c\u6b62\uff0c\u6700\u540e\u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u4e2a\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\uff1b

    \u54e8\u5175\u5212\u5206\u5b8c\u6210\u540e\uff0c\u539f\u6570\u7ec4\u88ab\u5212\u5206\u6210\u4e09\u90e8\u5206\uff1a\u5de6\u5b50\u6570\u7ec4\u3001\u57fa\u51c6\u6570\u3001\u53f3\u5b50\u6570\u7ec4\uff0c\u4e14\u6ee1\u8db3\u201c\u5de6\u5b50\u6570\u7ec4\u4efb\u610f\u5143\u7d20 \\(\\leq\\) \u57fa\u51c6\u6570 \\(\\leq\\) \u53f3\u5b50\u6570\u7ec4\u4efb\u610f\u5143\u7d20\u201d\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u63a5\u4e0b\u6765\u53ea\u9700\u5bf9\u8fd9\u4e24\u4e2a\u5b50\u6570\u7ec4\u8fdb\u884c\u6392\u5e8f\u3002

    <1><2><3><4><5><6><7><8><9>

    \u5feb\u901f\u6392\u5e8f\u7684\u5206\u6cbb\u601d\u60f3

    \u54e8\u5175\u5212\u5206\u7684\u5b9e\u8d28\u662f\u5c06\u4e00\u4e2a\u8f83\u957f\u6570\u7ec4\u7684\u6392\u5e8f\u95ee\u9898\u7b80\u5316\u4e3a\u4e24\u4e2a\u8f83\u77ed\u6570\u7ec4\u7684\u6392\u5e8f\u95ee\u9898\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart quick_sort.java
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(int[] nums, int i, int j) {\nint tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\nint partition(int[] nums, int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);  // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.cpp
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(vector<int> &nums, int i, int j) {\nint tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\nint partition(vector<int> &nums, int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.py
    def partition(self, nums: list[int], left: int, right: int) -> int:\n\"\"\"\u54e8\u5175\u5212\u5206\"\"\"\n# \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\ni, j = left, right\nwhile i < j:\nwhile i < j and nums[j] >= nums[left]:\nj -= 1  # \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile i < j and nums[i] <= nums[left]:\ni += 1  # \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n# \u5143\u7d20\u4ea4\u6362\nnums[i], nums[j] = nums[j], nums[i]\n# \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nnums[i], nums[left] = nums[left], nums[i]\nreturn i  # \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n
    quick_sort.go
    /* \u54e8\u5175\u5212\u5206 */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\ni, j := left, right\nfor i < j {\nfor i < j && nums[j] >= nums[left] {\nj-- // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nfor i < j && nums[i] <= nums[left] {\ni++ // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\n// \u5143\u7d20\u4ea4\u6362\nnums[i], nums[j] = nums[j], nums[i]\n}\n// \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nnums[i], nums[left] = nums[left], nums[i]\nreturn i // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.js
    /* \u5143\u7d20\u4ea4\u6362 */\nswap(nums, i, j) {\nlet tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\npartition(nums, left, right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nlet i = left,\nj = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) {\nj -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nwhile (i < j && nums[i] <= nums[left]) {\ni += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\n// \u5143\u7d20\u4ea4\u6362\nthis.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nthis.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.ts
    /* \u5143\u7d20\u4ea4\u6362 */\nswap(nums: number[], i: number, j: number): void {\nlet tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\npartition(nums: number[], left: number, right: number): number {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nlet i = left,\nj = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) {\nj -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nwhile (i < j && nums[i] <= nums[left]) {\ni += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\n// \u5143\u7d20\u4ea4\u6362\nthis.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nthis.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.c
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(int nums[], int i, int j) {\nint tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u5feb\u901f\u6392\u5e8f\u7c7b */\n// \u5feb\u901f\u6392\u5e8f\u7c7b-\u54e8\u5175\u5212\u5206\nint partition(int nums[], int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) {\n// \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nj--;\n}\nwhile (i < j && nums[i] <= nums[left]) {\n// \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\ni++;\n}\n// \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\nswap(nums, i, j);\n}\n// \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nswap(nums, i, left);\n// \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\nreturn i;\n}\n
    quick_sort.cs
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(int[] nums, int i, int j) {\nint tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\nint partition(int[] nums, int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);  // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.swift
    /* \u5143\u7d20\u4ea4\u6362 */\nfunc swap(nums: inout [Int], i: Int, j: Int) {\nlet tmp = nums[i]\nnums[i] = nums[j]\nnums[j] = tmp\n}\n/* \u54e8\u5175\u5212\u5206 */\nfunc partition(nums: inout [Int], left: Int, right: Int) -> Int {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nvar i = left\nvar j = right\nwhile i < j {\nwhile i < j, nums[j] >= nums[left] {\nj -= 1 // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nwhile i < j, nums[i] <= nums[left] {\ni += 1 // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nswap(nums: &nums, i: i, j: j) // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums: &nums, i: i, j: left) // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.zig
    // \u5143\u7d20\u4ea4\u6362\nfn swap(nums: []i32, i: usize, j: usize) void {\nvar tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n// \u54e8\u5175\u5212\u5206\nfn partition(nums: []i32, left: usize, right: usize) usize {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nvar i = left;\nvar j = right;\nwhile (i < j) {\nwhile (i < j and nums[j] >= nums[left]) j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j and nums[i] <= nums[left]) i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j);   // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);    // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;               // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.dart
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid _swap(List<int> nums, int i, int j) {\nint tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\nint _partition(List<int> nums, int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left]) i++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n_swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\n_swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    "},{"location":"chapter_sorting/quick_sort/#1151","title":"11.5.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"
    1. \u9996\u5148\uff0c\u5bf9\u539f\u6570\u7ec4\u6267\u884c\u4e00\u6b21\u300c\u54e8\u5175\u5212\u5206\u300d\uff0c\u5f97\u5230\u672a\u6392\u5e8f\u7684\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\uff1b
    2. \u7136\u540e\uff0c\u5bf9\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u5206\u522b\u9012\u5f52\u6267\u884c\u300c\u54e8\u5175\u5212\u5206\u300d\uff1b
    3. \u6301\u7eed\u9012\u5f52\uff0c\u76f4\u81f3\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\uff0c\u4ece\u800c\u5b8c\u6210\u6574\u4e2a\u6570\u7ec4\u7684\u6392\u5e8f\uff1b

    Fig. \u5feb\u901f\u6392\u5e8f\u6d41\u7a0b

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart quick_sort.java
    /* \u5feb\u901f\u6392\u5e8f */\nvoid quickSort(int[] nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right)\nreturn;\n// \u54e8\u5175\u5212\u5206\nint pivot = partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    quick_sort.cpp
    /* \u5feb\u901f\u6392\u5e8f */\nvoid quickSort(vector<int> &nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right)\nreturn;\n// \u54e8\u5175\u5212\u5206\nint pivot = partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    quick_sort.py
    def quick_sort(self, nums: list[int], left: int, right: int) -> None:\n\"\"\"\u5feb\u901f\u6392\u5e8f\"\"\"\n# \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif left >= right:\nreturn\n# \u54e8\u5175\u5212\u5206\npivot = self.partition(nums, left, right)\n# \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nself.quick_sort(nums, left, pivot - 1)\nself.quick_sort(nums, pivot + 1, right)\n
    quick_sort.go
    /* \u5feb\u901f\u6392\u5e8f */\nfunc (q *quickSort) quickSort(nums []int, left, right int) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif left >= right {\nreturn\n}\n// \u54e8\u5175\u5212\u5206\npivot := q.partition(nums, left, right)\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nq.quickSort(nums, left, pivot-1)\nq.quickSort(nums, pivot+1, right)\n}\n
    quick_sort.js
    /* \u5feb\u901f\u6392\u5e8f */\nquickSort(nums, left, right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right) return;\n// \u54e8\u5175\u5212\u5206\nconst pivot = this.partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nthis.quickSort(nums, left, pivot - 1);\nthis.quickSort(nums, pivot + 1, right);\n}\n
    quick_sort.ts
    /* \u5feb\u901f\u6392\u5e8f */\nquickSort(nums: number[], left: number, right: number): void {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right) {\nreturn;\n}\n// \u54e8\u5175\u5212\u5206\nconst pivot = this.partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nthis.quickSort(nums, left, pivot - 1);\nthis.quickSort(nums, pivot + 1, right);\n}\n
    quick_sort.c
    /* \u5feb\u901f\u6392\u5e8f\u7c7b */\n// \u5feb\u901f\u6392\u5e8f\u7c7b-\u54e8\u5175\u5212\u5206\nint partition(int nums[], int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) {\n// \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nj--;\n}\nwhile (i < j && nums[i] <= nums[left]) {\n// \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\ni++;\n}\n// \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\nswap(nums, i, j);\n}\n// \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nswap(nums, i, left);\n// \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\nreturn i;\n}\n// \u5feb\u901f\u6392\u5e8f\u7c7b-\u5feb\u901f\u6392\u5e8f\nvoid quickSort(int nums[], int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right) {\nreturn;\n}\n// \u54e8\u5175\u5212\u5206\nint pivot = partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    quick_sort.cs
    /* \u5feb\u901f\u6392\u5e8f */\nvoid quickSort(int[] nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right)\nreturn;\n// \u54e8\u5175\u5212\u5206\nint pivot = partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    quick_sort.swift
    /* \u5feb\u901f\u6392\u5e8f */\nfunc quickSort(nums: inout [Int], left: Int, right: Int) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif left >= right {\nreturn\n}\n// \u54e8\u5175\u5212\u5206\nlet pivot = partition(nums: &nums, left: left, right: right)\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums: &nums, left: left, right: pivot - 1)\nquickSort(nums: &nums, left: pivot + 1, right: right)\n}\n
    quick_sort.zig
    // \u5feb\u901f\u6392\u5e8f\nfn quickSort(nums: []i32, left: usize, right: usize) void {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right) return;\n// \u54e8\u5175\u5212\u5206\nvar pivot = partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    quick_sort.dart
    /* \u5feb\u901f\u6392\u5e8f */\nvoid quickSort(List<int> nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right) return;\n// \u54e8\u5175\u5212\u5206\nint pivot = _partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    "},{"location":"chapter_sorting/quick_sort/#1152","title":"11.5.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n \\log n)\\) \u3001\u81ea\u9002\u5e94\u6392\u5e8f \uff1a\u5728\u5e73\u5747\u60c5\u51b5\u4e0b\uff0c\u54e8\u5175\u5212\u5206\u7684\u9012\u5f52\u5c42\u6570\u4e3a \\(\\log n\\) \uff0c\u6bcf\u5c42\u4e2d\u7684\u603b\u5faa\u73af\u6570\u4e3a \\(n\\) \uff0c\u603b\u4f53\u4f7f\u7528 \\(O(n \\log n)\\) \u65f6\u95f4\u3002\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u6bcf\u8f6e\u54e8\u5175\u5212\u5206\u64cd\u4f5c\u90fd\u5c06\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4\u5212\u5206\u4e3a\u957f\u5ea6\u4e3a \\(0\\) \u548c \\(n - 1\\) \u7684\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u6b64\u65f6\u9012\u5f52\u5c42\u6570\u8fbe\u5230 \\(n\\) \u5c42\uff0c\u6bcf\u5c42\u4e2d\u7684\u5faa\u73af\u6570\u4e3a \\(n\\) \uff0c\u603b\u4f53\u4f7f\u7528 \\(O(n^2)\\) \u65f6\u95f4\u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(n)\\) \u3001\u539f\u5730\u6392\u5e8f \uff1a\u5728\u8f93\u5165\u6570\u7ec4\u5b8c\u5168\u5012\u5e8f\u7684\u60c5\u51b5\u4e0b\uff0c\u8fbe\u5230\u6700\u5dee\u9012\u5f52\u6df1\u5ea6 \\(n\\) \uff0c\u4f7f\u7528 \\(O(n)\\) \u6808\u5e27\u7a7a\u95f4\u3002\u6392\u5e8f\u64cd\u4f5c\u662f\u5728\u539f\u6570\u7ec4\u4e0a\u8fdb\u884c\u7684\uff0c\u672a\u501f\u52a9\u989d\u5916\u6570\u7ec4\u3002
    • \u975e\u7a33\u5b9a\u6392\u5e8f\uff1a\u5728\u54e8\u5175\u5212\u5206\u7684\u6700\u540e\u4e00\u6b65\uff0c\u57fa\u51c6\u6570\u53ef\u80fd\u4f1a\u88ab\u4ea4\u6362\u81f3\u76f8\u7b49\u5143\u7d20\u7684\u53f3\u4fa7\u3002
    "},{"location":"chapter_sorting/quick_sort/#1153","title":"11.5.3. \u00a0 \u5feb\u6392\u4e3a\u4ec0\u4e48\u5feb\uff1f","text":"

    \u4ece\u540d\u79f0\u4e0a\u5c31\u80fd\u770b\u51fa\uff0c\u5feb\u901f\u6392\u5e8f\u5728\u6548\u7387\u65b9\u9762\u5e94\u8be5\u5177\u6709\u4e00\u5b9a\u7684\u4f18\u52bf\u3002\u5c3d\u7ba1\u5feb\u901f\u6392\u5e8f\u7684\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4e0e\u300c\u5f52\u5e76\u6392\u5e8f\u300d\u548c\u300c\u5806\u6392\u5e8f\u300d\u76f8\u540c\uff0c\u4f46\u901a\u5e38\u5feb\u901f\u6392\u5e8f\u7684\u6548\u7387\u66f4\u9ad8\uff0c\u539f\u56e0\u5982\u4e0b\uff1a

    • \u51fa\u73b0\u6700\u5dee\u60c5\u51b5\u7684\u6982\u7387\u5f88\u4f4e\uff1a\u867d\u7136\u5feb\u901f\u6392\u5e8f\u7684\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff0c\u6ca1\u6709\u5f52\u5e76\u6392\u5e8f\u7a33\u5b9a\uff0c\u4f46\u5728\u7edd\u5927\u591a\u6570\u60c5\u51b5\u4e0b\uff0c\u5feb\u901f\u6392\u5e8f\u80fd\u5728 \\(O(n \\log n)\\) \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e0b\u8fd0\u884c\u3002
    • \u7f13\u5b58\u4f7f\u7528\u6548\u7387\u9ad8\uff1a\u5728\u6267\u884c\u54e8\u5175\u5212\u5206\u64cd\u4f5c\u65f6\uff0c\u7cfb\u7edf\u53ef\u5c06\u6574\u4e2a\u5b50\u6570\u7ec4\u52a0\u8f7d\u5230\u7f13\u5b58\uff0c\u56e0\u6b64\u8bbf\u95ee\u5143\u7d20\u7684\u6548\u7387\u8f83\u9ad8\u3002\u800c\u50cf\u300c\u5806\u6392\u5e8f\u300d\u8fd9\u7c7b\u7b97\u6cd5\u9700\u8981\u8df3\u8dc3\u5f0f\u8bbf\u95ee\u5143\u7d20\uff0c\u4ece\u800c\u7f3a\u4e4f\u8fd9\u4e00\u7279\u6027\u3002
    • \u590d\u6742\u5ea6\u7684\u5e38\u6570\u7cfb\u6570\u4f4e\uff1a\u5728\u4e0a\u8ff0\u4e09\u79cd\u7b97\u6cd5\u4e2d\uff0c\u5feb\u901f\u6392\u5e8f\u7684\u6bd4\u8f83\u3001\u8d4b\u503c\u3001\u4ea4\u6362\u7b49\u64cd\u4f5c\u7684\u603b\u6570\u91cf\u6700\u5c11\u3002\u8fd9\u4e0e\u300c\u63d2\u5165\u6392\u5e8f\u300d\u6bd4\u300c\u5192\u6ce1\u6392\u5e8f\u300d\u66f4\u5feb\u7684\u539f\u56e0\u7c7b\u4f3c\u3002
    "},{"location":"chapter_sorting/quick_sort/#1154","title":"11.5.4. \u00a0 \u57fa\u51c6\u6570\u4f18\u5316","text":"

    \u5feb\u901f\u6392\u5e8f\u5728\u67d0\u4e9b\u8f93\u5165\u4e0b\u7684\u65f6\u95f4\u6548\u7387\u53ef\u80fd\u964d\u4f4e\u3002\u4e3e\u4e00\u4e2a\u6781\u7aef\u4f8b\u5b50\uff0c\u5047\u8bbe\u8f93\u5165\u6570\u7ec4\u662f\u5b8c\u5168\u5012\u5e8f\u7684\uff0c\u7531\u4e8e\u6211\u4eec\u9009\u62e9\u6700\u5de6\u7aef\u5143\u7d20\u4f5c\u4e3a\u57fa\u51c6\u6570\uff0c\u90a3\u4e48\u5728\u54e8\u5175\u5212\u5206\u5b8c\u6210\u540e\uff0c\u57fa\u51c6\u6570\u88ab\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u53f3\u7aef\uff0c\u5bfc\u81f4\u5de6\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a \\(n - 1\\) \u3001\u53f3\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a \\(0\\) \u3002\u5982\u6b64\u9012\u5f52\u4e0b\u53bb\uff0c\u6bcf\u8f6e\u54e8\u5175\u5212\u5206\u540e\u7684\u53f3\u5b50\u6570\u7ec4\u957f\u5ea6\u90fd\u4e3a \\(0\\) \uff0c\u5206\u6cbb\u7b56\u7565\u5931\u6548\uff0c\u5feb\u901f\u6392\u5e8f\u9000\u5316\u4e3a\u300c\u5192\u6ce1\u6392\u5e8f\u300d\u3002

    \u4e3a\u4e86\u5c3d\u91cf\u907f\u514d\u8fd9\u79cd\u60c5\u51b5\u53d1\u751f\uff0c\u6211\u4eec\u53ef\u4ee5\u4f18\u5316\u54e8\u5175\u5212\u5206\u4e2d\u7684\u57fa\u51c6\u6570\u7684\u9009\u53d6\u7b56\u7565\u3002\u4f8b\u5982\uff0c\u6211\u4eec\u53ef\u4ee5\u968f\u673a\u9009\u53d6\u4e00\u4e2a\u5143\u7d20\u4f5c\u4e3a\u57fa\u51c6\u6570\u3002\u7136\u800c\uff0c\u5982\u679c\u8fd0\u6c14\u4e0d\u4f73\uff0c\u6bcf\u6b21\u90fd\u9009\u5230\u4e0d\u7406\u60f3\u7684\u57fa\u51c6\u6570\uff0c\u6548\u7387\u4ecd\u7136\u4e0d\u5c3d\u5982\u4eba\u610f\u3002

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u7f16\u7a0b\u8bed\u8a00\u901a\u5e38\u751f\u6210\u7684\u662f\u201c\u4f2a\u968f\u673a\u6570\u201d\u3002\u5982\u679c\u6211\u4eec\u9488\u5bf9\u4f2a\u968f\u673a\u6570\u5e8f\u5217\u6784\u5efa\u4e00\u4e2a\u7279\u5b9a\u7684\u6d4b\u8bd5\u6837\u4f8b\uff0c\u90a3\u4e48\u5feb\u901f\u6392\u5e8f\u7684\u6548\u7387\u4ecd\u7136\u53ef\u80fd\u52a3\u5316\u3002

    \u4e3a\u4e86\u8fdb\u4e00\u6b65\u6539\u8fdb\uff0c\u6211\u4eec\u53ef\u4ee5\u5728\u6570\u7ec4\u4e2d\u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\uff08\u901a\u5e38\u4e3a\u6570\u7ec4\u7684\u9996\u3001\u5c3e\u3001\u4e2d\u70b9\u5143\u7d20\uff09\uff0c\u5e76\u5c06\u8fd9\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\u4f5c\u4e3a\u57fa\u51c6\u6570\u3002\u8fd9\u6837\u4e00\u6765\uff0c\u57fa\u51c6\u6570\u201c\u65e2\u4e0d\u592a\u5c0f\u4e5f\u4e0d\u592a\u5927\u201d\u7684\u6982\u7387\u5c06\u5927\u5e45\u63d0\u5347\u3002\u5f53\u7136\uff0c\u6211\u4eec\u8fd8\u53ef\u4ee5\u9009\u53d6\u66f4\u591a\u5019\u9009\u5143\u7d20\uff0c\u4ee5\u8fdb\u4e00\u6b65\u63d0\u9ad8\u7b97\u6cd5\u7684\u7a33\u5065\u6027\u3002\u91c7\u7528\u8fd9\u79cd\u65b9\u6cd5\u540e\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u52a3\u5316\u81f3 \\(O(n^2)\\) \u7684\u6982\u7387\u5927\u5927\u964d\u4f4e\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart quick_sort.java
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint medianThree(int[] nums, int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nint partition(int[] nums, int left, int right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint med = medianThree(nums, left, (left + right) / 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);  // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.cpp
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint medianThree(vector<int> &nums, int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nint partition(vector<int> &nums, int left, int right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint med = medianThree(nums, left, (left + right) / 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.py
    def median_three(self, nums: list[int], left: int, mid: int, right: int) -> int:\n\"\"\"\u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\"\"\"\n# \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n# \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif (nums[left] < nums[mid]) ^ (nums[left] < nums[right]):\nreturn left\nelif (nums[mid] < nums[left]) ^ (nums[mid] < nums[right]):\nreturn mid\nreturn right\ndef partition(self, nums: list[int], left: int, right: int) -> int:\n\"\"\"\u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09\"\"\"\n# \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nmed = self.median_three(nums, left, (left + right) // 2, right)\n# \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nnums[left], nums[med] = nums[med], nums[left]\n# \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\ni, j = left, right\nwhile i < j:\nwhile i < j and nums[j] >= nums[left]:\nj -= 1  # \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile i < j and nums[i] <= nums[left]:\ni += 1  # \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n# \u5143\u7d20\u4ea4\u6362\nnums[i], nums[j] = nums[j], nums[i]\n# \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nnums[i], nums[left] = nums[left], nums[i]\nreturn i  # \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n
    quick_sort.go
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\uff08!= \u5728\u8fd9\u91cc\u8d77\u5230\u5f02\u6216\u7684\u4f5c\u7528\uff09\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif (nums[left] < nums[mid]) != (nums[left] < nums[right]) {\nreturn left\n} else if (nums[mid] < nums[left]) != (nums[mid] < nums[right]) {\nreturn mid\n}\nreturn right\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09*/\nfunc (q *quickSortMedian) partition(nums []int, left, right int) int {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nmed := q.medianThree(nums, left, (left+right)/2, right)\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nnums[left], nums[med] = nums[med], nums[left]\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\ni, j := left, right\nfor i < j {\nfor i < j && nums[j] >= nums[left] {\nj-- //\u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nfor i < j && nums[i] <= nums[left] {\ni++ //\u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\n//\u5143\u7d20\u4ea4\u6362\nnums[i], nums[j] = nums[j], nums[i]\n}\n//\u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nnums[i], nums[left] = nums[left], nums[i]\nreturn i //\u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.js
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nmedianThree(nums, left, mid, right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right])) return left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse return right;\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\npartition(nums, left, right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nlet med = this.medianThree(\nnums,\nleft,\nMath.floor((left + right) / 2),\nright\n);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nthis.swap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nlet i = left,\nj = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left]) i++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nthis.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nthis.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.ts
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nmedianThree(\nnums: number[],\nleft: number,\nmid: number,\nright: number\n): number {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif (Number(nums[left] < nums[mid]) ^ Number(nums[left] < nums[right])) {\nreturn left;\n} else if (\nNumber(nums[mid] < nums[left]) ^ Number(nums[mid] < nums[right])\n) {\nreturn mid;\n} else {\nreturn right;\n}\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\npartition(nums: number[], left: number, right: number): number {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nlet med = this.medianThree(\nnums,\nleft,\nMath.floor((left + right) / 2),\nright\n);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nthis.swap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nlet i = left,\nj = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) {\nj--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nwhile (i < j && nums[i] <= nums[left]) {\ni++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nthis.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nthis.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.c
    /* \u5feb\u901f\u6392\u5e8f\u7c7b\uff08\u4e2d\u4f4d\u57fa\u51c6\u6570\u4f18\u5316\uff09 */\n// \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint medianThree(int nums[], int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n/* \u5feb\u901f\u6392\u5e8f\u7c7b\uff08\u4e2d\u4f4d\u57fa\u51c6\u6570\u4f18\u5316\uff09 */\n// \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint medianThree(int nums[], int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n// \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09\nint partitionMedian(int nums[], int left, int right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint med = medianThree(nums, left, (left + right) / 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.cs
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint medianThree(int[] nums, int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nint partition(int[] nums, int left, int right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint med = medianThree(nums, left, (left + right) / 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);  // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.swift
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -> Int {\nif (nums[left] < nums[mid]) != (nums[left] < nums[right]) {\nreturn left\n} else if (nums[mid] < nums[left]) != (nums[mid] < nums[right]) {\nreturn mid\n} else {\nreturn right\n}\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nfunc partitionMedian(nums: inout [Int], left: Int, right: Int) -> Int {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nlet med = medianThree(nums: nums, left: left, mid: (left + right) / 2, right: right)\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums: &nums, i: left, j: med)\nreturn partition(nums: &nums, left: left, right: right)\n}\n
    quick_sort.zig
    // \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nfn medianThree(nums: []i32, left: usize, mid: usize, right: usize) usize {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) != (nums[left] < nums[right])) {\nreturn left;\n} else if ((nums[mid] < nums[left]) != (nums[mid] < nums[right])) {\nreturn mid;\n} else {\nreturn right;\n}\n}\n// \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09\nfn partition(nums: []i32, left: usize, right: usize) usize {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nvar med = medianThree(nums, left, (left + right) / 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nvar i = left;\nvar j = right;\nwhile (i < j) {\nwhile (i < j and nums[j] >= nums[left]) j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j and nums[i] <= nums[left]) i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j);   // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);    // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;               // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.dart
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint _medianThree(List<int> nums, int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nint _partition(List<int> nums, int left, int right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint med = _medianThree(nums, left, (left + right) ~/ 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n_swap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left]) i++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n_swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\n_swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    "},{"location":"chapter_sorting/quick_sort/#1155","title":"11.5.5. \u00a0 \u5c3e\u9012\u5f52\u4f18\u5316","text":"

    \u5728\u67d0\u4e9b\u8f93\u5165\u4e0b\uff0c\u5feb\u901f\u6392\u5e8f\u53ef\u80fd\u5360\u7528\u7a7a\u95f4\u8f83\u591a\u3002\u4ee5\u5b8c\u5168\u5012\u5e8f\u7684\u8f93\u5165\u6570\u7ec4\u4e3a\u4f8b\uff0c\u7531\u4e8e\u6bcf\u8f6e\u54e8\u5175\u5212\u5206\u540e\u53f3\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a \\(0\\) \uff0c\u9012\u5f52\u6811\u7684\u9ad8\u5ea6\u4f1a\u8fbe\u5230 \\(n - 1\\) \uff0c\u6b64\u65f6\u9700\u8981\u5360\u7528 \\(O(n)\\) \u5927\u5c0f\u7684\u6808\u5e27\u7a7a\u95f4\u3002

    \u4e3a\u4e86\u9632\u6b62\u6808\u5e27\u7a7a\u95f4\u7684\u7d2f\u79ef\uff0c\u6211\u4eec\u53ef\u4ee5\u5728\u6bcf\u8f6e\u54e8\u5175\u6392\u5e8f\u5b8c\u6210\u540e\uff0c\u6bd4\u8f83\u4e24\u4e2a\u5b50\u6570\u7ec4\u7684\u957f\u5ea6\uff0c\u4ec5\u5bf9\u8f83\u77ed\u7684\u5b50\u6570\u7ec4\u8fdb\u884c\u9012\u5f52\u3002\u7531\u4e8e\u8f83\u77ed\u5b50\u6570\u7ec4\u7684\u957f\u5ea6\u4e0d\u4f1a\u8d85\u8fc7 \\(\\frac{n}{2}\\) \uff0c\u56e0\u6b64\u8fd9\u79cd\u65b9\u6cd5\u80fd\u786e\u4fdd\u9012\u5f52\u6df1\u5ea6\u4e0d\u8d85\u8fc7 \\(\\log n\\) \uff0c\u4ece\u800c\u5c06\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u81f3 \\(O(\\log n)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart quick_sort.java
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nvoid quickSort(int[] nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nint pivot = partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.cpp
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nvoid quickSort(vector<int> &nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nint pivot = partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1;                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1;                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.py
    def quick_sort(self, nums: list[int], left: int, right: int) -> None:\n\"\"\"\u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09\"\"\"\n# \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile left < right:\n# \u54e8\u5175\u5212\u5206\u64cd\u4f5c\npivot = self.partition(nums, left, right)\n# \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif pivot - left < right - pivot:\nself.quick_sort(nums, left, pivot - 1)  # \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1  # \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\nelse:\nself.quick_sort(nums, pivot + 1, right)  # \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1  # \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n
    quick_sort.go
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09*/\nfunc (q *quickSortTailCall) quickSort(nums []int, left, right int) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nfor left < right {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\npivot := q.partition(nums, left, right)\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif pivot-left < right-pivot {\nq.quickSort(nums, left, pivot-1) // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nq.quickSort(nums, pivot+1, right) // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.js
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nquickSort(nums, left, right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nlet pivot = this.partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nthis.quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nthis.quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.ts
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nquickSort(nums: number[], left: number, right: number): void {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nlet pivot = this.partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nthis.quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nthis.quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.c
    /* \u5feb\u901f\u6392\u5e8f\u7c7b\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\n// \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09\nvoid quickSortTailCall(int nums[], int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nint pivot = partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSortTailCall(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1;                         // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSortTailCall(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1;                         // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.cs
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nvoid quickSort(int[] nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nint pivot = partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSort(nums, left, pivot - 1);  // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1;  // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.swift
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nfunc quickSortTailCall(nums: inout [Int], left: Int, right: Int) {\nvar left = left\nvar right = right\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile left < right {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nlet pivot = partition(nums: &nums, left: left, right: right)\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left) < (right - pivot) {\nquickSortTailCall(nums: &nums, left: left, right: pivot - 1) // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSortTailCall(nums: &nums, left: pivot + 1, right: right) // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.zig
    // \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09\nfn quickSort(nums: []i32, left_: usize, right_: usize) void {\nvar left = left_;\nvar right = right_;\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nvar pivot = partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSort(nums, left, pivot - 1);   // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1;                   // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSort(nums, pivot + 1, right);  // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1;                  // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.dart
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nvoid quickSort(List<int> nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nint pivot = _partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    "},{"location":"chapter_sorting/radix_sort/","title":"11.10. \u00a0 \u57fa\u6570\u6392\u5e8f","text":"

    \u4e0a\u4e00\u8282\u6211\u4eec\u4ecb\u7ecd\u4e86\u8ba1\u6570\u6392\u5e8f\uff0c\u5b83\u9002\u7528\u4e8e\u6570\u636e\u91cf \\(n\\) \u8f83\u5927\u4f46\u6570\u636e\u8303\u56f4 \\(m\\) \u8f83\u5c0f\u7684\u60c5\u51b5\u3002\u5047\u8bbe\u6211\u4eec\u9700\u8981\u5bf9 \\(n = 10^6\\) \u4e2a\u5b66\u53f7\u8fdb\u884c\u6392\u5e8f\uff0c\u800c\u5b66\u53f7\u662f\u4e00\u4e2a \\(8\\) \u4f4d\u6570\u5b57\uff0c\u8fd9\u610f\u5473\u7740\u6570\u636e\u8303\u56f4 \\(m = 10^8\\) \u975e\u5e38\u5927\uff0c\u4f7f\u7528\u8ba1\u6570\u6392\u5e8f\u9700\u8981\u5206\u914d\u5927\u91cf\u5185\u5b58\u7a7a\u95f4\uff0c\u800c\u57fa\u6570\u6392\u5e8f\u53ef\u4ee5\u907f\u514d\u8fd9\u79cd\u60c5\u51b5\u3002

    \u300c\u57fa\u6570\u6392\u5e8f Radix Sort\u300d\u7684\u6838\u5fc3\u601d\u60f3\u4e0e\u8ba1\u6570\u6392\u5e8f\u4e00\u81f4\uff0c\u4e5f\u901a\u8fc7\u7edf\u8ba1\u4e2a\u6570\u6765\u5b9e\u73b0\u6392\u5e8f\u3002\u5728\u6b64\u57fa\u7840\u4e0a\uff0c\u57fa\u6570\u6392\u5e8f\u5229\u7528\u6570\u5b57\u5404\u4f4d\u4e4b\u95f4\u7684\u9012\u8fdb\u5173\u7cfb\uff0c\u4f9d\u6b21\u5bf9\u6bcf\u4e00\u4f4d\u8fdb\u884c\u6392\u5e8f\uff0c\u4ece\u800c\u5f97\u5230\u6700\u7ec8\u7684\u6392\u5e8f\u7ed3\u679c\u3002

    "},{"location":"chapter_sorting/radix_sort/#11101","title":"11.10.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u4ee5\u5b66\u53f7\u6570\u636e\u4e3a\u4f8b\uff0c\u5047\u8bbe\u6570\u5b57\u7684\u6700\u4f4e\u4f4d\u662f\u7b2c \\(1\\) \u4f4d\uff0c\u6700\u9ad8\u4f4d\u662f\u7b2c \\(8\\) \u4f4d\uff0c\u57fa\u6570\u6392\u5e8f\u7684\u6b65\u9aa4\u5982\u4e0b\uff1a

    1. \u521d\u59cb\u5316\u4f4d\u6570 \\(k = 1\\) \uff1b
    2. \u5bf9\u5b66\u53f7\u7684\u7b2c \\(k\\) \u4f4d\u6267\u884c\u300c\u8ba1\u6570\u6392\u5e8f\u300d\u3002\u5b8c\u6210\u540e\uff0c\u6570\u636e\u4f1a\u6839\u636e\u7b2c \\(k\\) \u4f4d\u4ece\u5c0f\u5230\u5927\u6392\u5e8f\uff1b
    3. \u5c06 \\(k\\) \u589e\u52a0 \\(1\\) \uff0c\u7136\u540e\u8fd4\u56de\u6b65\u9aa4 2. \u7ee7\u7eed\u8fed\u4ee3\uff0c\u76f4\u5230\u6240\u6709\u4f4d\u90fd\u6392\u5e8f\u5b8c\u6210\u540e\u7ed3\u675f\uff1b

    Fig. \u57fa\u6570\u6392\u5e8f\u7b97\u6cd5\u6d41\u7a0b

    \u4e0b\u9762\u6765\u5256\u6790\u4ee3\u7801\u5b9e\u73b0\u3002\u5bf9\u4e8e\u4e00\u4e2a \\(d\\) \u8fdb\u5236\u7684\u6570\u5b57 \\(x\\) \uff0c\u8981\u83b7\u53d6\u5176\u7b2c \\(k\\) \u4f4d \\(x_k\\) \uff0c\u53ef\u4ee5\u4f7f\u7528\u4ee5\u4e0b\u8ba1\u7b97\u516c\u5f0f\uff1a

    \\[ x_k = \\lfloor\\frac{x}{d^{k-1}}\\rfloor \\bmod d \\]

    \u5176\u4e2d \\(\\lfloor a \\rfloor\\) \u8868\u793a\u5bf9\u6d6e\u70b9\u6570 \\(a\\) \u5411\u4e0b\u53d6\u6574\uff0c\u800c \\(\\bmod \\space d\\) \u8868\u793a\u5bf9 \\(d\\) \u53d6\u4f59\u3002\u5bf9\u4e8e\u5b66\u53f7\u6570\u636e\uff0c\\(d = 10\\) \u4e14 \\(k \\in [1, 8]\\) \u3002

    \u6b64\u5916\uff0c\u6211\u4eec\u9700\u8981\u5c0f\u5e45\u6539\u52a8\u8ba1\u6570\u6392\u5e8f\u4ee3\u7801\uff0c\u4f7f\u4e4b\u53ef\u4ee5\u6839\u636e\u6570\u5b57\u7684\u7b2c \\(k\\) \u4f4d\u8fdb\u884c\u6392\u5e8f\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart radix_sort.java
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nint digit(int num, int exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nvoid countingSortDigit(int[] nums, int exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nint[] counter = new int[10];\nint n = nums.length;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (int i = 0; i < n; i++) {\nint d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++;                // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (int i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nint[] res = new int[n];\nfor (int i = n - 1; i >= 0; i--) {\nint d = digit(nums[i], exp);\nint j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++)\nnums[i] = res[i];\n}\n/* \u57fa\u6570\u6392\u5e8f */\nvoid radixSort(int[] nums) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nint m = Integer.MIN_VALUE;\nfor (int num : nums)\nif (num > m)\nm = num;\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (int exp = 1; exp <= m; exp *= 10)\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n
    radix_sort.cpp
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nint digit(int num, int exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nvoid countingSortDigit(vector<int> &nums, int exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nvector<int> counter(10, 0);\nint n = nums.size();\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (int i = 0; i < n; i++) {\nint d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++;                // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (int i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nvector<int> res(n, 0);\nfor (int i = n - 1; i >= 0; i--) {\nint d = digit(nums[i], exp);\nint j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++)\nnums[i] = res[i];\n}\n/* \u57fa\u6570\u6392\u5e8f */\nvoid radixSort(vector<int> &nums) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nint m = *max_element(nums.begin(), nums.end());\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (int exp = 1; exp <= m; exp *= 10)\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n
    radix_sort.py
    def digit(num: int, exp: int) -> int:\n\"\"\"\u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1)\"\"\"\n# \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num // exp) % 10\ndef counting_sort_digit(nums: list[int], exp: int) -> None:\n\"\"\"\u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09\"\"\"\n# \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\ncounter = [0] * 10\nn = len(nums)\n# \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor i in range(n):\nd = digit(nums[i], exp)  # \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d] += 1  # \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n# \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor i in range(1, 10):\ncounter[i] += counter[i - 1]\n# \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nres = [0] * n\nfor i in range(n - 1, -1, -1):\nd = digit(nums[i], exp)\nj = counter[d] - 1  # \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i]  # \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d] -= 1  # \u5c06 d \u7684\u6570\u91cf\u51cf 1\n# \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor i in range(n):\nnums[i] = res[i]\ndef radix_sort(nums: list[int]) -> None:\n\"\"\"\u57fa\u6570\u6392\u5e8f\"\"\"\n# \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nm = max(nums)\n# \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nexp = 1\nwhile exp <= m:\n# \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n# k = 1 -> exp = 1\n# k = 2 -> exp = 10\n# \u5373 exp = 10^(k-1)\ncounting_sort_digit(nums, exp)\nexp *= 10\n
    radix_sort.go
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfunc digit(num, exp int) int {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num / exp) % 10\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfunc countingSortDigit(nums []int, exp int) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\ncounter := make([]int, 10)\nn := len(nums)\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor i := 0; i < n; i++ {\nd := digit(nums[i], exp) // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++             // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor i := 1; i < 10; i++ {\ncounter[i] += counter[i-1]\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nres := make([]int, n)\nfor i := n - 1; i >= 0; i-- {\nd := digit(nums[i], exp)\nj := counter[d] - 1 // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i]    // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--        // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor i := 0; i < n; i++ {\nnums[i] = res[i]\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nfunc radixSort(nums []int) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nmax := math.MinInt\nfor _, num := range nums {\nif num > max {\nmax = num\n}\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor exp := 1; max >= exp; exp *= 10 {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp)\n}\n}\n
    radix_sort.js
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfunction digit(num, exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn Math.floor(num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfunction countingSortDigit(nums, exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nconst counter = new Array(10).fill(0);\nconst n = nums.length;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (let i = 0; i < n; i++) {\nconst d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++; // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (let i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nconst res = new Array(n).fill(0);\nfor (let i = n - 1; i >= 0; i--) {\nconst d = digit(nums[i], exp);\nconst j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (let i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nfunction radixSort(nums) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nlet m = Number.MIN_VALUE;\nfor (const num of nums) {\nif (num > m) {\nm = num;\n}\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (let exp = 1; exp <= m; exp *= 10) {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n}\n
    radix_sort.ts
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfunction digit(num: number, exp: number): number {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn Math.floor(num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfunction countingSortDigit(nums: number[], exp: number): void {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nconst counter = new Array(10).fill(0);\nconst n = nums.length;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (let i = 0; i < n; i++) {\nconst d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++; // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (let i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nconst res = new Array(n).fill(0);\nfor (let i = n - 1; i >= 0; i--) {\nconst d = digit(nums[i], exp);\nconst j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (let i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nfunction radixSort(nums: number[]): void {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nlet m = Number.MIN_VALUE;\nfor (const num of nums) {\nif (num > m) {\nm = num;\n}\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (let exp = 1; exp <= m; exp *= 10) {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n}\n
    radix_sort.c
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nint digit(int num, int exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nvoid countingSortDigit(int nums[], int size, int exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nint *counter = (int *)malloc((sizeof(int) * 10));\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (int i = 0; i < size; i++) {\n// \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\nint d = digit(nums[i], exp);\n// \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\ncounter[d]++;\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (int i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nint *res = (int *)malloc(sizeof(int) * size);\nfor (int i = size - 1; i >= 0; i--) {\nint d = digit(nums[i], exp);\nint j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < size; i++) {\nnums[i] = res[i];\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nvoid radixSort(int nums[], int size) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nint max = INT32_MIN;\nfor (size_t i = 0; i < size - 1; i++) {\nif (nums[i] > max) {\nmax = nums[i];\n}\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (int exp = 1; max >= exp; exp *= 10)\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, size, exp);\n}\n
    radix_sort.cs
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nint digit(int num, int exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nvoid countingSortDigit(int[] nums, int exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nint[] counter = new int[10];\nint n = nums.Length;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (int i = 0; i < n; i++) {\nint d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++;                // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (int i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nint[] res = new int[n];\nfor (int i = n - 1; i >= 0; i--) {\nint d = digit(nums[i], exp);\nint j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nvoid radixSort(int[] nums) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nint m = int.MinValue;\nforeach (int num in nums) {\nif (num > m) m = num;\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (int exp = 1; exp <= m; exp *= 10) {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n}\n
    radix_sort.swift
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfunc digit(num: Int, exp: Int) -> Int {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\n(num / exp) % 10\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfunc countingSortDigit(nums: inout [Int], exp: Int) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nvar counter = Array(repeating: 0, count: 10)\nlet n = nums.count\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor i in nums.indices {\nlet d = digit(num: nums[i], exp: exp) // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d] += 1 // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor i in 1 ..< 10 {\ncounter[i] += counter[i - 1]\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nvar res = Array(repeating: 0, count: n)\nfor i in stride(from: n - 1, through: 0, by: -1) {\nlet d = digit(num: nums[i], exp: exp)\nlet j = counter[d] - 1 // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i] // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d] -= 1 // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor i in nums.indices {\nnums[i] = res[i]\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nfunc radixSort(nums: inout [Int]) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nvar m = Int.min\nfor num in nums {\nif num > m {\nm = num\n}\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor exp in sequence(first: 1, next: { m >= ($0 * 10) ? $0 * 10 : nil }) {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums: &nums, exp: exp)\n}\n}\n
    radix_sort.zig
    // \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1)\nfn digit(num: i32, exp: i32) i32 {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn @mod(@divFloor(num, exp), 10);\n}\n// \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09\nfn countingSortDigit(nums: []i32, exp: i32) !void {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nvar mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);\n// defer mem_arena.deinit();\nconst mem_allocator = mem_arena.allocator();\nvar counter = try mem_allocator.alloc(usize, 10);\n@memset(counter, 0);\nvar n = nums.len;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (nums) |num| {\nvar d: u32 = @bitCast(digit(num, exp)); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d] += 1; // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nvar i: usize = 1;\nwhile (i < 10) : (i += 1) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nvar res = try mem_allocator.alloc(i32, n);\ni = n - 1;\nwhile (i >= 0) : (i -= 1) {\nvar d: u32 = @bitCast(digit(nums[i], exp));\nvar j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d] -= 1;        // \u5c06 d \u7684\u6570\u91cf\u51cf 1\nif (i == 0) break;\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\ni = 0;\nwhile (i < n) : (i += 1) {\nnums[i] = res[i];\n}\n}\n// \u57fa\u6570\u6392\u5e8f\nfn radixSort(nums: []i32) !void {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nvar m: i32 = std.math.minInt(i32);\nfor (nums) |num| {\nif (num > m) m = num;\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nvar exp: i32 = 1;\nwhile (exp <= m) : (exp *= 10) {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ntry countingSortDigit(nums, exp);    }\n}
    radix_sort.dart
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nint digit(int num, int exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num ~/ exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nvoid countingSortDigit(List<int> nums, int exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nList<int> counter = List<int>.filled(10, 0);\nint n = nums.length;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (int i = 0; i < n; i++) {\nint d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++; // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (int i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nList<int> res = List<int>.filled(n, 0);\nfor (int i = n - 1; i >= 0; i--) {\nint d = digit(nums[i], exp);\nint j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++) nums[i] = res[i];\n}\n/* \u57fa\u6570\u6392\u5e8f */\nvoid radixSort(List<int> nums) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\n// dart \u4e2d int \u7684\u957f\u5ea6\u662f 64 \u4f4d\u7684\nint m = -1 << 63; for (int num in nums) if (num > m) m = num;\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (int exp = 1; exp <= m; exp *= 10)\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n

    \u4e3a\u4ec0\u4e48\u4ece\u6700\u4f4e\u4f4d\u5f00\u59cb\u6392\u5e8f\uff1f

    \u5728\u8fde\u7eed\u7684\u6392\u5e8f\u8f6e\u6b21\u4e2d\uff0c\u540e\u4e00\u8f6e\u6392\u5e8f\u4f1a\u8986\u76d6\u524d\u4e00\u8f6e\u6392\u5e8f\u7684\u7ed3\u679c\u3002\u4e3e\u4f8b\u6765\u8bf4\uff0c\u5982\u679c\u7b2c\u4e00\u8f6e\u6392\u5e8f\u7ed3\u679c \\(a < b\\) \uff0c\u800c\u7b2c\u4e8c\u8f6e\u6392\u5e8f\u7ed3\u679c \\(a > b\\) \uff0c\u90a3\u4e48\u7b2c\u4e8c\u8f6e\u7684\u7ed3\u679c\u5c06\u53d6\u4ee3\u7b2c\u4e00\u8f6e\u7684\u7ed3\u679c\u3002\u7531\u4e8e\u6570\u5b57\u7684\u9ad8\u4f4d\u4f18\u5148\u7ea7\u9ad8\u4e8e\u4f4e\u4f4d\uff0c\u6211\u4eec\u5e94\u8be5\u5148\u6392\u5e8f\u4f4e\u4f4d\u518d\u6392\u5e8f\u9ad8\u4f4d\u3002

    "},{"location":"chapter_sorting/radix_sort/#11102","title":"11.10.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"

    \u76f8\u8f83\u4e8e\u8ba1\u6570\u6392\u5e8f\uff0c\u57fa\u6570\u6392\u5e8f\u9002\u7528\u4e8e\u6570\u503c\u8303\u56f4\u8f83\u5927\u7684\u60c5\u51b5\uff0c\u4f46\u524d\u63d0\u662f\u6570\u636e\u5fc5\u987b\u53ef\u4ee5\u8868\u793a\u4e3a\u56fa\u5b9a\u4f4d\u6570\u7684\u683c\u5f0f\uff0c\u4e14\u4f4d\u6570\u4e0d\u80fd\u8fc7\u5927\u3002\u4f8b\u5982\uff0c\u6d6e\u70b9\u6570\u4e0d\u9002\u5408\u4f7f\u7528\u57fa\u6570\u6392\u5e8f\uff0c\u56e0\u4e3a\u5176\u4f4d\u6570 \\(k\\) \u8fc7\u5927\uff0c\u53ef\u80fd\u5bfc\u81f4\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(nk) \\gg O(n^2)\\) \u3002

    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(nk)\\) \uff1a\u8bbe\u6570\u636e\u91cf\u4e3a \\(n\\) \u3001\u6570\u636e\u4e3a \\(d\\) \u8fdb\u5236\u3001\u6700\u5927\u4f4d\u6570\u4e3a \\(k\\) \uff0c\u5219\u5bf9\u67d0\u4e00\u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\u4f7f\u7528 \\(O(n + d)\\) \u65f6\u95f4\uff0c\u6392\u5e8f\u6240\u6709 \\(k\\) \u4f4d\u4f7f\u7528 \\(O((n + d)k)\\) \u65f6\u95f4\u3002\u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\\(d\\) \u548c \\(k\\) \u90fd\u76f8\u5bf9\u8f83\u5c0f\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u8d8b\u5411 \\(O(n)\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(n + d)\\) \u3001\u975e\u539f\u5730\u6392\u5e8f \uff1a\u4e0e\u8ba1\u6570\u6392\u5e8f\u76f8\u540c\uff0c\u57fa\u6570\u6392\u5e8f\u9700\u8981\u501f\u52a9\u957f\u5ea6\u4e3a \\(n\\) \u548c \\(d\\) \u7684\u6570\u7ec4 res \u548c counter \u3002
    • \u7a33\u5b9a\u6392\u5e8f\uff1a\u4e0e\u8ba1\u6570\u6392\u5e8f\u76f8\u540c\u3002
    "},{"location":"chapter_sorting/selection_sort/","title":"11.2. \u00a0 \u9009\u62e9\u6392\u5e8f","text":"

    \u300c\u9009\u62e9\u6392\u5e8f Selection Sort\u300d\u7684\u5de5\u4f5c\u539f\u7406\u975e\u5e38\u76f4\u63a5\uff1a\u5f00\u542f\u4e00\u4e2a\u5faa\u73af\uff0c\u6bcf\u8f6e\u4ece\u672a\u6392\u5e8f\u533a\u95f4\u9009\u62e9\u6700\u5c0f\u7684\u5143\u7d20\uff0c\u5c06\u5176\u653e\u5230\u5df2\u6392\u5e8f\u533a\u95f4\u7684\u672b\u5c3e\u3002

    \u8bbe\u6570\u7ec4\u7684\u957f\u5ea6\u4e3a \\(n\\) \uff0c\u9009\u62e9\u6392\u5e8f\u7684\u7b97\u6cd5\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u521d\u59cb\u72b6\u6001\u4e0b\uff0c\u6240\u6709\u5143\u7d20\u672a\u6392\u5e8f\uff0c\u5373\u672a\u6392\u5e8f\uff08\u7d22\u5f15\uff09\u533a\u95f4\u4e3a \\([0, n-1]\\) \u3002
    2. \u9009\u53d6\u533a\u95f4 \\([0, n-1]\\) \u4e2d\u7684\u6700\u5c0f\u5143\u7d20\uff0c\u5c06\u5176\u4e0e\u7d22\u5f15 \\(0\\) \u5904\u5143\u7d20\u4ea4\u6362\u3002\u5b8c\u6210\u540e\uff0c\u6570\u7ec4\u524d 1 \u4e2a\u5143\u7d20\u5df2\u6392\u5e8f\u3002
    3. \u9009\u53d6\u533a\u95f4 \\([1, n-1]\\) \u4e2d\u7684\u6700\u5c0f\u5143\u7d20\uff0c\u5c06\u5176\u4e0e\u7d22\u5f15 \\(1\\) \u5904\u5143\u7d20\u4ea4\u6362\u3002\u5b8c\u6210\u540e\uff0c\u6570\u7ec4\u524d 2 \u4e2a\u5143\u7d20\u5df2\u6392\u5e8f\u3002
    4. \u4ee5\u6b64\u7c7b\u63a8\u3002\u7ecf\u8fc7 \\(n - 1\\) \u8f6e\u9009\u62e9\u4e0e\u4ea4\u6362\u540e\uff0c\u6570\u7ec4\u524d \\(n - 1\\) \u4e2a\u5143\u7d20\u5df2\u6392\u5e8f\u3002
    5. \u4ec5\u5269\u7684\u4e00\u4e2a\u5143\u7d20\u5fc5\u5b9a\u662f\u6700\u5927\u5143\u7d20\uff0c\u65e0\u9700\u6392\u5e8f\uff0c\u56e0\u6b64\u6570\u7ec4\u6392\u5e8f\u5b8c\u6210\u3002
    <1><2><3><4><5><6><7><8><9><10><11>

    \u5728\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u7528 \\(k\\) \u6765\u8bb0\u5f55\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart selection_sort.java
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(int[] nums) {\nint n = nums.length;\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (int i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nint k = i;\nfor (int j = i + 1; j < n; j++) {\nif (nums[j] < nums[k])\nk = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nint temp = nums[i];\nnums[i] = nums[k];\nnums[k] = temp;\n}\n}\n
    selection_sort.cpp
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(vector<int> &nums) {\nint n = nums.size();\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (int i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nint k = i;\nfor (int j = i + 1; j < n; j++) {\nif (nums[j] < nums[k])\nk = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nswap(nums[i], nums[k]);\n}\n}\n
    selection_sort.py
    def selection_sort(nums: list[int]):\n\"\"\"\u9009\u62e9\u6392\u5e8f\"\"\"\nn = len(nums)\n# \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor i in range(n - 1):\n# \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nk = i\nfor j in range(i + 1, n):\nif nums[j] < nums[k]:\nk = j  # \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n# \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nnums[i], nums[k] = nums[k], nums[i]\n
    selection_sort.go
    /* \u9009\u62e9\u6392\u5e8f */\nfunc selectionSort(nums []int) {\nn := len(nums)\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor i := 0; i < n-1; i++ {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nk := i\nfor j := i + 1; j < n; j++ {\nif nums[j] < nums[k] {\n// \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\nk = j\n}\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nnums[i], nums[k] = nums[k], nums[i]\n}\n}\n
    selection_sort.js
    /* \u9009\u62e9\u6392\u5e8f */\nfunction selectionSort(nums) {\nlet n = nums.length;\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (let i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nlet k = i;\nfor (let j = i + 1; j < n; j++) {\nif (nums[j] < nums[k]) {\nk = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\n[nums[i], nums[k]] = [nums[k], nums[i]];\n}\n}\n
    selection_sort.ts
    /* \u9009\u62e9\u6392\u5e8f */\nfunction selectionSort(nums: number[]): void {\nlet n = nums.length;\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (let i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nlet k = i;\nfor (let j = i + 1; j < n; j++) {\nif (nums[j] < nums[k]) {\nk = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\n[nums[i], nums[k]] = [nums[k], nums[i]];\n}\n}\n
    selection_sort.c
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(int nums[], int n) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (int i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nint k = i;\nfor (int j = i + 1; j < n; j++) {\nif (nums[j] < nums[k])\nk = j;  // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nint temp = nums[i];\nnums[i] = nums[k];\nnums[k] = temp;\n}\n}\n
    selection_sort.cs
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(int[] nums) {\nint n = nums.Length;\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (int i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nint k = i;\nfor (int j = i + 1; j < n; j++) {\nif (nums[j] < nums[k])\nk = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\n(nums[k], nums[i]) = (nums[i], nums[k]);\n}\n}\n
    selection_sort.swift
    /* \u9009\u62e9\u6392\u5e8f */\nfunc selectionSort(nums: inout [Int]) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor i in nums.indices.dropLast() {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nvar k = i\nfor j in nums.indices.dropFirst(i + 1) {\nif nums[j] < nums[k] {\nk = j // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nnums.swapAt(i, k)\n}\n}\n
    selection_sort.zig
    [class]{}-[func]{selectionSort}\n
    selection_sort.dart
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(List<int> nums) {\nint n = nums.length;\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (int i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nint k = i;\nfor (int j = i + 1; j < n; j++) {\nif (nums[j] < nums[k]) k = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nint temp = nums[i];\nnums[i] = nums[k];\nnums[k] = temp;\n}\n}\n
    "},{"location":"chapter_sorting/selection_sort/#1121","title":"11.2.1. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3001\u975e\u81ea\u9002\u5e94\u6392\u5e8f\uff1a\u5916\u5faa\u73af\u5171 \\(n - 1\\) \u8f6e\uff0c\u7b2c\u4e00\u8f6e\u7684\u672a\u6392\u5e8f\u533a\u95f4\u957f\u5ea6\u4e3a \\(n\\) \uff0c\u6700\u540e\u4e00\u8f6e\u7684\u672a\u6392\u5e8f\u533a\u95f4\u957f\u5ea6\u4e3a \\(2\\) \uff0c\u5373\u5404\u8f6e\u5916\u5faa\u73af\u5206\u522b\u5305\u542b \\(n\\) , \\(n - 1\\) , \\(\\cdots\\) , \\(2\\) \u8f6e\u5185\u5faa\u73af\uff0c\u6c42\u548c\u4e3a \\(\\frac{(n - 1)(n + 2)}{2}\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(1)\\) \u3001\u539f\u5730\u6392\u5e8f\uff1a\u6307\u9488 \\(i\\) , \\(j\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u975e\u7a33\u5b9a\u6392\u5e8f\uff1a\u5728\u4ea4\u6362\u5143\u7d20\u65f6\uff0c\u6709\u53ef\u80fd\u5c06 nums[i] \u4ea4\u6362\u81f3\u5176\u76f8\u7b49\u5143\u7d20\u7684\u53f3\u8fb9\uff0c\u5bfc\u81f4\u4e24\u8005\u7684\u76f8\u5bf9\u987a\u5e8f\u53d1\u751f\u6539\u53d8\u3002

    Fig. \u9009\u62e9\u6392\u5e8f\u975e\u7a33\u5b9a\u793a\u4f8b

    "},{"location":"chapter_sorting/sorting_algorithm/","title":"11.1. \u00a0 \u6392\u5e8f\u7b97\u6cd5","text":"

    \u300c\u6392\u5e8f\u7b97\u6cd5 Sorting Algorithm\u300d\u7528\u4e8e\u5bf9\u4e00\u7ec4\u6570\u636e\u6309\u7167\u7279\u5b9a\u987a\u5e8f\u8fdb\u884c\u6392\u5217\u3002\u6392\u5e8f\u7b97\u6cd5\u6709\u7740\u5e7f\u6cdb\u7684\u5e94\u7528\uff0c\u56e0\u4e3a\u6709\u5e8f\u6570\u636e\u901a\u5e38\u80fd\u591f\u88ab\u66f4\u6709\u6548\u5730\u67e5\u627e\u3001\u5206\u6790\u548c\u5904\u7406\u3002

    \u5728\u6392\u5e8f\u7b97\u6cd5\u4e2d\uff0c\u6570\u636e\u7c7b\u578b\u53ef\u4ee5\u662f\u6574\u6570\u3001\u6d6e\u70b9\u6570\u3001\u5b57\u7b26\u6216\u5b57\u7b26\u4e32\u7b49\uff1b\u987a\u5e8f\u7684\u5224\u65ad\u89c4\u5219\u53ef\u6839\u636e\u9700\u6c42\u8bbe\u5b9a\uff0c\u5982\u6570\u5b57\u5927\u5c0f\u3001\u5b57\u7b26 ASCII \u7801\u987a\u5e8f\u6216\u81ea\u5b9a\u4e49\u89c4\u5219\u3002

    Fig. \u6570\u636e\u7c7b\u578b\u548c\u5224\u65ad\u89c4\u5219\u793a\u4f8b

    "},{"location":"chapter_sorting/sorting_algorithm/#1111","title":"11.1.1. \u00a0 \u8bc4\u4ef7\u7ef4\u5ea6","text":"

    \u8fd0\u884c\u6548\u7387\uff1a\u6211\u4eec\u671f\u671b\u6392\u5e8f\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5c3d\u91cf\u4f4e\uff0c\u4e14\u603b\u4f53\u64cd\u4f5c\u6570\u91cf\u8f83\u5c11\uff08\u5373\u65f6\u95f4\u590d\u6742\u5ea6\u4e2d\u7684\u5e38\u6570\u9879\u964d\u4f4e\uff09\u3002\u5bf9\u4e8e\u5927\u6570\u636e\u91cf\u60c5\u51b5\uff0c\u8fd0\u884c\u6548\u7387\u663e\u5f97\u5c24\u4e3a\u91cd\u8981\u3002

    \u5c31\u5730\u6027\uff1a\u987e\u540d\u601d\u4e49\uff0c\u300c\u539f\u5730\u6392\u5e8f\u300d\u901a\u8fc7\u5728\u539f\u6570\u7ec4\u4e0a\u76f4\u63a5\u64cd\u4f5c\u5b9e\u73b0\u6392\u5e8f\uff0c\u65e0\u9700\u501f\u52a9\u989d\u5916\u7684\u8f85\u52a9\u6570\u7ec4\uff0c\u4ece\u800c\u8282\u7701\u5185\u5b58\u3002\u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\u539f\u5730\u6392\u5e8f\u7684\u6570\u636e\u642c\u8fd0\u64cd\u4f5c\u8f83\u5c11\uff0c\u8fd0\u884c\u901f\u5ea6\u4e5f\u66f4\u5feb\u3002

    \u7a33\u5b9a\u6027\uff1a\u300c\u7a33\u5b9a\u6392\u5e8f\u300d\u5728\u5b8c\u6210\u6392\u5e8f\u540e\uff0c\u76f8\u7b49\u5143\u7d20\u5728\u6570\u7ec4\u4e2d\u7684\u76f8\u5bf9\u987a\u5e8f\u4e0d\u53d1\u751f\u6539\u53d8\u3002\u7a33\u5b9a\u6392\u5e8f\u662f\u4f18\u826f\u7279\u6027\uff0c\u4e5f\u662f\u591a\u7ea7\u6392\u5e8f\u573a\u666f\u7684\u5fc5\u8981\u6761\u4ef6\u3002

    \u5047\u8bbe\u6211\u4eec\u6709\u4e00\u4e2a\u5b58\u50a8\u5b66\u751f\u4fe1\u606f\u7684\u8868\u683c\uff0c\u7b2c 1, 2 \u5217\u5206\u522b\u662f\u59d3\u540d\u548c\u5e74\u9f84\u3002\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u300c\u975e\u7a33\u5b9a\u6392\u5e8f\u300d\u53ef\u80fd\u5bfc\u81f4\u8f93\u5165\u6570\u636e\u7684\u6709\u5e8f\u6027\u4e27\u5931\u3002

    # \u8f93\u5165\u6570\u636e\u662f\u6309\u7167\u59d3\u540d\u6392\u5e8f\u597d\u7684\n# (name, age)\n('A', 19)\n('B', 18)\n('C', 21)\n('D', 19)\n('E', 23)\n# \u5047\u8bbe\u4f7f\u7528\u975e\u7a33\u5b9a\u6392\u5e8f\u7b97\u6cd5\u6309\u5e74\u9f84\u6392\u5e8f\u5217\u8868\uff0c\n# \u7ed3\u679c\u4e2d ('D', 19) \u548c ('A', 19) \u7684\u76f8\u5bf9\u4f4d\u7f6e\u6539\u53d8\uff0c\n# \u8f93\u5165\u6570\u636e\u6309\u59d3\u540d\u6392\u5e8f\u7684\u6027\u8d28\u4e22\u5931\n('B', 18)\n('D', 19)\n('A', 19)\n('C', 21)\n('E', 23)\n

    \u81ea\u9002\u5e94\u6027\uff1a\u300c\u81ea\u9002\u5e94\u6392\u5e8f\u300d\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4f1a\u53d7\u8f93\u5165\u6570\u636e\u7684\u5f71\u54cd\uff0c\u5373\u6700\u4f73\u3001\u6700\u5dee\u3001\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u5e76\u4e0d\u5b8c\u5168\u76f8\u7b49\u3002

    \u81ea\u9002\u5e94\u6027\u9700\u8981\u6839\u636e\u5177\u4f53\u60c5\u51b5\u6765\u8bc4\u4f30\u3002\u5982\u679c\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u5dee\u4e8e\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u8bf4\u660e\u6392\u5e8f\u7b97\u6cd5\u5728\u67d0\u4e9b\u6570\u636e\u4e0b\u6027\u80fd\u53ef\u80fd\u52a3\u5316\uff0c\u56e0\u6b64\u88ab\u89c6\u4e3a\u8d1f\u9762\u5c5e\u6027\uff1b\u800c\u5982\u679c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u4f18\u4e8e\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u5219\u88ab\u89c6\u4e3a\u6b63\u9762\u5c5e\u6027\u3002

    \u662f\u5426\u57fa\u4e8e\u6bd4\u8f83\uff1a\u300c\u57fa\u4e8e\u6bd4\u8f83\u7684\u6392\u5e8f\u300d\u4f9d\u8d56\u4e8e\u6bd4\u8f83\u8fd0\u7b97\u7b26\uff08\\(<\\) , \\(=\\) , \\(>\\)\uff09\u6765\u5224\u65ad\u5143\u7d20\u7684\u76f8\u5bf9\u987a\u5e8f\uff0c\u4ece\u800c\u6392\u5e8f\u6574\u4e2a\u6570\u7ec4\uff0c\u7406\u8bba\u6700\u4f18\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002\u800c\u300c\u975e\u6bd4\u8f83\u6392\u5e8f\u300d\u4e0d\u4f7f\u7528\u6bd4\u8f83\u8fd0\u7b97\u7b26\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u8fbe \\(O(n)\\) \uff0c\u4f46\u5176\u901a\u7528\u6027\u76f8\u5bf9\u8f83\u5dee\u3002

    "},{"location":"chapter_sorting/sorting_algorithm/#1112","title":"11.1.2. \u00a0 \u7406\u60f3\u6392\u5e8f\u7b97\u6cd5","text":"

    \u8fd0\u884c\u5feb\u3001\u539f\u5730\u3001\u7a33\u5b9a\u3001\u6b63\u5411\u81ea\u9002\u5e94\u3001\u901a\u7528\u6027\u597d\u3002\u663e\u7136\uff0c\u8fc4\u4eca\u4e3a\u6b62\u5c1a\u672a\u53d1\u73b0\u517c\u5177\u4ee5\u4e0a\u6240\u6709\u7279\u6027\u7684\u6392\u5e8f\u7b97\u6cd5\u3002\u56e0\u6b64\uff0c\u5728\u9009\u62e9\u6392\u5e8f\u7b97\u6cd5\u65f6\uff0c\u9700\u8981\u6839\u636e\u5177\u4f53\u7684\u6570\u636e\u7279\u70b9\u548c\u95ee\u9898\u9700\u6c42\u6765\u51b3\u5b9a\u3002

    \u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c06\u5171\u540c\u5b66\u4e60\u5404\u79cd\u6392\u5e8f\u7b97\u6cd5\uff0c\u5e76\u57fa\u4e8e\u4e0a\u8ff0\u8bc4\u4ef7\u7ef4\u5ea6\u5bf9\u5404\u4e2a\u6392\u5e8f\u7b97\u6cd5\u7684\u4f18\u7f3a\u70b9\u8fdb\u884c\u5206\u6790\u3002

    "},{"location":"chapter_sorting/summary/","title":"11.11. \u00a0 \u5c0f\u7ed3","text":"
    • \u5192\u6ce1\u6392\u5e8f\u901a\u8fc7\u4ea4\u6362\u76f8\u90bb\u5143\u7d20\u6765\u5b9e\u73b0\u6392\u5e8f\u3002\u901a\u8fc7\u6dfb\u52a0\u4e00\u4e2a\u6807\u5fd7\u4f4d\u6765\u5b9e\u73b0\u63d0\u524d\u8fd4\u56de\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5192\u6ce1\u6392\u5e8f\u7684\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u5230 \\(O(n)\\) \u3002
    • \u63d2\u5165\u6392\u5e8f\u6bcf\u8f6e\u5c06\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u5143\u7d20\u63d2\u5165\u5230\u5df2\u6392\u5e8f\u533a\u95f4\u7684\u6b63\u786e\u4f4d\u7f6e\uff0c\u4ece\u800c\u5b8c\u6210\u6392\u5e8f\u3002\u867d\u7136\u63d2\u5165\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff0c\u4f46\u7531\u4e8e\u5355\u5143\u64cd\u4f5c\u76f8\u5bf9\u8f83\u5c11\uff0c\u5b83\u5728\u5c0f\u6570\u636e\u91cf\u7684\u6392\u5e8f\u4efb\u52a1\u4e2d\u975e\u5e38\u53d7\u6b22\u8fce\u3002
    • \u5feb\u901f\u6392\u5e8f\u57fa\u4e8e\u54e8\u5175\u5212\u5206\u64cd\u4f5c\u5b9e\u73b0\u6392\u5e8f\u3002\u5728\u54e8\u5175\u5212\u5206\u4e2d\uff0c\u6709\u53ef\u80fd\u6bcf\u6b21\u90fd\u9009\u53d6\u5230\u6700\u5dee\u7684\u57fa\u51c6\u6570\uff0c\u5bfc\u81f4\u65f6\u95f4\u590d\u6742\u5ea6\u52a3\u5316\u81f3 \\(O(n^2)\\) \u3002\u5f15\u5165\u4e2d\u4f4d\u6570\u57fa\u51c6\u6570\u6216\u968f\u673a\u57fa\u51c6\u6570\u53ef\u4ee5\u964d\u4f4e\u8fd9\u79cd\u52a3\u5316\u7684\u6982\u7387\u3002\u5c3e\u9012\u5f52\u65b9\u6cd5\u53ef\u4ee5\u6709\u6548\u5730\u51cf\u5c11\u9012\u5f52\u6df1\u5ea6\uff0c\u5c06\u7a7a\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u5230 \\(O(\\log n)\\) \u3002
    • \u5f52\u5e76\u6392\u5e8f\u5305\u62ec\u5212\u5206\u548c\u5408\u5e76\u4e24\u4e2a\u9636\u6bb5\uff0c\u5178\u578b\u5730\u4f53\u73b0\u4e86\u5206\u6cbb\u7b56\u7565\u3002\u5728\u5f52\u5e76\u6392\u5e8f\u4e2d\uff0c\u6392\u5e8f\u6570\u7ec4\u9700\u8981\u521b\u5efa\u8f85\u52a9\u6570\u7ec4\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff1b\u7136\u800c\u6392\u5e8f\u94fe\u8868\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u4f18\u5316\u81f3 \\(O(1)\\) \u3002
    • \u6876\u6392\u5e8f\u5305\u542b\u4e09\u4e2a\u6b65\u9aa4\uff1a\u6570\u636e\u5206\u6876\u3001\u6876\u5185\u6392\u5e8f\u548c\u5408\u5e76\u7ed3\u679c\u3002\u5b83\u540c\u6837\u4f53\u73b0\u4e86\u5206\u6cbb\u7b56\u7565\uff0c\u9002\u7528\u4e8e\u6570\u636e\u4f53\u91cf\u5f88\u5927\u7684\u60c5\u51b5\u3002\u6876\u6392\u5e8f\u7684\u5173\u952e\u5728\u4e8e\u5bf9\u6570\u636e\u8fdb\u884c\u5e73\u5747\u5206\u914d\u3002
    • \u8ba1\u6570\u6392\u5e8f\u662f\u6876\u6392\u5e8f\u7684\u4e00\u4e2a\u7279\u4f8b\uff0c\u5b83\u901a\u8fc7\u7edf\u8ba1\u6570\u636e\u51fa\u73b0\u7684\u6b21\u6570\u6765\u5b9e\u73b0\u6392\u5e8f\u3002\u8ba1\u6570\u6392\u5e8f\u9002\u7528\u4e8e\u6570\u636e\u91cf\u5927\u4f46\u6570\u636e\u8303\u56f4\u6709\u9650\u7684\u60c5\u51b5\uff0c\u5e76\u4e14\u8981\u6c42\u6570\u636e\u80fd\u591f\u8f6c\u6362\u4e3a\u6b63\u6574\u6570\u3002
    • \u57fa\u6570\u6392\u5e8f\u901a\u8fc7\u9010\u4f4d\u6392\u5e8f\u6765\u5b9e\u73b0\u6570\u636e\u6392\u5e8f\uff0c\u8981\u6c42\u6570\u636e\u80fd\u591f\u8868\u793a\u4e3a\u56fa\u5b9a\u4f4d\u6570\u7684\u6570\u5b57\u3002

    Fig. \u6392\u5e8f\u7b97\u6cd5\u5bf9\u6bd4

    • \u603b\u7684\u6765\u8bf4\uff0c\u6211\u4eec\u5e0c\u671b\u627e\u5230\u4e00\u79cd\u6392\u5e8f\u7b97\u6cd5\uff0c\u5177\u6709\u9ad8\u6548\u7387\u3001\u7a33\u5b9a\u3001\u539f\u5730\u4ee5\u53ca\u6b63\u5411\u81ea\u9002\u5e94\u6027\u7b49\u4f18\u70b9\u3002\u7136\u800c\uff0c\u6b63\u5982\u5176\u4ed6\u6570\u636e\u7ed3\u6784\u548c\u7b97\u6cd5\u4e00\u6837\uff0c\u6ca1\u6709\u4e00\u79cd\u6392\u5e8f\u7b97\u6cd5\u80fd\u591f\u540c\u65f6\u6ee1\u8db3\u6240\u6709\u8fd9\u4e9b\u6761\u4ef6\u3002\u5728\u5b9e\u9645\u5e94\u7528\u4e2d\uff0c\u6211\u4eec\u9700\u8981\u6839\u636e\u6570\u636e\u7684\u7279\u6027\u6765\u9009\u62e9\u5408\u9002\u7684\u6392\u5e8f\u7b97\u6cd5\u3002
    "},{"location":"chapter_sorting/summary/#11111-q-a","title":"11.11.1. \u00a0 Q & A","text":"

    \u6392\u5e8f\u7b97\u6cd5\u7a33\u5b9a\u6027\u5728\u4ec0\u4e48\u60c5\u51b5\u4e0b\u662f\u5fc5\u987b\u7684\uff1f

    \u5728\u73b0\u5b9e\u4e2d\uff0c\u6211\u4eec\u6709\u53ef\u80fd\u662f\u5728\u5bf9\u8c61\u7684\u67d0\u4e2a\u5c5e\u6027\u4e0a\u8fdb\u884c\u6392\u5e8f\u3002\u4f8b\u5982\uff0c\u5b66\u751f\u6709\u59d3\u540d\u548c\u8eab\u9ad8\u4e24\u4e2a\u5c5e\u6027\uff0c\u6211\u4eec\u5e0c\u671b\u5b9e\u73b0\u4e00\u4e2a\u591a\u7ea7\u6392\u5e8f/

    \u5148\u6309\u7167\u59d3\u540d\u8fdb\u884c\u6392\u5e8f\uff0c\u5f97\u5230 (A, 180) (B, 185) (C, 170) (D, 170) \uff1b\u63a5\u4e0b\u6765\u5bf9\u8eab\u9ad8\u8fdb\u884c\u6392\u5e8f\u3002\u7531\u4e8e\u6392\u5e8f\u7b97\u6cd5\u4e0d\u7a33\u5b9a\uff0c\u6211\u4eec\u53ef\u80fd\u5f97\u5230 (D, 170) (C, 170) (A, 180) (B, 185) \u3002

    \u53ef\u4ee5\u53d1\u73b0\uff0c\u5b66\u751f D \u548c C \u7684\u4f4d\u7f6e\u53d1\u751f\u4e86\u4ea4\u6362\uff0c\u59d3\u540d\u7684\u6709\u5e8f\u6027\u88ab\u7834\u574f\u4e86\uff0c\u800c\u8fd9\u662f\u6211\u4eec\u4e0d\u5e0c\u671b\u770b\u5230\u7684\u3002

    \u54e8\u5175\u5212\u5206\u4e2d\u201c\u4ece\u53f3\u5f80\u5de6\u67e5\u627e\u201d\u4e0e\u201c\u4ece\u5de6\u5f80\u53f3\u67e5\u627e\u201d\u7684\u987a\u5e8f\u53ef\u4ee5\u4ea4\u6362\u5417\uff1f

    \u4e0d\u884c\uff0c\u5f53\u6211\u4eec\u4ee5\u6700\u5de6\u7aef\u5143\u7d20\u4e3a\u57fa\u51c6\u6570\u65f6\uff0c\u5fc5\u987b\u5148\u201c\u4ece\u53f3\u5f80\u5de6\u67e5\u627e\u201d\u518d\u201c\u4ece\u5de6\u5f80\u53f3\u67e5\u627e\u201d\u3002\u8fd9\u4e2a\u7ed3\u8bba\u6709\u4e9b\u53cd\u76f4\u89c9\uff0c\u6211\u4eec\u6765\u5256\u6790\u4e00\u4e0b\u539f\u56e0\u3002

    \u54e8\u5175\u5212\u5206 partition() \u7684\u6700\u540e\u4e00\u6b65\u662f\u4ea4\u6362 nums[left] \u548c nums[i] \u3002\u5b8c\u6210\u4ea4\u6362\u540e\uff0c\u57fa\u51c6\u6570\u5de6\u8fb9\u7684\u5143\u7d20\u90fd <= \u57fa\u51c6\u6570\uff0c\u8fd9\u5c31\u8981\u6c42\u6700\u540e\u4e00\u6b65\u4ea4\u6362\u524d nums[left] >= nums[i] \u5fc5\u987b\u6210\u7acb\u3002\u5047\u8bbe\u6211\u4eec\u5148\u201c\u4ece\u5de6\u5f80\u53f3\u67e5\u627e\u201d\uff0c\u90a3\u4e48\u5982\u679c\u627e\u4e0d\u5230\u6bd4\u57fa\u51c6\u6570\u66f4\u5c0f\u7684\u5143\u7d20\uff0c\u5219\u4f1a\u5728 i == j \u65f6\u8df3\u51fa\u5faa\u73af\uff0c\u6b64\u65f6\u53ef\u80fd nums[j] == nums[i] > nums[left]\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u6b64\u65f6\u6700\u540e\u4e00\u6b65\u4ea4\u6362\u64cd\u4f5c\u4f1a\u628a\u4e00\u4e2a\u6bd4\u57fa\u51c6\u6570\u66f4\u5927\u7684\u5143\u7d20\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\uff0c\u5bfc\u81f4\u54e8\u5175\u5212\u5206\u5931\u8d25\u3002

    \u4e3e\u4e2a\u4f8b\u5b50\uff0c\u7ed9\u5b9a\u6570\u7ec4 [0, 0, 0, 0, 1] \uff0c\u5982\u679c\u5148\u201c\u4ece\u5de6\u5411\u53f3\u67e5\u627e\u201d\uff0c\u54e8\u5175\u5212\u5206\u540e\u6570\u7ec4\u4e3a [1, 0, 0, 0, 0] \uff0c\u8fd9\u4e2a\u7ed3\u679c\u662f\u4e0d\u6b63\u786e\u7684\u3002

    \u518d\u6df1\u5165\u601d\u8003\u4e00\u4e0b\uff0c\u5982\u679c\u6211\u4eec\u9009\u62e9 nums[right] \u4e3a\u57fa\u51c6\u6570\uff0c\u90a3\u4e48\u6b63\u597d\u53cd\u8fc7\u6765\uff0c\u5fc5\u987b\u5148\u201c\u4ece\u5de6\u5f80\u53f3\u67e5\u627e\u201d\u3002

    \u5173\u4e8e\u5c3e\u9012\u5f52\u4f18\u5316\uff0c\u4e3a\u4ec0\u4e48\u9009\u77ed\u7684\u6570\u7ec4\u80fd\u4fdd\u8bc1\u9012\u5f52\u6df1\u5ea6\u4e0d\u8d85\u8fc7 \\(log n\\) \uff1f

    \u9012\u5f52\u6df1\u5ea6\u5c31\u662f\u5f53\u524d\u672a\u8fd4\u56de\u7684\u9012\u5f52\u65b9\u6cd5\u7684\u6570\u91cf\u3002\u6bcf\u8f6e\u54e8\u5175\u5212\u5206\u6211\u4eec\u5c06\u539f\u6570\u7ec4\u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\u3002\u5728\u5c3e\u9012\u5f52\u4f18\u5316\u540e\uff0c\u5411\u4e0b\u9012\u5f52\u7684\u5b50\u6570\u7ec4\u957f\u5ea6\u6700\u5927\u4e3a\u539f\u6570\u7ec4\u7684\u4e00\u534a\u957f\u5ea6\u3002\u5047\u8bbe\u6700\u5dee\u60c5\u51b5\uff0c\u4e00\u76f4\u4e3a\u4e00\u534a\u957f\u5ea6\uff0c\u90a3\u4e48\u6700\u7ec8\u7684\u9012\u5f52\u6df1\u5ea6\u5c31\u662f \\(log n\\) \u3002

    \u56de\u987e\u539f\u59cb\u7684\u5feb\u901f\u6392\u5e8f\uff0c\u6211\u4eec\u6709\u53ef\u80fd\u4f1a\u8fde\u7eed\u5730\u9012\u5f52\u957f\u5ea6\u8f83\u5927\u7684\u6570\u7ec4\uff0c\u6700\u5dee\u60c5\u51b5\u4e0b\u4e3a \\(n, n - 1, n - 2, ..., 2, 1\\) \uff0c\u4ece\u800c\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \u3002\u5c3e\u9012\u5f52\u4f18\u5316\u53ef\u4ee5\u907f\u514d\u8fd9\u79cd\u60c5\u51b5\u7684\u51fa\u73b0\u3002

    \u5f53\u6570\u7ec4\u4e2d\u6240\u6709\u5143\u7d20\u90fd\u76f8\u7b49\u65f6\uff0c\u5feb\u901f\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(n^2)\\) \u5417\uff1f\u8be5\u5982\u4f55\u5904\u7406\u8fd9\u79cd\u9000\u5316\u60c5\u51b5\uff1f

    \u662f\u7684\u3002\u8fd9\u79cd\u60c5\u51b5\u53ef\u4ee5\u8003\u8651\u901a\u8fc7\u54e8\u5175\u5212\u5206\u5c06\u6570\u7ec4\u5212\u5206\u4e3a\u4e09\u4e2a\u90e8\u5206\uff1a\u5c0f\u4e8e\u3001\u7b49\u4e8e\u3001\u5927\u4e8e\u57fa\u51c6\u6570\u3002\u4ec5\u5411\u4e0b\u9012\u5f52\u5c0f\u4e8e\u548c\u5927\u4e8e\u7684\u4e24\u90e8\u5206\u3002\u5728\u8be5\u65b9\u6cd5\u4e0b\uff0c\u8f93\u5165\u5143\u7d20\u5168\u90e8\u76f8\u7b49\u7684\u6570\u7ec4\uff0c\u4ec5\u4e00\u8f6e\u54e8\u5175\u5212\u5206\u5373\u53ef\u5b8c\u6210\u6392\u5e8f\u3002

    \u6876\u6392\u5e8f\u7684\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a\u4ec0\u4e48\u662f \\(O(n^2)\\) \uff1f

    \u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u6240\u6709\u5143\u7d20\u88ab\u5206\u81f3\u540c\u4e00\u4e2a\u6876\u4e2d\u3002\u5982\u679c\u6211\u4eec\u91c7\u7528\u4e00\u4e2a \\(O(n^2)\\) \u7b97\u6cd5\u6765\u6392\u5e8f\u8fd9\u4e9b\u5143\u7d20\uff0c\u5219\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    "},{"location":"chapter_stack_and_queue/","title":"5. \u00a0 \u6808\u4e0e\u961f\u5217","text":""},{"location":"chapter_stack_and_queue/deque/","title":"5.3. \u00a0 \u53cc\u5411\u961f\u5217","text":"

    \u5bf9\u4e8e\u961f\u5217\uff0c\u6211\u4eec\u4ec5\u80fd\u5728\u5934\u90e8\u5220\u9664\u6216\u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\u3002\u7136\u800c\uff0c\u300c\u53cc\u5411\u961f\u5217 Deque\u300d\u63d0\u4f9b\u4e86\u66f4\u9ad8\u7684\u7075\u6d3b\u6027\uff0c\u5141\u8bb8\u5728\u5934\u90e8\u548c\u5c3e\u90e8\u6267\u884c\u5143\u7d20\u7684\u6dfb\u52a0\u6216\u5220\u9664\u64cd\u4f5c\u3002

    Fig. \u53cc\u5411\u961f\u5217\u7684\u64cd\u4f5c

    "},{"location":"chapter_stack_and_queue/deque/#531","title":"5.3.1. \u00a0 \u53cc\u5411\u961f\u5217\u5e38\u7528\u64cd\u4f5c","text":"

    \u53cc\u5411\u961f\u5217\u7684\u5e38\u7528\u64cd\u4f5c\u5982\u4e0b\u8868\u6240\u793a\uff0c\u5177\u4f53\u7684\u65b9\u6cd5\u540d\u79f0\u9700\u8981\u6839\u636e\u6240\u4f7f\u7528\u7684\u7f16\u7a0b\u8bed\u8a00\u6765\u786e\u5b9a\u3002

    \u65b9\u6cd5\u540d \u63cf\u8ff0 \u65f6\u95f4\u590d\u6742\u5ea6 pushFirst() \u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u961f\u9996 \\(O(1)\\) pushLast() \u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u961f\u5c3e \\(O(1)\\) popFirst() \u5220\u9664\u961f\u9996\u5143\u7d20 \\(O(1)\\) popLast() \u5220\u9664\u961f\u5c3e\u5143\u7d20 \\(O(1)\\) peekFirst() \u8bbf\u95ee\u961f\u9996\u5143\u7d20 \\(O(1)\\) peekLast() \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 \\(O(1)\\)

    \u540c\u6837\u5730\uff0c\u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u4e2d\u5df2\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\u7c7b\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart deque.java
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\nDeque<Integer> deque = new LinkedList<>();\n/* \u5143\u7d20\u5165\u961f */\ndeque.offerLast(2);   // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.offerFirst(1);\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.peekFirst();  // \u961f\u9996\u5143\u7d20\nint peekLast = deque.peekLast();    // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\nint popFirst = deque.pollFirst();  // \u961f\u9996\u5143\u7d20\u51fa\u961f\nint popLast = deque.pollLast();    // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.size();\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = deque.isEmpty();\n
    deque.cpp
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\ndeque<int> deque;\n/* \u5143\u7d20\u5165\u961f */\ndeque.push_back(2);   // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.push_front(1);\n/* \u8bbf\u95ee\u5143\u7d20 */\nint front = deque.front(); // \u961f\u9996\u5143\u7d20\nint back = deque.back();   // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\ndeque.pop_front();  // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.pop_back();   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.size();\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty = deque.empty();\n
    deque.py
    # \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217\ndeque: Deque[int] = collections.deque()\n# \u5143\u7d20\u5165\u961f\ndeque.append(2)      # \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.append(5)\ndeque.append(4)\ndeque.appendleft(3)  # \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.appendleft(1)\n# \u8bbf\u95ee\u5143\u7d20\nfront: int = deque[0]  # \u961f\u9996\u5143\u7d20\nrear: int = deque[-1]  # \u961f\u5c3e\u5143\u7d20\n# \u5143\u7d20\u51fa\u961f\npop_front: int = deque.popleft()  # \u961f\u9996\u5143\u7d20\u51fa\u961f\npop_rear: int = deque.pop()       # \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n# \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nsize: int = len(deque)\n# \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(deque) == 0\n
    deque_test.go
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// \u5728 Go \u4e2d\uff0c\u5c06 list \u4f5c\u4e3a\u53cc\u5411\u961f\u5217\u4f7f\u7528\ndeque := list.New()\n/* \u5143\u7d20\u5165\u961f */\ndeque.PushBack(2)      // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.PushFront(1)\n/* \u8bbf\u95ee\u5143\u7d20 */\nfront := deque.Front() // \u961f\u9996\u5143\u7d20\nrear := deque.Back()   // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\ndeque.Remove(front)    // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.Remove(rear)     // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize := deque.Len()\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty := deque.Len() == 0\n
    deque.js
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// JavaScript \u6ca1\u6709\u5185\u7f6e\u7684\u53cc\u7aef\u961f\u5217\uff0c\u53ea\u80fd\u628a Array \u5f53\u4f5c\u53cc\u7aef\u961f\u5217\u6765\u4f7f\u7528\nconst deque = [];\n/* \u5143\u7d20\u5165\u961f */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// \u8bf7\u6ce8\u610f\uff0c\u7531\u4e8e\u662f\u6570\u7ec4\uff0cunshift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\ndeque.unshift(3);\ndeque.unshift(1);\nconsole.log(\"\u53cc\u5411\u961f\u5217 deque = \", deque);\n/* \u8bbf\u95ee\u5143\u7d20 */\nconst peekFirst = deque[0];\nconsole.log(\"\u961f\u9996\u5143\u7d20 peekFirst = \" + peekFirst);\nconst peekLast = deque[deque.length - 1];\nconsole.log(\"\u961f\u5c3e\u5143\u7d20 peekLast = \" + peekLast);\n/* \u5143\u7d20\u51fa\u961f */\n// \u8bf7\u6ce8\u610f\uff0c\u7531\u4e8e\u662f\u6570\u7ec4\uff0cshift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\nconst popFront = deque.shift();\nconsole.log(\"\u961f\u9996\u51fa\u961f\u5143\u7d20 popFront = \" + popFront + \"\uff0c\u961f\u9996\u51fa\u961f\u540e deque = \" + deque);\nconst popBack = deque.pop();\nconsole.log(\"\u961f\u5c3e\u51fa\u961f\u5143\u7d20 popBack = \" + popBack + \"\uff0c\u961f\u5c3e\u51fa\u961f\u540e deque = \" + deque);\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = deque.length;\nconsole.log(\"\u53cc\u5411\u961f\u5217\u957f\u5ea6 size = \" + size);\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst isEmpty = size === 0;\nconsole.log(\"\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a = \" + isEmpty);\n
    deque.ts
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// TypeScript \u6ca1\u6709\u5185\u7f6e\u7684\u53cc\u7aef\u961f\u5217\uff0c\u53ea\u80fd\u628a Array \u5f53\u4f5c\u53cc\u7aef\u961f\u5217\u6765\u4f7f\u7528\nconst deque: number[] = [];\n/* \u5143\u7d20\u5165\u961f */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// \u8bf7\u6ce8\u610f\uff0c\u7531\u4e8e\u662f\u6570\u7ec4\uff0cunshift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\ndeque.unshift(3);\ndeque.unshift(1);\nconsole.log(\"\u53cc\u5411\u961f\u5217 deque = \", deque);\n/* \u8bbf\u95ee\u5143\u7d20 */\nconst peekFirst: number = deque[0];\nconsole.log(\"\u961f\u9996\u5143\u7d20 peekFirst = \" + peekFirst);\nconst peekLast: number = deque[deque.length - 1];\nconsole.log(\"\u961f\u5c3e\u5143\u7d20 peekLast = \" + peekLast);\n/* \u5143\u7d20\u51fa\u961f */\n// \u8bf7\u6ce8\u610f\uff0c\u7531\u4e8e\u662f\u6570\u7ec4\uff0cshift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\nconst popFront: number = deque.shift() as number;\nconsole.log(\"\u961f\u9996\u51fa\u961f\u5143\u7d20 popFront = \" + popFront + \"\uff0c\u961f\u9996\u51fa\u961f\u540e deque = \" + deque);\nconst popBack: number = deque.pop() as number;\nconsole.log(\"\u961f\u5c3e\u51fa\u961f\u5143\u7d20 popBack = \" + popBack + \"\uff0c\u961f\u5c3e\u51fa\u961f\u540e deque = \" + deque);\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nconst size: number = deque.length;\nconsole.log(\"\u53cc\u5411\u961f\u5217\u957f\u5ea6 size = \" + size);\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst isEmpty: boolean = size === 0;\nconsole.log(\"\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a = \" + isEmpty);\n
    deque.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u53cc\u5411\u961f\u5217\n
    deque.cs
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// \u5728 C# \u4e2d\uff0c\u5c06\u94fe\u8868 LinkedList \u770b\u4f5c\u53cc\u5411\u961f\u5217\u6765\u4f7f\u7528\nLinkedList<int> deque = new LinkedList<int>();\n/* \u5143\u7d20\u5165\u961f */\ndeque.AddLast(2);   // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.AddFirst(1);\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.First.Value;  // \u961f\u9996\u5143\u7d20\nint peekLast = deque.Last.Value;    // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\ndeque.RemoveFirst();  // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.RemoveLast();   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.Count;\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = deque.Count == 0;\n
    deque.swift
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// Swift \u6ca1\u6709\u5185\u7f6e\u7684\u53cc\u5411\u961f\u5217\u7c7b\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u53cc\u5411\u961f\u5217\u6765\u4f7f\u7528\nvar deque: [Int] = []\n/* \u5143\u7d20\u5165\u961f */\ndeque.append(2) // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.insert(1, at: 0)\n/* \u8bbf\u95ee\u5143\u7d20 */\nlet peekFirst = deque.first! // \u961f\u9996\u5143\u7d20\nlet peekLast = deque.last! // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\n// \u4f7f\u7528 Array \u6a21\u62df\u65f6 popFirst \u7684\u590d\u6742\u5ea6\u4e3a O(n)\nlet popFirst = deque.removeFirst() // \u961f\u9996\u5143\u7d20\u51fa\u961f\nlet popLast = deque.removeLast() // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = deque.count\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = deque.isEmpty\n
    deque.zig
    \n
    deque.dart
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// \u5728 Dart \u4e2d\uff0cQueue \u88ab\u5b9a\u4e49\u4e3a\u53cc\u5411\u961f\u5217\nQueue<int> deque = Queue<int>();\n/* \u5143\u7d20\u5165\u961f */\ndeque.addLast(2);  // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.addFirst(1);\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.first; // \u961f\u9996\u5143\u7d20\nint peekLast = deque.last;   // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\nint popFirst = deque.removeFirst(); // \u961f\u9996\u5143\u7d20\u51fa\u961f\nint popLast = deque.removeLast();   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.length;\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = deque.isEmpty;W\n
    "},{"location":"chapter_stack_and_queue/deque/#532","title":"5.3.2. \u00a0 \u53cc\u5411\u961f\u5217\u5b9e\u73b0 *","text":"

    \u53cc\u5411\u961f\u5217\u7684\u5b9e\u73b0\u4e0e\u961f\u5217\u7c7b\u4f3c\uff0c\u53ef\u4ee5\u9009\u62e9\u94fe\u8868\u6216\u6570\u7ec4\u4f5c\u4e3a\u5e95\u5c42\u6570\u636e\u7ed3\u6784\u3002

    "},{"location":"chapter_stack_and_queue/deque/#_1","title":"\u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u7684\u5b9e\u73b0","text":"

    \u56de\u987e\u4e0a\u4e00\u8282\u5185\u5bb9\uff0c\u6211\u4eec\u4f7f\u7528\u666e\u901a\u5355\u5411\u94fe\u8868\u6765\u5b9e\u73b0\u961f\u5217\uff0c\u56e0\u4e3a\u5b83\u53ef\u4ee5\u65b9\u4fbf\u5730\u5220\u9664\u5934\u8282\u70b9\uff08\u5bf9\u5e94\u51fa\u961f\u64cd\u4f5c\uff09\u548c\u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0\u65b0\u8282\u70b9\uff08\u5bf9\u5e94\u5165\u961f\u64cd\u4f5c\uff09\u3002

    \u5bf9\u4e8e\u53cc\u5411\u961f\u5217\u800c\u8a00\uff0c\u5934\u90e8\u548c\u5c3e\u90e8\u90fd\u53ef\u4ee5\u6267\u884c\u5165\u961f\u548c\u51fa\u961f\u64cd\u4f5c\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u53cc\u5411\u961f\u5217\u9700\u8981\u5b9e\u73b0\u53e6\u4e00\u4e2a\u5bf9\u79f0\u65b9\u5411\u7684\u64cd\u4f5c\u3002\u4e3a\u6b64\uff0c\u6211\u4eec\u91c7\u7528\u300c\u53cc\u5411\u94fe\u8868\u300d\u4f5c\u4e3a\u53cc\u5411\u961f\u5217\u7684\u5e95\u5c42\u6570\u636e\u7ed3\u6784\u3002

    \u6211\u4eec\u5c06\u53cc\u5411\u94fe\u8868\u7684\u5934\u8282\u70b9\u548c\u5c3e\u8282\u70b9\u89c6\u4e3a\u53cc\u5411\u961f\u5217\u7684\u961f\u9996\u548c\u961f\u5c3e\uff0c\u540c\u65f6\u5b9e\u73b0\u5728\u4e24\u7aef\u6dfb\u52a0\u548c\u5220\u9664\u8282\u70b9\u7684\u529f\u80fd\u3002

    LinkedListDequepushLast()pushFirst()popLast()popFirst()

    \u4ee5\u4e0b\u662f\u5177\u4f53\u5b9e\u73b0\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linkedlist_deque.java
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\nint val; // \u8282\u70b9\u503c\nListNode next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nListNode prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nListNode(int val) {\nthis.val = val;\nprev = next = null;\n}\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\nprivate ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\nprivate int queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\npublic LinkedListDeque() {\nfront = rear = null;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f\u64cd\u4f5c */\nprivate void push(int num, boolean isFront) {\nListNode node = new ListNode(num);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (isEmpty())\nfront = rear = node;\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelse if (isFront) {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nfront.prev = node;\nnode.next = front;\nfront = node; // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nrear.next = node;\nnode.prev = rear;\nrear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\npublic void pushFirst(int num) {\npush(num, true);\n}\n/* \u961f\u5c3e\u5165\u961f */\npublic void pushLast(int num) {\npush(num, false);\n}\n/* \u51fa\u961f\u64cd\u4f5c */\nprivate Integer pop(boolean isFront) {\n// \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de null\nif (isEmpty())\nreturn null;\nint val;\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif (isFront) {\nval = front.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nListNode fNext = front.next;\nif (fNext != null) {\nfNext.prev = null;\nfront.next = null;\n}\nfront = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n} else {\nval = rear.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nListNode rPrev = rear.prev;\nif (rPrev != null) {\nrPrev.next = null;\nrear.prev = null;\n}\nrear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n}\n/* \u961f\u9996\u51fa\u961f */\npublic Integer popFirst() {\nreturn pop(true);\n}\n/* \u961f\u5c3e\u51fa\u961f */\npublic Integer popLast() {\nreturn pop(false);\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic Integer peekFirst() {\nreturn isEmpty() ? null : front.val;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npublic Integer peekLast() {\nreturn isEmpty() ? null : rear.val;\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\npublic int[] toArray() {\nListNode node = front;\nint[] res = new int[size()];\nfor (int i = 0; i < res.length; i++) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_deque.cpp
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nstruct DoublyListNode {\nint val;              // \u8282\u70b9\u503c\nDoublyListNode *next; // \u540e\u7ee7\u8282\u70b9\u6307\u9488\nDoublyListNode *prev; // \u524d\u9a71\u8282\u70b9\u6307\u9488\nDoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n}\n};\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\nprivate:\nDoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\nint queSize = 0;              // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nLinkedListDeque() : front(nullptr), rear(nullptr) {\n}\n/* \u6790\u6784\u65b9\u6cd5 */\n~LinkedListDeque() {\n// \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\nDoublyListNode *pre, *cur = front;\nwhile (cur != nullptr) {\npre = cur;\ncur = cur->next;\ndelete pre;\n}\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f\u64cd\u4f5c */\nvoid push(int num, bool isFront) {\nDoublyListNode *node = new DoublyListNode(num);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (isEmpty())\nfront = rear = node;\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelse if (isFront) {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nfront->prev = node;\nnode->next = front;\nfront = node; // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nrear->next = node;\nnode->prev = rear;\nrear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(int num) {\npush(num, true);\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(int num) {\npush(num, false);\n}\n/* \u51fa\u961f\u64cd\u4f5c */\nint pop(bool isFront) {\n// \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de -1\nif (isEmpty())\nreturn -1;\nint val;\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif (isFront) {\nval = front->val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nDoublyListNode *fNext = front->next;\nif (fNext != nullptr) {\nfNext->prev = nullptr;\nfront->next = nullptr;\ndelete front;\n}\nfront = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n} else {\nval = rear->val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nDoublyListNode *rPrev = rear->prev;\nif (rPrev != nullptr) {\nrPrev->next = nullptr;\nrear->prev = nullptr;\ndelete rear;\n}\nrear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n}\n/* \u961f\u9996\u51fa\u961f */\nint popFirst() {\nreturn pop(true);\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast() {\nreturn pop(false);\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst() {\nreturn isEmpty() ? -1 : front->val;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast() {\nreturn isEmpty() ? -1 : rear->val;\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nvector<int> toVector() {\nDoublyListNode *node = front;\nvector<int> res(size());\nfor (int i = 0; i < res.size(); i++) {\nres[i] = node->val;\nnode = node->next;\n}\nreturn res;\n}\n};\n
    linkedlist_deque.py
    class ListNode:\n\"\"\"\u53cc\u5411\u94fe\u8868\u8282\u70b9\"\"\"\ndef __init__(self, val: int) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.val: int = val\nself.next: ListNode | None = None  # \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nself.prev: ListNode | None = None  # \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nclass LinkedListDeque:\n\"\"\"\u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\ndef __init__(self) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.front: ListNode | None = None  # \u5934\u8282\u70b9 front\nself.rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\nself.__size: int = 0  # \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\nreturn self.__size\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn self.size() == 0\ndef push(self, num: int, is_front: bool) -> None:\n\"\"\"\u5165\u961f\u64cd\u4f5c\"\"\"\nnode = ListNode(num)\n# \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif self.is_empty():\nself.front = self.rear = node\n# \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelif is_front:\n# \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nself.front.prev = node\nnode.next = self.front\nself.front = node  # \u66f4\u65b0\u5934\u8282\u70b9\n# \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\nelse:\n# \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nself.rear.next = node\nnode.prev = self.rear\nself.rear = node  # \u66f4\u65b0\u5c3e\u8282\u70b9\nself.__size += 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\ndef push_first(self, num: int) -> None:\n\"\"\"\u961f\u9996\u5165\u961f\"\"\"\nself.push(num, True)\ndef push_last(self, num: int) -> None:\n\"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\nself.push(num, False)\ndef pop(self, is_front: bool) -> int:\n\"\"\"\u51fa\u961f\u64cd\u4f5c\"\"\"\n# \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de None\nif self.is_empty():\nreturn None\n# \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif is_front:\nval: int = self.front.val  # \u6682\u5b58\u5934\u8282\u70b9\u503c\n# \u5220\u9664\u5934\u8282\u70b9\nfnext: ListNode | None = self.front.next\nif fnext != None:\nfnext.prev = None\nself.front.next = None\nself.front = fnext  # \u66f4\u65b0\u5934\u8282\u70b9\n# \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\nelse:\nval: int = self.rear.val  # \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n# \u5220\u9664\u5c3e\u8282\u70b9\nrprev: ListNode | None = self.rear.prev\nif rprev != None:\nrprev.next = None\nself.rear.prev = None\nself.rear = rprev  # \u66f4\u65b0\u5c3e\u8282\u70b9\nself.__size -= 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val\ndef pop_first(self) -> int:\n\"\"\"\u961f\u9996\u51fa\u961f\"\"\"\nreturn self.pop(True)\ndef pop_last(self) -> int:\n\"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\nreturn self.pop(False)\ndef peek_first(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\nreturn None if self.is_empty() else self.front.val\ndef peek_last(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\nreturn None if self.is_empty() else self.rear.val\ndef to_array(self) -> list[int]:\n\"\"\"\u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\"\"\"\nnode = self.front\nres = [0] * self.size()\nfor i in range(self.size()):\nres[i] = node.val\nnode = node.next\nreturn res\n
    linkedlist_deque.go
    /* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntype linkedListDeque struct {\n// \u4f7f\u7528\u5185\u7f6e\u5305 list\ndata *list.List\n}\n/* \u521d\u59cb\u5316\u53cc\u7aef\u961f\u5217 */\nfunc newLinkedListDeque() *linkedListDeque {\nreturn &linkedListDeque{\ndata: list.New(),\n}\n}\n/* \u961f\u9996\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushFirst(value any) {\ns.data.PushFront(value)\n}\n/* \u961f\u5c3e\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushLast(value any) {\ns.data.PushBack(value)\n}\n/* \u961f\u9996\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popFirst() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Front()\ns.data.Remove(e)\nreturn e.Value\n}\n/* \u961f\u5c3e\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popLast() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Back()\ns.data.Remove(e)\nreturn e.Value\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListDeque) peekFirst() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Front()\nreturn e.Value\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (s *linkedListDeque) peekLast() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Back()\nreturn e.Value\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListDeque) size() int {\nreturn s.data.Len()\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListDeque) isEmpty() bool {\nreturn s.data.Len() == 0\n}\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListDeque) toList() *list.List {\nreturn s.data\n}\n
    linkedlist_deque.js
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\nprev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\nnext; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\nval; // \u8282\u70b9\u503c\nconstructor(val) {\nthis.val = val;\nthis.next = null;\nthis.prev = null;\n}\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n#front; // \u5934\u8282\u70b9 front\n#rear; // \u5c3e\u8282\u70b9 rear\n#queSize; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nconstructor() {\nthis.#front = null;\nthis.#rear = null;\nthis.#queSize = 0;\n}\n/* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\npushLast(val) {\nconst node = new ListNode(val);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (this.#queSize === 0) {\nthis.#front = node;\nthis.#rear = node;\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nthis.#rear.next = node;\nnode.prev = this.#rear;\nthis.#rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nthis.#queSize++;\n}\n/* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\npushFirst(val) {\nconst node = new ListNode(val);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (this.#queSize === 0) {\nthis.#front = node;\nthis.#rear = node;\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nthis.#front.prev = node;\nnode.next = this.#front;\nthis.#front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n}\nthis.#queSize++;\n}\n/* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\npopLast() {\nif (this.#queSize === 0) {\nreturn null;\n}\nconst value = this.#rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nlet temp = this.#rear.prev;\nif (temp !== null) {\ntemp.next = null;\nthis.#rear.prev = null;\n}\nthis.#rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\nthis.#queSize--;\nreturn value;\n}\n/* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\npopFirst() {\nif (this.#queSize === 0) {\nreturn null;\n}\nconst value = this.#front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nlet temp = this.#front.next;\nif (temp !== null) {\ntemp.prev = null;\nthis.#front.next = null;\n}\nthis.#front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\nthis.#queSize--;\nreturn value;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npeekLast() {\nreturn this.#queSize === 0 ? null : this.#rear.val;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeekFirst() {\nreturn this.#queSize === 0 ? null : this.#front.val;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize() {\nreturn this.#queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty() {\nreturn this.#queSize === 0;\n}\n/* \u6253\u5370\u53cc\u5411\u961f\u5217 */\nprint() {\nconst arr = [];\nlet temp = this.#front;\nwhile (temp !== null) {\narr.push(temp.val);\ntemp = temp.next;\n}\nconsole.log('[' + arr.join(', ') + ']');\n}\n}\n
    linkedlist_deque.ts
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\nprev: ListNode; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\nnext: ListNode; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\nval: number; // \u8282\u70b9\u503c\nconstructor(val: number) {\nthis.val = val;\nthis.next = null;\nthis.prev = null;\n}\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\nprivate front: ListNode; // \u5934\u8282\u70b9 front\nprivate rear: ListNode; // \u5c3e\u8282\u70b9 rear\nprivate queSize: number; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nconstructor() {\nthis.front = null;\nthis.rear = null;\nthis.queSize = 0;\n}\n/* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\npushLast(val: number): void {\nconst node: ListNode = new ListNode(val);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (this.queSize === 0) {\nthis.front = node;\nthis.rear = node;\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nthis.rear.next = node;\nnode.prev = this.rear;\nthis.rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nthis.queSize++;\n}\n/* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\npushFirst(val: number): void {\nconst node: ListNode = new ListNode(val);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (this.queSize === 0) {\nthis.front = node;\nthis.rear = node;\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nthis.front.prev = node;\nnode.next = this.front;\nthis.front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n}\nthis.queSize++;\n}\n/* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\npopLast(): number {\nif (this.queSize === 0) {\nreturn null;\n}\nconst value: number = this.rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nlet temp: ListNode = this.rear.prev;\nif (temp !== null) {\ntemp.next = null;\nthis.rear.prev = null;\n}\nthis.rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\nthis.queSize--;\nreturn value;\n}\n/* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\npopFirst(): number {\nif (this.queSize === 0) {\nreturn null;\n}\nconst value: number = this.front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nlet temp: ListNode = this.front.next;\nif (temp !== null) {\ntemp.prev = null;\nthis.front.next = null;\n}\nthis.front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\nthis.queSize--;\nreturn value;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npeekLast(): number {\nreturn this.queSize === 0 ? null : this.rear.val;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeekFirst(): number {\nreturn this.queSize === 0 ? null : this.front.val;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize(): number {\nreturn this.queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty(): boolean {\nreturn this.queSize === 0;\n}\n/* \u6253\u5370\u53cc\u5411\u961f\u5217 */\nprint(): void {\nconst arr: number[] = [];\nlet temp: ListNode = this.front;\nwhile (temp !== null) {\narr.push(temp.val);\ntemp = temp.next;\n}\nconsole.log('[' + arr.join(', ') + ']');\n}\n}\n
    linkedlist_deque.c
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nstruct doublyListNode {\nint val;                     // \u8282\u70b9\u503c\nstruct doublyListNode *next; // \u540e\u7ee7\u8282\u70b9\nstruct doublyListNode *prev; // \u524d\u9a71\u8282\u70b9\n};\ntypedef struct doublyListNode doublyListNode;\n/* \u6784\u9020\u51fd\u6570 */\ndoublyListNode *newDoublyListNode(int num) {\ndoublyListNode *new = (doublyListNode *)malloc(sizeof(doublyListNode));\nnew->val = num;\nnew->next = NULL;\nnew->prev = NULL;\nreturn new;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delDoublyListNode(doublyListNode *node) {\nfree(node);\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nstruct linkedListDeque {\ndoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\nint queSize;                  // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n};\ntypedef struct linkedListDeque linkedListDeque;\n/* \u6784\u9020\u51fd\u6570 */\nlinkedListDeque *newLinkedListDeque() {\nlinkedListDeque *deque = (linkedListDeque *)malloc(sizeof(linkedListDeque));\ndeque->front = NULL;\ndeque->rear = NULL;\ndeque->queSize = 0;\nreturn deque;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListdeque(linkedListDeque *deque) {\n// \u91ca\u653e\u6240\u6709\u8282\u70b9\nfor (int i = 0; i < deque->queSize && deque->front != NULL; i++) {\ndoublyListNode *tmp = deque->front;\ndeque->front = deque->front->next;\nfree(tmp);\n}\n// \u91ca\u653e deque \u7ed3\u6784\u4f53\nfree(deque);\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(linkedListDeque *deque) {\nreturn deque->queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(linkedListDeque *deque) {\nreturn (size(deque) == 0);\n}\n/* \u5165\u961f */\nvoid push(linkedListDeque *deque, int num, bool isFront) {\ndoublyListNode *node = newDoublyListNode(num);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411node\nif (empty(deque)) {\ndeque->front = deque->rear = node;\n}\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelse if (isFront) {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\ndeque->front->prev = node;\nnode->next = deque->front;\ndeque->front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n}\n// \u5bf9\u5c3e\u5165\u961f\u64cd\u4f5c\nelse {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\ndeque->rear->next = node;\nnode->prev = deque->rear;\ndeque->rear = node;\n}\ndeque->queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(linkedListDeque *deque, int num) {\npush(deque, num, true);\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(linkedListDeque *deque, int num) {\npush(deque, num, false);\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(linkedListDeque *deque) {\nassert(size(deque) && deque->front);\nreturn deque->front->val;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(linkedListDeque *deque) {\nassert(size(deque) && deque->rear);\nreturn deque->rear->val;\n}\n/* \u51fa\u961f */\nint pop(linkedListDeque *deque, bool isFront) {\nif (empty(deque))\nreturn -1;\nint val;\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif (isFront) {\nval = peekFirst(deque); // \u6682\u5b58\u5934\u8282\u70b9\u503c\ndoublyListNode *fNext = deque->front->next;\nif (fNext) {\nfNext->prev = NULL;\ndeque->front->next = NULL;\ndelDoublyListNode(deque->front);\n}\ndeque->front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n}\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\nelse {\nval = peekLast(deque); // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\ndoublyListNode *rPrev = deque->rear->prev;\nif (rPrev) {\nrPrev->next = NULL;\ndeque->rear->prev = NULL;\ndelDoublyListNode(deque->rear);\n}\ndeque->rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\ndeque->queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n}\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(linkedListDeque *deque) {\nreturn pop(deque, true);\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(linkedListDeque *deque) {\nreturn pop(deque, false);\n}\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListDeque(linkedListDeque *deque) {\nint arr[deque->queSize];\n// \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\nint i;\ndoublyListNode *node;\nfor (i = 0, node = deque->front; i < deque->queSize; i++) {\narr[i] = node->val;\nnode = node->next;\n}\nprintArray(arr, deque->queSize);\n}\n
    linkedlist_deque.cs
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\npublic int val;       // \u8282\u70b9\u503c\npublic ListNode? next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\npublic ListNode? prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\npublic ListNode(int val) {\nthis.val = val;\nprev = null;\nnext = null;\n}\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\nprivate ListNode? front, rear; // \u5934\u8282\u70b9 front, \u5c3e\u8282\u70b9 rear\nprivate int queSize = 0;      // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\npublic LinkedListDeque() {\nfront = null;\nrear = null;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f\u64cd\u4f5c */\nprivate void push(int num, bool isFront) {\nListNode node = new ListNode(num);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (isEmpty()) {\nfront = node;\nrear = node;\n}\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelse if (isFront) {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nfront.prev = node;\nnode.next = front;\nfront = node; // \u66f4\u65b0\u5934\u8282\u70b9                           \n}\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\nelse {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nrear.next = node;\nnode.prev = rear;\nrear = node;  // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\npublic void pushFirst(int num) {\npush(num, true);\n}\n/* \u961f\u5c3e\u5165\u961f */\npublic void pushLast(int num) {\npush(num, false);\n}\n/* \u51fa\u961f\u64cd\u4f5c */\nprivate int? pop(bool isFront) {\n// \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de null\nif (isEmpty()) {\nreturn null;\n}\nint val;\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif (isFront) {\nval = front.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nListNode fNext = front.next;\nif (fNext != null) {\nfNext.prev = null;\nfront.next = null;\n}\nfront = fNext;   // \u66f4\u65b0\u5934\u8282\u70b9\n}\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\nelse {\nval = rear.val;  // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nListNode rPrev = rear.prev;\nif (rPrev != null) {\nrPrev.next = null;\nrear.prev = null;\n}\nrear = rPrev;    // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n}\n/* \u961f\u9996\u51fa\u961f */\npublic int? popFirst() {\nreturn pop(true);\n}\n/* \u961f\u5c3e\u51fa\u961f */\npublic int? popLast() {\nreturn pop(false);\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int? peekFirst() {\nreturn isEmpty() ? null : front.val;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npublic int? peekLast() {\nreturn isEmpty() ? null : rear.val;\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\npublic int[] toArray() {\nListNode node = front;\nint[] res = new int[size()];\nfor (int i = 0; i < res.Length; i++) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_deque.swift
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\nvar val: Int // \u8282\u70b9\u503c\nvar next: ListNode? // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nvar prev: ListNode? // \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\ninit(val: Int) {\nself.val = val\n}\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\nprivate var front: ListNode? // \u5934\u8282\u70b9 front\nprivate var rear: ListNode? // \u5c3e\u8282\u70b9 rear\nprivate var queSize: Int // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\ninit() {\nqueSize = 0\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nfunc size() -> Int {\nqueSize\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nsize() == 0\n}\n/* \u5165\u961f\u64cd\u4f5c */\nprivate func push(num: Int, isFront: Bool) {\nlet node = ListNode(val: num)\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif isEmpty() {\nfront = node\nrear = node\n}\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelse if isFront {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nfront?.prev = node\nnode.next = front\nfront = node // \u66f4\u65b0\u5934\u8282\u70b9\n}\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\nelse {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nrear?.next = node\nnode.prev = rear\nrear = node // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize += 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\nfunc pushFirst(num: Int) {\npush(num: num, isFront: true)\n}\n/* \u961f\u5c3e\u5165\u961f */\nfunc pushLast(num: Int) {\npush(num: num, isFront: false)\n}\n/* \u51fa\u961f\u64cd\u4f5c */\nprivate func pop(isFront: Bool) -> Int {\nif isEmpty() {\nfatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n}\nlet val: Int\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif isFront {\nval = front!.val // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nlet fNext = front?.next\nif fNext != nil {\nfNext?.prev = nil\nfront?.next = nil\n}\nfront = fNext // \u66f4\u65b0\u5934\u8282\u70b9\n}\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\nelse {\nval = rear!.val // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nlet rPrev = rear?.prev\nif rPrev != nil {\nrPrev?.next = nil\nrear?.prev = nil\n}\nrear = rPrev // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize -= 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val\n}\n/* \u961f\u9996\u51fa\u961f */\nfunc popFirst() -> Int {\npop(isFront: true)\n}\n/* \u961f\u5c3e\u51fa\u961f */\nfunc popLast() -> Int {\npop(isFront: false)\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc peekFirst() -> Int? {\nisEmpty() ? nil : front?.val\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc peekLast() -> Int? {\nisEmpty() ? nil : rear?.val\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nfunc toArray() -> [Int] {\nvar node = front\nvar res = Array(repeating: 0, count: size())\nfor i in res.indices {\nres[i] = node!.val\nnode = node?.next\n}\nreturn res\n}\n}\n
    linkedlist_deque.zig
    // \u53cc\u5411\u94fe\u8868\u8282\u70b9\nfn ListNode(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nval: T = undefined,     // \u8282\u70b9\u503c\nnext: ?*Self = null,    // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nprev: ?*Self = null,    // \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\n// Initialize a list node with specific value\npub fn init(self: *Self, x: i32) void {\nself.val = x;\nself.next = null;\nself.prev = null;\n}\n};\n}\n// \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\nfn LinkedListDeque(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nfront: ?*ListNode(T) = null,                    // \u5934\u8282\u70b9 front\nrear: ?*ListNode(T) = null,                     // \u5c3e\u8282\u70b9 rear\nque_size: usize = 0,                             // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nmem_arena: ?std.heap.ArenaAllocator = null,\nmem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n// \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator) !void {\nif (self.mem_arena == null) {\nself.mem_arena = std.heap.ArenaAllocator.init(allocator);\nself.mem_allocator = self.mem_arena.?.allocator();\n}\nself.front = null;\nself.rear = null;\nself.que_size = 0;\n}\n// \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.mem_arena == null) return;\nself.mem_arena.?.deinit();\n}\n// \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\npub fn size(self: *Self) usize {\nreturn self.que_size;\n}\n// \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\npub fn isEmpty(self: *Self) bool {\nreturn self.size() == 0;\n}\n// \u5165\u961f\u64cd\u4f5c\npub fn push(self: *Self, num: T, is_front: bool) !void {\nvar node = try self.mem_allocator.create(ListNode(T));\nnode.init(num);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (self.isEmpty()) {\nself.front = node;\nself.rear = node;\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\n} else if (is_front) {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nself.front.?.prev = node;\nnode.next = self.front;\nself.front = node;  // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nself.rear.?.next = node;\nnode.prev = self.rear;\nself.rear = node;   // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nself.que_size += 1;      // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n} // \u961f\u9996\u5165\u961f\npub fn pushFirst(self: *Self, num: T) !void {\ntry self.push(num, true);\n} // \u961f\u5c3e\u5165\u961f\npub fn pushLast(self: *Self, num: T) !void {\ntry self.push(num, false);\n} // \u51fa\u961f\u64cd\u4f5c\npub fn pop(self: *Self, is_front: bool) T {\nif (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\nvar val: T = undefined;\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif (is_front) {\nval = self.front.?.val;     // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nvar fNext = self.front.?.next;\nif (fNext != null) {\nfNext.?.prev = null;\nself.front.?.next = null;\n}\nself.front = fNext;         // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n} else {\nval = self.rear.?.val;      // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nvar rPrev = self.rear.?.prev;\nif (rPrev != null) {\nrPrev.?.next = null;\nself.rear.?.prev = null;\n}\nself.rear = rPrev;          // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nself.que_size -= 1;              // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n} // \u961f\u9996\u51fa\u961f\npub fn popFirst(self: *Self) T {\nreturn self.pop(true);\n} // \u961f\u5c3e\u51fa\u961f\npub fn popLast(self: *Self) T {\nreturn self.pop(false);\n} // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\npub fn peekFirst(self: *Self) T {\nif (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\nreturn self.front.?.val;\n}  // \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\npub fn peekLast(self: *Self) T {\nif (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\nreturn self.rear.?.val;\n}\n// \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\npub fn toArray(self: *Self) ![]T {\nvar node = self.front;\nvar res = try self.mem_allocator.alloc(T, self.size());\n@memset(res, @as(T, 0));\nvar i: usize = 0;\nwhile (i < res.len) : (i += 1) {\nres[i] = node.?.val;\nnode = node.?.next;\n}\nreturn res;\n}\n};\n}\n
    linkedlist_deque.dart
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\nint val; // \u8282\u70b9\u503c\nListNode? next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nListNode? prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nListNode(this.val, {this.next, this.prev});\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u5bf9\u5217 */\nclass LinkedListDeque {\nlate ListNode? _front; // \u5934\u8282\u70b9 _front\nlate ListNode? _rear; // \u5c3e\u8282\u70b9 _rear\nint _queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nLinkedListDeque() {\nthis._front = null;\nthis._rear = null;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u957f\u5ea6 */\nint size() {\nreturn this._queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f\u64cd\u4f5c */\nvoid push(int num, bool isFront) {\nfinal ListNode node = ListNode(num);\nif (isEmpty()) {\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 _front\uff0c_rear \u90fd\u6307\u5411 node\n_front = _rear = node;\n} else if (isFront) {\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n_front!.prev = node;\nnode.next = _front;\n_front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n} else {\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n_rear!.next = node;\nnode.prev = _rear;\n_rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\n_queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(int num) {\npush(num, true);\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(int num) {\npush(num, false);\n}\n/* \u51fa\u961f\u64cd\u4f5c */\nint? pop(bool isFront) {\n// \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de null\nif (isEmpty()) {\nreturn null;\n}\nfinal int val;\nif (isFront) {\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nval = _front!.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nListNode? fNext = _front!.next;\nif (fNext != null) {\nfNext.prev = null;\n_front!.next = null;\n}\n_front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n} else {\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\nval = _rear!.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nListNode? rPrev = _rear!.prev;\nif (rPrev != null) {\nrPrev.next = null;\n_rear!.prev = null;\n}\n_rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\n_queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n}\n/* \u961f\u9996\u51fa\u961f */\nint? popFirst() {\nreturn pop(true);\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint? popLast() {\nreturn pop(false);\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint? peekFirst() {\nreturn _front?.val;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint? peekLast() {\nreturn _rear?.val;\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nList<int> toArray() {\nListNode? node = _front;\nfinal List<int> res = [];\nfor (int i = 0; i < _queSize; i++) {\nres.add(node!.val);\nnode = node.next;\n}\nreturn res;\n}\n}\n
    "},{"location":"chapter_stack_and_queue/deque/#_2","title":"\u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u4e0e\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u961f\u5217\u7c7b\u4f3c\uff0c\u6211\u4eec\u4e5f\u53ef\u4ee5\u4f7f\u7528\u73af\u5f62\u6570\u7ec4\u6765\u5b9e\u73b0\u53cc\u5411\u961f\u5217\u3002\u5728\u961f\u5217\u7684\u5b9e\u73b0\u57fa\u7840\u4e0a\uff0c\u4ec5\u9700\u589e\u52a0\u201c\u961f\u9996\u5165\u961f\u201d\u548c\u201c\u961f\u5c3e\u51fa\u961f\u201d\u7684\u65b9\u6cd5\u3002

    ArrayDequepushLast()pushFirst()popLast()popFirst()

    \u4ee5\u4e0b\u662f\u5177\u4f53\u5b9e\u73b0\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array_deque.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nprivate int[] nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\npublic ArrayDeque(int capacity) {\nthis.nums = new int[capacity];\nfront = queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\npublic int capacity() {\nreturn nums.length;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn queSize == 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nprivate int index(int i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + capacity()) % capacity();\n}\n/* \u961f\u9996\u5165\u961f */\npublic void pushFirst(int num) {\nif (queSize == capacity()) {\nSystem.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nfront = index(front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nnums[front] = num;\nqueSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\npublic void pushLast(int num) {\nif (queSize == capacity()) {\nSystem.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nint rear = index(front + queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\npublic int popFirst() {\nint num = peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfront = index(front + 1);\nqueSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\npublic int popLast() {\nint num = peekLast();\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peekFirst() {\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\nreturn nums[front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npublic int peekLast() {\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nint last = index(front + queSize - 1);\nreturn nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\npublic int[] toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] res = new int[queSize];\nfor (int i = 0, j = front; i < queSize; i++, j++) {\nres[i] = nums[index(j)];\n}\nreturn res;\n}\n}\n
    array_deque.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nprivate:\nvector<int> nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nint front;        // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nint queSize;      // \u53cc\u5411\u961f\u5217\u957f\u5ea6\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nArrayDeque(int capacity) {\nnums.resize(capacity);\nfront = queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity() {\nreturn nums.size();\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn queSize == 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nint index(int i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + capacity()) % capacity();\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(int num) {\nif (queSize == capacity()) {\ncout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nfront = index(front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nnums[front] = num;\nqueSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(int num) {\nif (queSize == capacity()) {\ncout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nint rear = index(front + queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\nint popFirst() {\nint num = peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfront = index(front + 1);\nqueSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast() {\nint num = peekLast();\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst() {\nif (isEmpty())\nthrow out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\nreturn nums[front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast() {\nif (isEmpty())\nthrow out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nint last = index(front + queSize - 1);\nreturn nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nvector<int> toVector() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvector<int> res(queSize);\nfor (int i = 0, j = front; i < queSize; i++, j++) {\nres[i] = nums[index(j)];\n}\nreturn res;\n}\n};\n
    array_deque.py
    class ArrayDeque:\n\"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\ndef __init__(self, capacity: int) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__nums: list[int] = [0] * capacity\nself.__front: int = 0\nself.__size: int = 0\ndef capacity(self) -> int:\n\"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\nreturn len(self.__nums)\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\nreturn self.__size\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn self.__size == 0\ndef index(self, i: int) -> int:\n\"\"\"\u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15\"\"\"\n# \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n# \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n# \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + self.capacity()) % self.capacity()\ndef push_first(self, num: int) -> None:\n\"\"\"\u961f\u9996\u5165\u961f\"\"\"\nif self.__size == self.capacity():\nprint(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n# \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n# \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nself.__front = self.index(self.__front - 1)\n# \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nself.__nums[self.__front] = num\nself.__size += 1\ndef push_last(self, num: int) -> None:\n\"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\nif self.__size == self.capacity():\nprint(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n# \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nrear = self.index(self.__front + self.__size)\n# \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nself.__nums[rear] = num\nself.__size += 1\ndef pop_first(self) -> int:\n\"\"\"\u961f\u9996\u51fa\u961f\"\"\"\nnum = self.peek_first()\n# \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nself.__front = self.index(self.__front + 1)\nself.__size -= 1\nreturn num\ndef pop_last(self) -> int:\n\"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\nnum = self.peek_last()\nself.__size -= 1\nreturn num\ndef peek_first(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\nif self.is_empty():\nraise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\nreturn self.__nums[self.__front]\ndef peek_last(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\nif self.is_empty():\nraise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n# \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nlast = self.index(self.__front + self.__size - 1)\nreturn self.__nums[last]\ndef to_array(self) -> list[int]:\n\"\"\"\u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\"\"\"\n# \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nres = []\nfor i in range(self.__size):\nres.append(self.__nums[self.index(self.__front + i)])\nreturn res\n
    array_deque.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntype arrayDeque struct {\nnums        []int // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nfront       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nqueSize     int   // \u53cc\u5411\u961f\u5217\u957f\u5ea6\nqueCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\nreturn &arrayDeque{\nnums:        make([]int, queCapacity),\nqueCapacity: queCapacity,\nfront:       0,\nqueSize:     0,\n}\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayDeque) size() int {\nreturn q.queSize\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayDeque) isEmpty() bool {\nreturn q.queSize == 0\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nfunc (q *arrayDeque) index(i int) int {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + q.queCapacity) % q.queCapacity\n}\n/* \u961f\u9996\u5165\u961f */\nfunc (q *arrayDeque) pushFirst(num int) {\nif q.queSize == q.queCapacity {\nfmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nq.front = q.index(q.front - 1)\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nq.nums[q.front] = num\nq.queSize++\n}\n/* \u961f\u5c3e\u5165\u961f */\nfunc (q *arrayDeque) pushLast(num int) {\nif q.queSize == q.queCapacity {\nfmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nrear := q.index(q.front + q.queSize)\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nq.nums[rear] = num\nq.queSize++\n}\n/* \u961f\u9996\u51fa\u961f */\nfunc (q *arrayDeque) popFirst() any {\nnum := q.peekFirst()\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nq.front = q.index(q.front + 1)\nq.queSize--\nreturn num\n}\n/* \u961f\u5c3e\u51fa\u961f */\nfunc (q *arrayDeque) popLast() any {\nnum := q.peekLast()\nq.queSize--\nreturn num\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayDeque) peekFirst() any {\nif q.isEmpty() {\nreturn nil\n}\nreturn q.nums[q.front]\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (q *arrayDeque) peekLast() any {\nif q.isEmpty() {\nreturn nil\n}\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nlast := q.index(q.front + q.queSize - 1)\nreturn q.nums[last]\n}\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (q *arrayDeque) toSlice() []int {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nres := make([]int, q.queSize)\nfor i, j := 0, q.front; i < q.queSize; i++ {\nres[i] = q.nums[q.index(j)]\nj++\n}\nreturn res\n}\n
    array_deque.js
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n#nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n#front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n#queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor(capacity) {\nthis.#nums = new Array(capacity);\nthis.#front = 0;\nthis.#queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\ncapacity() {\nreturn this.#nums.length;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize() {\nreturn this.#queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty() {\nreturn this.#queSize === 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nindex(i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + this.capacity()) % this.capacity();\n}\n/* \u961f\u9996\u5165\u961f */\npushFirst(num) {\nif (this.#queSize === this.capacity()) {\nconsole.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nthis.#front = this.index(this.#front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nthis.#nums[this.#front] = num;\nthis.#queSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\npushLast(num) {\nif (this.#queSize === this.capacity()) {\nconsole.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nconst rear = this.index(this.#front + this.#queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nthis.#nums[rear] = num;\nthis.#queSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\npopFirst() {\nconst num = this.peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nthis.#front = this.index(this.#front + 1);\nthis.#queSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\npopLast() {\nconst num = this.peekLast();\nthis.#queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeekFirst() {\nif (this.isEmpty()) throw new Error('The Deque Is Empty.');\nreturn this.#nums[this.#front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npeekLast() {\nif (this.isEmpty()) throw new Error('The Deque Is Empty.');\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nconst last = this.index(this.#front + this.#queSize - 1);\nreturn this.#nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\ntoArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst res = [];\nfor (let i = 0, j = this.#front; i < this.#queSize; i++, j++) {\nres[i] = this.#nums[this.index(j)];\n}\nreturn res;\n}\n}\n
    array_deque.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nprivate nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate queSize: number; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor(capacity: number) {\nthis.nums = new Array(capacity);\nthis.front = 0;\nthis.queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\ncapacity(): number {\nreturn this.nums.length;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize(): number {\nreturn this.queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty(): boolean {\nreturn this.queSize === 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nindex(i: number): number {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + this.capacity()) % this.capacity();\n}\n/* \u961f\u9996\u5165\u961f */\npushFirst(num: number): void {\nif (this.queSize === this.capacity()) {\nconsole.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nthis.front = this.index(this.front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nthis.nums[this.front] = num;\nthis.queSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\npushLast(num: number): void {\nif (this.queSize === this.capacity()) {\nconsole.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nconst rear: number = this.index(this.front + this.queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nthis.nums[rear] = num;\nthis.queSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\npopFirst(): number {\nconst num: number = this.peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nthis.front = this.index(this.front + 1);\nthis.queSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\npopLast(): number {\nconst num: number = this.peekLast();\nthis.queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeekFirst(): number {\nif (this.isEmpty()) throw new Error('The Deque Is Empty.');\nreturn this.nums[this.front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npeekLast(): number {\nif (this.isEmpty()) throw new Error('The Deque Is Empty.');\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nconst last = this.index(this.front + this.queSize - 1);\nreturn this.nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\ntoArray(): number[] {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst res: number[] = [];\nfor (let i = 0, j = this.front; i < this.queSize; i++, j++) {\nres[i] = this.nums[this.index(j)];\n}\nreturn res;\n}\n}\n
    array_deque.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nstruct arrayDeque {\nint *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nint front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nint queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\nint queCapacity; // \u961f\u5217\u5bb9\u91cf\n};\ntypedef struct arrayDeque arrayDeque;\n/* \u6784\u9020\u51fd\u6570 */\narrayDeque *newArrayDeque(int capacity) {\narrayDeque *deque = (arrayDeque *)malloc(sizeof(arrayDeque));\n// \u521d\u59cb\u5316\u6570\u7ec4\ndeque->queCapacity = capacity;\ndeque->nums = (int *)malloc(sizeof(int) * deque->queCapacity);\ndeque->front = deque->queSize = 0;\nreturn deque;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayDeque(arrayDeque *deque) {\nfree(deque->nums);\ndeque->queCapacity = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(arrayDeque *deque) {\nreturn deque->queCapacity;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size(arrayDeque *deque) {\nreturn deque->queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(arrayDeque *deque) {\nreturn deque->queSize == 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nint dequeIndex(arrayDeque *deque, int i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn ((i + capacity(deque)) % capacity(deque));\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(arrayDeque *deque, int num) {\nif (deque->queSize == capacity(deque)) {\nprintf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u56de\u5230\u5c3e\u90e8\ndeque->front = dequeIndex(deque, deque->front - 1);\n// \u5c06 num \u6dfb\u52a0\u5230\u961f\u9996\ndeque->nums[deque->front] = num;\ndeque->queSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(arrayDeque *deque, int num) {\nif (deque->queSize == capacity(deque)) {\nprintf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nint rear = dequeIndex(deque, deque->front + deque->queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque->nums[rear] = num;\ndeque->queSize++;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(arrayDeque *deque) {\n// \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\nassert(empty(deque) == 0);\nreturn deque->nums[deque->front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(arrayDeque *deque) {\n// \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\nassert(empty(deque) == 0);\nint last = dequeIndex(deque, deque->front + deque->queSize - 1);\nreturn deque->nums[last];\n}\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(arrayDeque *deque) {\nint num = peekFirst(deque);\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\ndeque->front = dequeIndex(deque, deque->front + 1);\ndeque->queSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(arrayDeque *deque) {\nint num = peekLast(deque);\ndeque->queSize--;\nreturn num;\n}\n/* \u6253\u5370\u961f\u5217 */\nvoid printArrayDeque(arrayDeque *deque) {\nint arr[deque->queSize];\n// \u62f7\u8d1d\nfor (int i = 0, j = deque->front; i < deque->queSize; i++, j++) {\narr[i] = deque->nums[j % deque->queCapacity];\n}\nprintArray(arr, deque->queSize);\n}\n
    array_deque.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nprivate readonly int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\npublic ArrayDeque(int capacity) {\nthis.nums = new int[capacity];\nfront = queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\npublic int capacity() {\nreturn nums.Length;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn queSize == 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nprivate int index(int i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + capacity()) % capacity();\n}\n/* \u961f\u9996\u5165\u961f */\npublic void pushFirst(int num) {\nif (queSize == capacity()) {\nConsole.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nfront = index(front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nnums[front] = num;\nqueSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\npublic void pushLast(int num) {\nif (queSize == capacity()) {\nConsole.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nint rear = index(front + queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\npublic int popFirst() {\nint num = peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfront = index(front + 1);\nqueSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\npublic int popLast() {\nint num = peekLast();\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peekFirst() {\nif (isEmpty()) {\nthrow new InvalidOperationException();\n}\nreturn nums[front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npublic int peekLast() {\nif (isEmpty()) {\nthrow new InvalidOperationException();\n}\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nint last = index(front + queSize - 1);\nreturn nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\npublic int[] toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] res = new int[queSize];\nfor (int i = 0, j = front; i < queSize; i++, j++) {\nres[i] = nums[index(j)];\n}\nreturn res;\n}\n}\n
    array_deque.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nprivate var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate var front: Int // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate var queSize: Int // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\ninit(capacity: Int) {\nnums = Array(repeating: 0, count: capacity)\nfront = 0\nqueSize = 0\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nfunc capacity() -> Int {\nnums.count\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nfunc size() -> Int {\nqueSize\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nsize() == 0\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nprivate func index(i: Int) -> Int {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\n(i + capacity()) % capacity()\n}\n/* \u961f\u9996\u5165\u961f */\nfunc pushFirst(num: Int) {\nif size() == capacity() {\nprint(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nfront = index(i: front - 1)\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nnums[front] = num\nqueSize += 1\n}\n/* \u961f\u5c3e\u5165\u961f */\nfunc pushLast(num: Int) {\nif size() == capacity() {\nprint(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nlet rear = index(i: front + size())\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num\nqueSize += 1\n}\n/* \u961f\u9996\u51fa\u961f */\nfunc popFirst() -> Int {\nlet num = peekFirst()\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfront = index(i: front + 1)\nqueSize -= 1\nreturn num\n}\n/* \u961f\u5c3e\u51fa\u961f */\nfunc popLast() -> Int {\nlet num = peekLast()\nqueSize -= 1\nreturn num\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc peekFirst() -> Int {\nif isEmpty() {\nfatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n}\nreturn nums[front]\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc peekLast() -> Int {\nif isEmpty() {\nfatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n}\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nlet last = index(i: front + size() - 1)\nreturn nums[last]\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nfunc toArray() -> [Int] {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvar res = Array(repeating: 0, count: size())\nfor (i, j) in sequence(first: (0, front), next: { $0 < self.size() - 1 ? ($0 + 1, $1 + 1) : nil }) {\nres[i] = nums[index(i: j)]\n}\nreturn res\n}\n}\n
    array_deque.zig
    [class]{ArrayDeque}-[func]{}\n
    array_deque.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nlate List<int> _nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nlate int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nlate int _queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\nArrayDeque(int capacity) {\nthis._nums = List.filled(capacity, 0);\nthis._front = this._queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity() {\nreturn _nums.length;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn _queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn _queSize == 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nint index(int i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + capacity()) % capacity();\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(int num) {\nif (_queSize == capacity()) {\nthrow Exception(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 _front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n_front = index(_front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n_nums[_front] = num;\n_queSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(int num) {\nif (_queSize == capacity()) {\nthrow Exception(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nint rear = index(_front + _queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n_nums[rear] = num;\n_queSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\nint popFirst() {\nint num = peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n_front = index(_front + 1);\n_queSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast() {\nint num = peekLast();\n_queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst() {\nif (isEmpty()) {\nthrow Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n}\nreturn _nums[_front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast() {\nif (isEmpty()) {\nthrow Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n}\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nint last = index(_front + _queSize - 1);\nreturn _nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nList<int> toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nList<int> res = List.filled(_queSize, 0);\nfor (int i = 0, j = _front; i < _queSize; i++, j++) {\nres[i] = _nums[index(j)];\n}\nreturn res;\n}\n}\n
    "},{"location":"chapter_stack_and_queue/deque/#533","title":"5.3.3. \u00a0 \u53cc\u5411\u961f\u5217\u5e94\u7528","text":"

    \u53cc\u5411\u961f\u5217\u517c\u5177\u6808\u4e0e\u961f\u5217\u7684\u903b\u8f91\uff0c\u56e0\u6b64\u5b83\u53ef\u4ee5\u5b9e\u73b0\u8fd9\u4e24\u8005\u7684\u6240\u6709\u5e94\u7528\u573a\u666f\uff0c\u540c\u65f6\u63d0\u4f9b\u66f4\u9ad8\u7684\u81ea\u7531\u5ea6\u3002

    \u6211\u4eec\u77e5\u9053\uff0c\u8f6f\u4ef6\u7684\u201c\u64a4\u9500\u201d\u529f\u80fd\u901a\u5e38\u4f7f\u7528\u6808\u6765\u5b9e\u73b0\uff1a\u7cfb\u7edf\u5c06\u6bcf\u6b21\u66f4\u6539\u64cd\u4f5c push \u5230\u6808\u4e2d\uff0c\u7136\u540e\u901a\u8fc7 pop \u5b9e\u73b0\u64a4\u9500\u3002\u7136\u800c\uff0c\u8003\u8651\u5230\u7cfb\u7edf\u8d44\u6e90\u7684\u9650\u5236\uff0c\u8f6f\u4ef6\u901a\u5e38\u4f1a\u9650\u5236\u64a4\u9500\u7684\u6b65\u6570\uff08\u4f8b\u5982\u4ec5\u5141\u8bb8\u4fdd\u5b58 \\(50\\) \u6b65\uff09\u3002\u5f53\u6808\u7684\u957f\u5ea6\u8d85\u8fc7 \\(50\\) \u65f6\uff0c\u8f6f\u4ef6\u9700\u8981\u5728\u6808\u5e95\uff08\u5373\u961f\u9996\uff09\u6267\u884c\u5220\u9664\u64cd\u4f5c\u3002\u4f46\u6808\u65e0\u6cd5\u5b9e\u73b0\u8be5\u529f\u80fd\uff0c\u6b64\u65f6\u5c31\u9700\u8981\u4f7f\u7528\u53cc\u5411\u961f\u5217\u6765\u66ff\u4ee3\u6808\u3002\u8bf7\u6ce8\u610f\uff0c\u201c\u64a4\u9500\u201d\u7684\u6838\u5fc3\u903b\u8f91\u4ecd\u7136\u9075\u5faa\u6808\u7684\u5148\u5165\u540e\u51fa\u539f\u5219\uff0c\u53ea\u662f\u53cc\u5411\u961f\u5217\u80fd\u591f\u66f4\u52a0\u7075\u6d3b\u5730\u5b9e\u73b0\u4e00\u4e9b\u989d\u5916\u903b\u8f91\u3002

    "},{"location":"chapter_stack_and_queue/queue/","title":"5.2. \u00a0 \u961f\u5217","text":"

    \u300c\u961f\u5217 Queue\u300d\u662f\u4e00\u79cd\u9075\u5faa\u5148\u5165\u5148\u51fa\uff08First In, First Out\uff09\u89c4\u5219\u7684\u7ebf\u6027\u6570\u636e\u7ed3\u6784\u3002\u987e\u540d\u601d\u4e49\uff0c\u961f\u5217\u6a21\u62df\u4e86\u6392\u961f\u73b0\u8c61\uff0c\u5373\u65b0\u6765\u7684\u4eba\u4e0d\u65ad\u52a0\u5165\u961f\u5217\u7684\u5c3e\u90e8\uff0c\u800c\u4f4d\u4e8e\u961f\u5217\u5934\u90e8\u7684\u4eba\u9010\u4e2a\u79bb\u5f00\u3002

    \u6211\u4eec\u628a\u961f\u5217\u7684\u5934\u90e8\u79f0\u4e3a\u300c\u961f\u9996\u300d\uff0c\u5c3e\u90e8\u79f0\u4e3a\u300c\u961f\u5c3e\u300d\uff0c\u628a\u5c06\u5143\u7d20\u52a0\u5165\u961f\u5c3e\u7684\u64cd\u4f5c\u79f0\u4e3a\u300c\u5165\u961f\u300d\uff0c\u5220\u9664\u961f\u9996\u5143\u7d20\u7684\u64cd\u4f5c\u79f0\u4e3a\u300c\u51fa\u961f\u300d\u3002

    Fig. \u961f\u5217\u7684\u5148\u5165\u5148\u51fa\u89c4\u5219

    "},{"location":"chapter_stack_and_queue/queue/#521","title":"5.2.1. \u00a0 \u961f\u5217\u5e38\u7528\u64cd\u4f5c","text":"

    \u961f\u5217\u7684\u5e38\u89c1\u64cd\u4f5c\u5982\u4e0b\u8868\u6240\u793a\u3002\u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u4e0d\u540c\u7f16\u7a0b\u8bed\u8a00\u7684\u65b9\u6cd5\u540d\u79f0\u53ef\u80fd\u4f1a\u6709\u6240\u4e0d\u540c\u3002\u6211\u4eec\u5728\u6b64\u91c7\u7528\u4e0e\u6808\u76f8\u540c\u7684\u65b9\u6cd5\u547d\u540d\u3002

    \u65b9\u6cd5\u540d \u63cf\u8ff0 \u65f6\u95f4\u590d\u6742\u5ea6 push() \u5143\u7d20\u5165\u961f\uff0c\u5373\u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u961f\u5c3e \\(O(1)\\) pop() \u961f\u9996\u5143\u7d20\u51fa\u961f \\(O(1)\\) peek() \u8bbf\u95ee\u961f\u9996\u5143\u7d20 \\(O(1)\\)

    \u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u4e2d\u73b0\u6210\u7684\u961f\u5217\u7c7b\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart queue.java
    /* \u521d\u59cb\u5316\u961f\u5217 */\nQueue<Integer> queue = new LinkedList<>();\n/* \u5143\u7d20\u5165\u961f */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.peek();\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.poll();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.size();\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = queue.isEmpty();\n
    queue.cpp
    /* \u521d\u59cb\u5316\u961f\u5217 */\nqueue<int> queue;\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint front = queue.front();\n/* \u5143\u7d20\u51fa\u961f */\nqueue.pop();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.size();\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty = queue.empty();\n
    queue.py
    # \u521d\u59cb\u5316\u961f\u5217\n# \u5728 Python \u4e2d\uff0c\u6211\u4eec\u4e00\u822c\u5c06\u53cc\u5411\u961f\u5217\u7c7b deque \u770b\u4f5c\u961f\u5217\u4f7f\u7528\n# \u867d\u7136 queue.Queue() \u662f\u7eaf\u6b63\u7684\u961f\u5217\u7c7b\uff0c\u4f46\u4e0d\u592a\u597d\u7528\uff0c\u56e0\u6b64\u4e0d\u5efa\u8bae\nque: Deque[int] = collections.deque()\n# \u5143\u7d20\u5165\u961f\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n# \u8bbf\u95ee\u961f\u9996\u5143\u7d20\nfront: int = que[0];\n# \u5143\u7d20\u51fa\u961f\npop: int = que.popleft()\n# \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\nsize: int = len(que)\n# \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(que) == 0\n
    queue_test.go
    /* \u521d\u59cb\u5316\u961f\u5217 */\n// \u5728 Go \u4e2d\uff0c\u5c06 list \u4f5c\u4e3a\u961f\u5217\u6765\u4f7f\u7528\nqueue := list.New()\n/* \u5143\u7d20\u5165\u961f */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek := queue.Front()\n/* \u5143\u7d20\u51fa\u961f */\npop := queue.Front()\nqueue.Remove(pop)\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nsize := queue.Len()\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty := queue.Len() == 0\n
    queue.js
    /* \u521d\u59cb\u5316\u961f\u5217 */\n// JavaScript \u6ca1\u6709\u5185\u7f6e\u7684\u961f\u5217\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u961f\u5217\u6765\u4f7f\u7528\nconst queue = [];\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nconst peek = queue[0];\n/* \u5143\u7d20\u51fa\u961f */\n// \u5e95\u5c42\u662f\u6570\u7ec4\uff0c\u56e0\u6b64 shift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\nconst pop = queue.shift();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = queue.length;\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst empty = queue.length === 0;\n
    queue.ts
    /* \u521d\u59cb\u5316\u961f\u5217 */\n// TypeScript \u6ca1\u6709\u5185\u7f6e\u7684\u961f\u5217\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u961f\u5217\u6765\u4f7f\u7528 \nconst queue: number[] = [];\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nconst peek = queue[0];\n/* \u5143\u7d20\u51fa\u961f */\n// \u5e95\u5c42\u662f\u6570\u7ec4\uff0c\u56e0\u6b64 shift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\nconst pop = queue.shift();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = queue.length;\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst empty = queue.length === 0;\n
    queue.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u961f\u5217\n
    queue.cs
    /* \u521d\u59cb\u5316\u961f\u5217 */\nQueue<int> queue = new();\n/* \u5143\u7d20\u5165\u961f */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.Peek();\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.Dequeue();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.Count();\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = queue.Count() == 0;\n
    queue.swift
    /* \u521d\u59cb\u5316\u961f\u5217 */\n// Swift \u6ca1\u6709\u5185\u7f6e\u7684\u961f\u5217\u7c7b\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u961f\u5217\u6765\u4f7f\u7528\nvar queue: [Int] = []\n/* \u5143\u7d20\u5165\u961f */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nlet peek = queue.first!\n/* \u5143\u7d20\u51fa\u961f */\n// \u7531\u4e8e\u662f\u6570\u7ec4\uff0c\u56e0\u6b64 removeFirst \u7684\u590d\u6742\u5ea6\u4e3a O(n)\nlet pool = queue.removeFirst()\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = queue.count\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = queue.isEmpty\n
    queue.zig
    \n
    queue.dart
    /* \u521d\u59cb\u5316\u961f\u5217 */\n// \u5728 Dart \u4e2d\uff0c\u961f\u5217\u7c7b Qeque \u662f\u53cc\u5411\u961f\u5217\uff0c\u4e5f\u53ef\u4f5c\u4e3a\u961f\u5217\u4f7f\u7528\nQueue<int> queue = Queue();\n/* \u5143\u7d20\u5165\u961f */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.first;\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.removeFirst();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.length;\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = queue.isEmpty;\n
    "},{"location":"chapter_stack_and_queue/queue/#522","title":"5.2.2. \u00a0 \u961f\u5217\u5b9e\u73b0","text":"

    \u4e3a\u4e86\u5b9e\u73b0\u961f\u5217\uff0c\u6211\u4eec\u9700\u8981\u4e00\u79cd\u6570\u636e\u7ed3\u6784\uff0c\u53ef\u4ee5\u5728\u4e00\u7aef\u6dfb\u52a0\u5143\u7d20\uff0c\u5e76\u5728\u53e6\u4e00\u7aef\u5220\u9664\u5143\u7d20\u3002\u56e0\u6b64\uff0c\u94fe\u8868\u548c\u6570\u7ec4\u90fd\u53ef\u4ee5\u7528\u6765\u5b9e\u73b0\u961f\u5217\u3002

    "},{"location":"chapter_stack_and_queue/queue/#_1","title":"\u57fa\u4e8e\u94fe\u8868\u7684\u5b9e\u73b0","text":"

    \u5bf9\u4e8e\u94fe\u8868\u5b9e\u73b0\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u94fe\u8868\u7684\u300c\u5934\u8282\u70b9\u300d\u548c\u300c\u5c3e\u8282\u70b9\u300d\u5206\u522b\u89c6\u4e3a\u961f\u9996\u548c\u961f\u5c3e\uff0c\u89c4\u5b9a\u961f\u5c3e\u4ec5\u53ef\u6dfb\u52a0\u8282\u70b9\uff0c\u800c\u961f\u9996\u4ec5\u53ef\u5220\u9664\u8282\u70b9\u3002

    LinkedListQueuepush()pop()

    \u4ee5\u4e0b\u662f\u7528\u94fe\u8868\u5b9e\u73b0\u961f\u5217\u7684\u793a\u4f8b\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linkedlist_queue.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nprivate ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\nprivate int queSize = 0;\npublic LinkedListQueue() {\nfront = null;\nrear = null;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f */\npublic void push(int num) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nListNode node = new ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (front == null) {\nfront = node;\nrear = node;\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n} else {\nrear.next = node;\nrear = node;\n}\nqueSize++;\n}\n/* \u51fa\u961f */\npublic int pop() {\nint num = peek();\n// \u5220\u9664\u5934\u8282\u70b9\nfront = front.next;\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peek() {\nif (size() == 0)\nthrow new IndexOutOfBoundsException();\nreturn front.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic int[] toArray() {\nListNode node = front;\nint[] res = new int[size()];\nfor (int i = 0; i < res.length; i++) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_queue.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nprivate:\nListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\nint queSize;\npublic:\nLinkedListQueue() {\nfront = nullptr;\nrear = nullptr;\nqueSize = 0;\n}\n~LinkedListQueue() {\n// \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\nfreeMemoryLinkedList(front);\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty() {\nreturn queSize == 0;\n}\n/* \u5165\u961f */\nvoid push(int num) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nListNode *node = new ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (front == nullptr) {\nfront = node;\nrear = node;\n}\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\nelse {\nrear->next = node;\nrear = node;\n}\nqueSize++;\n}\n/* \u51fa\u961f */\nvoid pop() {\nint num = peek();\n// \u5220\u9664\u5934\u8282\u70b9\nListNode *tmp = front;\nfront = front->next;\n// \u91ca\u653e\u5185\u5b58\ndelete tmp;\nqueSize--;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek() {\nif (size() == 0)\nthrow out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\nreturn front->val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\nvector<int> toVector() {\nListNode *node = front;\nvector<int> res(size());\nfor (int i = 0; i < res.size(); i++) {\nres[i] = node->val;\nnode = node->next;\n}\nreturn res;\n}\n};\n
    linkedlist_queue.py
    class LinkedListQueue:\n\"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__front: ListNode | None = None  # \u5934\u8282\u70b9 front\nself.__rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\nself.__size: int = 0\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\nreturn self.__size\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn not self.__front\ndef push(self, num: int) -> None:\n\"\"\"\u5165\u961f\"\"\"\n# \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nnode = ListNode(num)\n# \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif self.__front is None:\nself.__front = node\nself.__rear = node\n# \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\nelse:\nself.__rear.next = node\nself.__rear = node\nself.__size += 1\ndef pop(self) -> int:\n\"\"\"\u51fa\u961f\"\"\"\nnum = self.peek()\n# \u5220\u9664\u5934\u8282\u70b9\nself.__front = self.__front.next\nself.__size -= 1\nreturn num\ndef peek(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\nif self.size() == 0:\nprint(\"\u961f\u5217\u4e3a\u7a7a\")\nreturn False\nreturn self.__front.val\ndef to_list(self) -> list[int]:\n\"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\nqueue = []\ntemp = self.__front\nwhile temp:\nqueue.append(temp.val)\ntemp = temp.next\nreturn queue\n
    linkedlist_queue.go
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\ntype linkedListQueue struct {\n// \u4f7f\u7528\u5185\u7f6e\u5305 list \u6765\u5b9e\u73b0\u961f\u5217\ndata *list.List\n}\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newLinkedListQueue() *linkedListQueue {\nreturn &linkedListQueue{\ndata: list.New(),\n}\n}\n/* \u5165\u961f */\nfunc (s *linkedListQueue) push(value any) {\ns.data.PushBack(value)\n}\n/* \u51fa\u961f */\nfunc (s *linkedListQueue) pop() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Front()\ns.data.Remove(e)\nreturn e.Value\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListQueue) peek() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Front()\nreturn e.Value\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListQueue) size() int {\nreturn s.data.Len()\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListQueue) isEmpty() bool {\nreturn s.data.Len() == 0\n}\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListQueue) toList() *list.List {\nreturn s.data\n}\n
    linkedlist_queue.js
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n#front; // \u5934\u8282\u70b9 #front\n#rear; // \u5c3e\u8282\u70b9 #rear\n#queSize = 0;\nconstructor() {\nthis.#front = null;\nthis.#rear = null;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nget size() {\nreturn this.#queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty() {\nreturn this.size === 0;\n}\n/* \u5165\u961f */\npush(num) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nconst node = new ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (!this.#front) {\nthis.#front = node;\nthis.#rear = node;\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n} else {\nthis.#rear.next = node;\nthis.#rear = node;\n}\nthis.#queSize++;\n}\n/* \u51fa\u961f */\npop() {\nconst num = this.peek();\n// \u5220\u9664\u5934\u8282\u70b9\nthis.#front = this.#front.next;\nthis.#queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek() {\nif (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\nreturn this.#front.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\ntoArray() {\nlet node = this.#front;\nconst res = new Array(this.size);\nfor (let i = 0; i < res.length; i++) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_queue.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nprivate front: ListNode | null; // \u5934\u8282\u70b9 front\nprivate rear: ListNode | null; // \u5c3e\u8282\u70b9 rear\nprivate queSize: number = 0;\nconstructor() {\nthis.front = null;\nthis.rear = null;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nget size(): number {\nreturn this.queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty(): boolean {\nreturn this.size === 0;\n}\n/* \u5165\u961f */\npush(num: number): void {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nconst node = new ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (!this.front) {\nthis.front = node;\nthis.rear = node;\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n} else {\nthis.rear!.next = node;\nthis.rear = node;\n}\nthis.queSize++;\n}\n/* \u51fa\u961f */\npop(): number {\nconst num = this.peek();\nif (!this.front) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n// \u5220\u9664\u5934\u8282\u70b9\nthis.front = this.front.next;\nthis.queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek(): number {\nif (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\nreturn this.front!.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\ntoArray(): number[] {\nlet node = this.front;\nconst res = new Array<number>(this.size);\nfor (let i = 0; i < res.length; i++) {\nres[i] = node!.val;\nnode = node!.next;\n}\nreturn res;\n}\n}\n
    linkedlist_queue.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nstruct linkedListQueue {\nListNode *front, *rear;\nint queSize;\n};\ntypedef struct linkedListQueue linkedListQueue;\n/* \u6784\u9020\u51fd\u6570 */\nlinkedListQueue *newLinkedListQueue() {\nlinkedListQueue *queue = (linkedListQueue *)malloc(sizeof(linkedListQueue));\nqueue->front = NULL;\nqueue->rear = NULL;\nqueue->queSize = 0;\nreturn queue;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListQueue(linkedListQueue *queue) {\n// \u91ca\u653e\u6240\u6709\u8282\u70b9\nfor (int i = 0; i < queue->queSize && queue->front != NULL; i++) {\nListNode *tmp = queue->front;\nqueue->front = queue->front->next;\nfree(tmp);\n}\n// \u91ca\u653e queue \u7ed3\u6784\u4f53\nfree(queue);\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(linkedListQueue *queue) {\nreturn queue->queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(linkedListQueue *queue) {\nreturn (size(queue) == 0);\n}\n/* \u5165\u961f */\nvoid push(linkedListQueue *queue, int num) {\n// \u5c3e\u8282\u70b9\u5904\u6dfb\u52a0 node\nListNode *node = newListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (queue->front == NULL) {\nqueue->front = node;\nqueue->rear = node;\n}\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\nelse {\nqueue->rear->next = node;\nqueue->rear = node;\n}\nqueue->queSize++;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(linkedListQueue *queue) {\nassert(size(queue) && queue->front);\nreturn queue->front->val;\n}\n/* \u51fa\u961f */\nvoid pop(linkedListQueue *queue) {\nint num = peek(queue);\nListNode *tmp = queue->front;\nqueue->front = queue->front->next;\nfree(tmp);\nqueue->queSize--;\n}\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListQueue(linkedListQueue *queue) {\nint arr[queue->queSize];\n// \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\nint i;\nListNode *node;\nfor (i = 0, node = queue->front; i < queue->queSize && queue->front != queue->rear; i++) {\narr[i] = node->val;\nnode = node->next;\n}\nprintArray(arr, queue->queSize);\n}\n
    linkedlist_queue.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nprivate ListNode? front, rear;  // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear \nprivate int queSize = 0;\npublic LinkedListQueue() {\nfront = null;\nrear = null;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f */\npublic void push(int num) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nListNode node = new ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (front == null) {\nfront = node;\nrear = node;\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n} else if (rear != null) {\nrear.next = node;\nrear = node;\n}\nqueSize++;\n}\n/* \u51fa\u961f */\npublic int pop() {\nint num = peek();\n// \u5220\u9664\u5934\u8282\u70b9\nfront = front?.next;\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peek() {\nif (size() == 0 || front == null)\nthrow new Exception();\nreturn front.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic int[] toArray() {\nif (front == null)\nreturn Array.Empty<int>();\nListNode node = front;\nint[] res = new int[size()];\nfor (int i = 0; i < res.Length; i++) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_queue.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nprivate var front: ListNode? // \u5934\u8282\u70b9\nprivate var rear: ListNode? // \u5c3e\u8282\u70b9\nprivate var _size = 0\ninit() {}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc size() -> Int {\n_size\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nsize() == 0\n}\n/* \u5165\u961f */\nfunc push(num: Int) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nlet node = ListNode(x: num)\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif front == nil {\nfront = node\nrear = node\n}\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\nelse {\nrear?.next = node\nrear = node\n}\n_size += 1\n}\n/* \u51fa\u961f */\n@discardableResult\nfunc pop() -> Int {\nlet num = peek()\n// \u5220\u9664\u5934\u8282\u70b9\nfront = front?.next\n_size -= 1\nreturn num\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc peek() -> Int {\nif isEmpty() {\nfatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n}\nreturn front!.val\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nfunc toArray() -> [Int] {\nvar node = front\nvar res = Array(repeating: 0, count: size())\nfor i in res.indices {\nres[i] = node!.val\nnode = node?.next\n}\nreturn res\n}\n}\n
    linkedlist_queue.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\nfn LinkedListQueue(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nfront: ?*inc.ListNode(T) = null,                // \u5934\u8282\u70b9 front\nrear: ?*inc.ListNode(T) = null,                 // \u5c3e\u8282\u70b9 rear\nque_size: usize = 0,                            // \u961f\u5217\u7684\u957f\u5ea6\nmem_arena: ?std.heap.ArenaAllocator = null,\nmem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n// \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator) !void {\nif (self.mem_arena == null) {\nself.mem_arena = std.heap.ArenaAllocator.init(allocator);\nself.mem_allocator = self.mem_arena.?.allocator();\n}\nself.front = null;\nself.rear = null;\nself.que_size = 0;\n}\n// \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.mem_arena == null) return;\nself.mem_arena.?.deinit();\n}\n// \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\npub fn size(self: *Self) usize {\nreturn self.que_size;\n}\n// \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\npub fn isEmpty(self: *Self) bool {\nreturn self.size() == 0;\n}\n// \u8bbf\u95ee\u961f\u9996\u5143\u7d20\npub fn peek(self: *Self) T {\nif (self.size() == 0) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\nreturn self.front.?.val;\n}  // \u5165\u961f\npub fn push(self: *Self, num: T) !void {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nvar node = try self.mem_allocator.create(inc.ListNode(T));\nnode.init(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (self.front == null) {\nself.front = node;\nself.rear = node;\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n} else {\nself.rear.?.next = node;\nself.rear = node;\n}\nself.que_size += 1;\n} // \u51fa\u961f\npub fn pop(self: *Self) T {\nvar num = self.peek();\n// \u5220\u9664\u5934\u8282\u70b9\nself.front = self.front.?.next;\nself.que_size -= 1;\nreturn num;\n} // \u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\npub fn toArray(self: *Self) ![]T {\nvar node = self.front;\nvar res = try self.mem_allocator.alloc(T, self.size());\n@memset(res, @as(T, 0));\nvar i: usize = 0;\nwhile (i < res.len) : (i += 1) {\nres[i] = node.?.val;\nnode = node.?.next;\n}\nreturn res;\n}\n};\n}\n
    linkedlist_queue.dart
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nListNode? _front; // \u5934\u8282\u70b9 _front\nListNode? _rear; // \u5c3e\u8282\u70b9 _rear\nint _queSize = 0; // \u961f\u5217\u957f\u5ea6\nLinkedListQueue() {\n_front = null;\n_rear = null;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn _queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn _queSize == 0;\n}\n/* \u5165\u961f */\nvoid push(int num) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nfinal node = ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (_front == null) {\n_front = node;\n_rear = node;\n} else {\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n_rear!.next = node;\n_rear = node;\n}\n_queSize++;\n}\n/* \u51fa\u961f */\nint pop() {\nfinal int num = peek();\n// \u5220\u9664\u5934\u8282\u70b9\n_front = _front!.next;\n_queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek() {\nif (_queSize == 0) {\nthrow Exception('\u961f\u5217\u4e3a\u7a7a');\n}\nreturn _front!.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nList<int> toArray() {\nListNode? node = _front;\nfinal List<int> queue = [];\nwhile (node != null) {\nqueue.add(node.val);\nnode = node.next;\n}\nreturn queue;\n}\n}\n
    "},{"location":"chapter_stack_and_queue/queue/#_2","title":"\u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u7531\u4e8e\u6570\u7ec4\u5220\u9664\u9996\u5143\u7d20\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u8fd9\u4f1a\u5bfc\u81f4\u51fa\u961f\u64cd\u4f5c\u6548\u7387\u8f83\u4f4e\u3002\u7136\u800c\uff0c\u6211\u4eec\u53ef\u4ee5\u91c7\u7528\u4ee5\u4e0b\u5de7\u5999\u65b9\u6cd5\u6765\u907f\u514d\u8fd9\u4e2a\u95ee\u9898\u3002

    \u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4e00\u4e2a\u53d8\u91cf front \u6307\u5411\u961f\u9996\u5143\u7d20\u7684\u7d22\u5f15\uff0c\u5e76\u7ef4\u62a4\u4e00\u4e2a\u53d8\u91cf queSize \u7528\u4e8e\u8bb0\u5f55\u961f\u5217\u957f\u5ea6\u3002\u5b9a\u4e49 rear = front + queSize \uff0c\u8fd9\u4e2a\u516c\u5f0f\u8ba1\u7b97\u51fa\u7684 rear \u6307\u5411\u961f\u5c3e\u5143\u7d20\u4e4b\u540e\u7684\u4e0b\u4e00\u4e2a\u4f4d\u7f6e\u3002

    \u57fa\u4e8e\u6b64\u8bbe\u8ba1\uff0c\u6570\u7ec4\u4e2d\u5305\u542b\u5143\u7d20\u7684\u6709\u6548\u533a\u95f4\u4e3a [front, rear - 1]\uff0c\u8fdb\u800c\uff1a

    • \u5bf9\u4e8e\u5165\u961f\u64cd\u4f5c\uff0c\u5c06\u8f93\u5165\u5143\u7d20\u8d4b\u503c\u7ed9 rear \u7d22\u5f15\u5904\uff0c\u5e76\u5c06 queSize \u589e\u52a0 1 \uff1b
    • \u5bf9\u4e8e\u51fa\u961f\u64cd\u4f5c\uff0c\u53ea\u9700\u5c06 front \u589e\u52a0 1 \uff0c\u5e76\u5c06 queSize \u51cf\u5c11 1 \uff1b

    \u53ef\u4ee5\u770b\u5230\uff0c\u5165\u961f\u548c\u51fa\u961f\u64cd\u4f5c\u90fd\u53ea\u9700\u8fdb\u884c\u4e00\u6b21\u64cd\u4f5c\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(1)\\) \u3002

    ArrayQueuepush()pop()

    \u4f60\u53ef\u80fd\u4f1a\u53d1\u73b0\u4e00\u4e2a\u95ee\u9898\uff1a\u5728\u4e0d\u65ad\u8fdb\u884c\u5165\u961f\u548c\u51fa\u961f\u7684\u8fc7\u7a0b\u4e2d\uff0cfront \u548c rear \u90fd\u5728\u5411\u53f3\u79fb\u52a8\uff0c\u5f53\u5b83\u4eec\u5230\u8fbe\u6570\u7ec4\u5c3e\u90e8\u65f6\u5c31\u65e0\u6cd5\u7ee7\u7eed\u79fb\u52a8\u4e86\u3002\u4e3a\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u7ec4\u89c6\u4e3a\u9996\u5c3e\u76f8\u63a5\u7684\u300c\u73af\u5f62\u6570\u7ec4\u300d\u3002

    \u5bf9\u4e8e\u73af\u5f62\u6570\u7ec4\uff0c\u6211\u4eec\u9700\u8981\u8ba9 front \u6216 rear \u5728\u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u76f4\u63a5\u56de\u5230\u6570\u7ec4\u5934\u90e8\u7ee7\u7eed\u904d\u5386\u3002\u8fd9\u79cd\u5468\u671f\u6027\u89c4\u5f8b\u53ef\u4ee5\u901a\u8fc7\u201c\u53d6\u4f59\u64cd\u4f5c\u201d\u6765\u5b9e\u73b0\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array_queue.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nprivate int[] nums; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate int queSize; // \u961f\u5217\u957f\u5ea6\npublic ArrayQueue(int capacity) {\nnums = new int[capacity];\nfront = queSize = 0;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\npublic int capacity() {\nreturn nums.length;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn queSize == 0;\n}\n/* \u5165\u961f */\npublic void push(int num) {\nif (queSize == capacity()) {\nSystem.out.println(\"\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nint rear = (front + queSize) % capacity();\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u51fa\u961f */\npublic int pop() {\nint num = peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nfront = (front + 1) % capacity();\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peek() {\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\nreturn nums[front];\n}\n/* \u8fd4\u56de\u6570\u7ec4 */\npublic int[] toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] res = new int[queSize];\nfor (int i = 0, j = front; i < queSize; i++, j++) {\nres[i] = nums[j % capacity()];\n}\nreturn res;\n}\n}\n
    array_queue.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nprivate:\nint *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nint front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nint queSize;     // \u961f\u5217\u957f\u5ea6\nint queCapacity; // \u961f\u5217\u5bb9\u91cf\npublic:\nArrayQueue(int capacity) {\n// \u521d\u59cb\u5316\u6570\u7ec4\nnums = new int[capacity];\nqueCapacity = capacity;\nfront = queSize = 0;\n}\n~ArrayQueue() {\ndelete[] nums;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity() {\nreturn queCapacity;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty() {\nreturn size() == 0;\n}\n/* \u5165\u961f */\nvoid push(int num) {\nif (queSize == queCapacity) {\ncout << \"\u961f\u5217\u5df2\u6ee1\" << endl;\nreturn;\n}\n// \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nint rear = (front + queSize) % queCapacity;\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u51fa\u961f */\nvoid pop() {\nint num = peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nfront = (front + 1) % queCapacity;\nqueSize--;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek() {\nif (empty())\nthrow out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\nreturn nums[front];\n}\n/* \u5c06\u6570\u7ec4\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\nvector<int> toVector() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvector<int> arr(queSize);\nfor (int i = 0, j = front; i < queSize; i++, j++) {\narr[i] = nums[j % queCapacity];\n}\nreturn arr;\n}\n};\n
    array_queue.py
    class ArrayQueue:\n\"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\ndef __init__(self, size: int) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__nums: list[int] = [0] * size  # \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nself.__front: int = 0  # \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nself.__size: int = 0  # \u961f\u5217\u957f\u5ea6\ndef capacity(self) -> int:\n\"\"\"\u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\nreturn len(self.__nums)\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\nreturn self.__size\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn self.__size == 0\ndef push(self, num: int) -> None:\n\"\"\"\u5165\u961f\"\"\"\nif self.__size == self.capacity():\nraise IndexError(\"\u961f\u5217\u5df2\u6ee1\")\n# \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n# \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8F\nrear: int = (self.__front + self.__size) % self.capacity()\n# \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nself.__nums[rear] = num\nself.__size += 1\ndef pop(self) -> int:\n\"\"\"\u51fa\u961f\"\"\"\nnum: int = self.peek()\n# \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nself.__front = (self.__front + 1) % self.capacity()\nself.__size -= 1\nreturn num\ndef peek(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\nif self.is_empty():\nraise IndexError(\"\u961f\u5217\u4e3a\u7a7a\")\nreturn self.__nums[self.__front]\ndef to_list(self) -> list[int]:\n\"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\nres = [0] * self.size()\nj: int = self.__front\nfor i in range(self.size()):\nres[i] = self.__nums[(j % self.capacity())]\nj += 1\nreturn res\n
    array_queue.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\ntype arrayQueue struct {\nnums        []int // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nfront       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nqueSize     int   // \u961f\u5217\u957f\u5ea6\nqueCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\nreturn &arrayQueue{\nnums:        make([]int, queCapacity),\nqueCapacity: queCapacity,\nfront:       0,\nqueSize:     0,\n}\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayQueue) size() int {\nreturn q.queSize\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayQueue) isEmpty() bool {\nreturn q.queSize == 0\n}\n/* \u5165\u961f */\nfunc (q *arrayQueue) push(num int) {\n// \u5f53 rear == queCapacity \u8868\u793a\u961f\u5217\u5df2\u6ee1\nif q.queSize == q.queCapacity {\nreturn\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nrear := (q.front + q.queSize) % q.queCapacity\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nq.nums[rear] = num\nq.queSize++\n}\n/* \u51fa\u961f */\nfunc (q *arrayQueue) pop() any {\nnum := q.peek()\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nq.front = (q.front + 1) % q.queCapacity\nq.queSize--\nreturn num\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayQueue) peek() any {\nif q.isEmpty() {\nreturn nil\n}\nreturn q.nums[q.front]\n}\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (q *arrayQueue) toSlice() []int {\nrear := (q.front + q.queSize)\nif rear >= q.queCapacity {\nrear %= q.queCapacity\nreturn append(q.nums[q.front:], q.nums[:rear]...)\n}\nreturn q.nums[q.front:rear]\n}\n
    array_queue.js
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n#nums; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n#front = 0; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n#queSize = 0; // \u961f\u5217\u957f\u5ea6\nconstructor(capacity) {\nthis.#nums = new Array(capacity);\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nget capacity() {\nreturn this.#nums.length;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nget size() {\nreturn this.#queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nempty() {\nreturn this.#queSize == 0;\n}\n/* \u5165\u961f */\npush(num) {\nif (this.size == this.capacity) {\nconsole.log('\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nconst rear = (this.#front + this.size) % this.capacity;\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nthis.#nums[rear] = num;\nthis.#queSize++;\n}\n/* \u51fa\u961f */\npop() {\nconst num = this.peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nthis.#front = (this.#front + 1) % this.capacity;\nthis.#queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek() {\nif (this.empty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\nreturn this.#nums[this.#front];\n}\n/* \u8fd4\u56de Array */\ntoArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst arr = new Array(this.size);\nfor (let i = 0, j = this.#front; i < this.size; i++, j++) {\narr[i] = this.#nums[j % this.capacity];\n}\nreturn arr;\n}\n}\n
    array_queue.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nprivate nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate queSize: number; // \u961f\u5217\u957f\u5ea6\nconstructor(capacity: number) {\nthis.nums = new Array(capacity);\nthis.front = this.queSize = 0;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nget capacity(): number {\nreturn this.nums.length;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nget size(): number {\nreturn this.queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nempty(): boolean {\nreturn this.queSize == 0;\n}\n/* \u5165\u961f */\npush(num: number): void {\nif (this.size == this.capacity) {\nconsole.log('\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nconst rear = (this.front + this.queSize) % this.capacity;\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nthis.nums[rear] = num;\nthis.queSize++;\n}\n/* \u51fa\u961f */\npop(): number {\nconst num = this.peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nthis.front = (this.front + 1) % this.capacity;\nthis.queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek(): number {\nif (this.empty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\nreturn this.nums[this.front];\n}\n/* \u8fd4\u56de Array */\ntoArray(): number[] {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst arr = new Array(this.size);\nfor (let i = 0, j = this.front; i < this.size; i++, j++) {\narr[i] = this.nums[j % this.capacity];\n}\nreturn arr;\n}\n}\n
    array_queue.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nstruct arrayQueue {\nint *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nint front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nint queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\nint queCapacity; // \u961f\u5217\u5bb9\u91cf\n};\ntypedef struct arrayQueue arrayQueue;\n/* \u6784\u9020\u51fd\u6570 */\narrayQueue *newArrayQueue(int capacity) {\narrayQueue *queue = (arrayQueue *)malloc(sizeof(arrayQueue));\n// \u521d\u59cb\u5316\u6570\u7ec4\nqueue->queCapacity = capacity;\nqueue->nums = (int *)malloc(sizeof(int) * queue->queCapacity);\nqueue->front = queue->queSize = 0;\nreturn queue;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayQueue(arrayQueue *queue) {\nfree(queue->nums);\nqueue->queCapacity = 0;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(arrayQueue *queue) {\nreturn queue->queCapacity;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(arrayQueue *queue) {\nreturn queue->queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(arrayQueue *queue) {\nreturn queue->queSize == 0;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(arrayQueue *queue) {\nassert(size(queue) != 0);\nreturn queue->nums[queue->front];\n}\n/* \u5165\u961f */\nvoid push(arrayQueue *queue, int num) {\nif (size(queue) == capacity(queue)) {\nprintf(\"\u961f\u5217\u5df2\u6ee1\\r\\n\");\nreturn;\n}\n// \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nint rear = (queue->front + queue->queSize) % queue->queCapacity;\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nqueue->nums[rear] = num;\nqueue->queSize++;\n}\n/* \u51fa\u961f */\nvoid pop(arrayQueue *queue) {\nint num = peek(queue);\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nqueue->front = (queue->front + 1) % queue->queCapacity;\nqueue->queSize--;\n}\n/* \u6253\u5370\u961f\u5217 */\nvoid printArrayQueue(arrayQueue *queue) {\nint arr[queue->queSize];\n// \u62f7\u8d1d\nfor (int i = 0, j = queue->front; i < queue->queSize; i++, j++) {\narr[i] = queue->nums[j % queue->queCapacity];\n}\nprintArray(arr, queue->queSize);\n}\n
    array_queue.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nprivate int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate int queSize; // \u961f\u5217\u957f\u5ea6\npublic ArrayQueue(int capacity) {\nnums = new int[capacity];\nfront = queSize = 0;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\npublic int capacity() {\nreturn nums.Length;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn queSize == 0;\n}\n/* \u5165\u961f */\npublic void push(int num) {\nif (queSize == capacity()) {\nConsole.WriteLine(\"\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nint rear = (front + queSize) % capacity();\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u51fa\u961f */\npublic int pop() {\nint num = peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nfront = (front + 1) % capacity();\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peek() {\nif (isEmpty())\nthrow new Exception();\nreturn nums[front];\n}\n/* \u8fd4\u56de\u6570\u7ec4 */\npublic int[] toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] res = new int[queSize];\nfor (int i = 0, j = front; i < queSize; i++, j++) {\nres[i] = nums[j % this.capacity()];\n}\nreturn res;\n}\n}\n
    array_queue.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nprivate var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate var front = 0 // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate var queSize = 0 // \u961f\u5217\u957f\u5ea6\ninit(capacity: Int) {\n// \u521d\u59cb\u5316\u6570\u7ec4\nnums = Array(repeating: 0, count: capacity)\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nfunc capacity() -> Int {\nnums.count\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc size() -> Int {\nqueSize\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nqueSize == 0\n}\n/* \u5165\u961f */\nfunc push(num: Int) {\nif size() == capacity() {\nprint(\"\u961f\u5217\u5df2\u6ee1\")\nreturn\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nlet rear = (front + queSize) % capacity()\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num\nqueSize += 1\n}\n/* \u51fa\u961f */\n@discardableResult\nfunc pop() -> Int {\nlet num = peek()\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nfront = (front + 1) % capacity()\nqueSize -= 1\nreturn num\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc peek() -> Int {\nif isEmpty() {\nfatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n}\nreturn nums[front]\n}\n/* \u8fd4\u56de\u6570\u7ec4 */\nfunc toArray() -> [Int] {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvar res = Array(repeating: 0, count: queSize)\nfor (i, j) in sequence(first: (0, front), next: { $0 < self.queSize - 1 ? ($0 + 1, $1 + 1) : nil }) {\nres[i] = nums[j % capacity()]\n}\nreturn res\n}\n}\n
    array_queue.zig
    // \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\nfn ArrayQueue(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nnums: []T = undefined,                          // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4     \ncap: usize = 0,                                 // \u961f\u5217\u5bb9\u91cf\nfront: usize = 0,                               // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nqueSize: usize = 0,                             // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\nmem_arena: ?std.heap.ArenaAllocator = null,\nmem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n// \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6570\u7ec4\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator, cap: usize) !void {\nif (self.mem_arena == null) {\nself.mem_arena = std.heap.ArenaAllocator.init(allocator);\nself.mem_allocator = self.mem_arena.?.allocator();\n}\nself.cap = cap;\nself.nums = try self.mem_allocator.alloc(T, self.cap);\n@memset(self.nums, @as(T, 0));\n}\n// \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.mem_arena == null) return;\nself.mem_arena.?.deinit();\n}\n// \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\npub fn capacity(self: *Self) usize {\nreturn self.cap;\n}\n// \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\npub fn size(self: *Self) usize {\nreturn self.queSize;\n}\n// \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\npub fn isEmpty(self: *Self) bool {\nreturn self.queSize == 0;\n}\n// \u5165\u961f\npub fn push(self: *Self, num: T) !void {\nif (self.size() == self.capacity()) {\nstd.debug.print(\"\u961f\u5217\u5df2\u6ee1\\n\", .{});\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nvar rear = (self.front + self.queSize) % self.capacity();\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nself.nums[rear] = num;\nself.queSize += 1;\n} // \u51fa\u961f\npub fn pop(self: *Self) T {\nvar num = self.peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nself.front = (self.front + 1) % self.capacity();\nself.queSize -= 1;\nreturn num;\n} // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\npub fn peek(self: *Self) T {\nif (self.isEmpty()) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\nreturn self.nums[self.front];\n} // \u8fd4\u56de\u6570\u7ec4\npub fn toArray(self: *Self) ![]T {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvar res = try self.mem_allocator.alloc(T, self.size());\n@memset(res, @as(T, 0));\nvar i: usize = 0;\nvar j: usize = self.front;\nwhile (i < self.size()) : ({ i += 1; j += 1; }) {\nres[i] = self.nums[j % self.capacity()];\n}\nreturn res;\n}\n};\n}\n
    array_queue.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nlate List<int> _nums; // \u7528\u4e8e\u50a8\u5b58\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nlate int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nlate int _queSize; // \u961f\u5217\u957f\u5ea6\nArrayQueue(int capacity) {\n_nums = List.filled(capacity, 0);\n_front = _queSize = 0;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nint capaCity() {\nreturn _nums.length;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn _queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn _queSize == 0;\n}\n/* \u5165\u961f */\nvoid push(int num) {\nif (_queSize == capaCity()) {\nthrow Exception(\"\u961f\u5217\u5df2\u6ee1\");\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nint rear = (_front + _queSize) % capaCity();\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n_nums[rear] = num;\n_queSize++;\n}\n/* \u51fa\u961f */\nint pop() {\nint num = peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n_front = (_front + 1) % capaCity();\n_queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek() {\nif (isEmpty()) {\nthrow Exception(\"\u961f\u5217\u4e3a\u7a7a\");\n}\nreturn _nums[_front];\n}\n/* \u8fd4\u56de Array */\nList<int> toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nfinal List<int> res = List.filled(_queSize, 0);\nfor (int i = 0, j = _front; i < _queSize; i++, j++) {\nres[i] = _nums[j % capaCity()];\n}\nreturn res;\n}\n}\n

    \u4ee5\u4e0a\u5b9e\u73b0\u7684\u961f\u5217\u4ecd\u7136\u5177\u6709\u5c40\u9650\u6027\uff0c\u5373\u5176\u957f\u5ea6\u4e0d\u53ef\u53d8\u3002\u7136\u800c\uff0c\u8fd9\u4e2a\u95ee\u9898\u4e0d\u96be\u89e3\u51b3\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u7ec4\u66ff\u6362\u4e3a\u52a8\u6001\u6570\u7ec4\uff0c\u4ece\u800c\u5f15\u5165\u6269\u5bb9\u673a\u5236\u3002\u6709\u5174\u8da3\u7684\u540c\u5b66\u53ef\u4ee5\u5c1d\u8bd5\u81ea\u884c\u5b9e\u73b0\u3002

    \u4e24\u79cd\u5b9e\u73b0\u7684\u5bf9\u6bd4\u7ed3\u8bba\u4e0e\u6808\u4e00\u81f4\uff0c\u5728\u6b64\u4e0d\u518d\u8d58\u8ff0\u3002

    "},{"location":"chapter_stack_and_queue/queue/#523","title":"5.2.3. \u00a0 \u961f\u5217\u5178\u578b\u5e94\u7528","text":"
    • \u6dd8\u5b9d\u8ba2\u5355\u3002\u8d2d\u7269\u8005\u4e0b\u5355\u540e\uff0c\u8ba2\u5355\u5c06\u52a0\u5165\u961f\u5217\u4e2d\uff0c\u7cfb\u7edf\u968f\u540e\u4f1a\u6839\u636e\u987a\u5e8f\u4f9d\u6b21\u5904\u7406\u961f\u5217\u4e2d\u7684\u8ba2\u5355\u3002\u5728\u53cc\u5341\u4e00\u671f\u95f4\uff0c\u77ed\u65f6\u95f4\u5185\u4f1a\u4ea7\u751f\u6d77\u91cf\u8ba2\u5355\uff0c\u9ad8\u5e76\u53d1\u6210\u4e3a\u5de5\u7a0b\u5e08\u4eec\u9700\u8981\u91cd\u70b9\u653b\u514b\u7684\u95ee\u9898\u3002
    • \u5404\u7c7b\u5f85\u529e\u4e8b\u9879\u3002\u4efb\u4f55\u9700\u8981\u5b9e\u73b0\u201c\u5148\u6765\u540e\u5230\u201d\u529f\u80fd\u7684\u573a\u666f\uff0c\u4f8b\u5982\u6253\u5370\u673a\u7684\u4efb\u52a1\u961f\u5217\u3001\u9910\u5385\u7684\u51fa\u9910\u961f\u5217\u7b49\u3002\u961f\u5217\u5728\u8fd9\u4e9b\u573a\u666f\u4e2d\u53ef\u4ee5\u6709\u6548\u5730\u7ef4\u62a4\u5904\u7406\u987a\u5e8f\u3002
    "},{"location":"chapter_stack_and_queue/stack/","title":"5.1. \u00a0 \u6808","text":"

    \u300c\u6808 Stack\u300d\u662f\u4e00\u79cd\u9075\u5faa\u5148\u5165\u540e\u51fa\uff08First In, Last Out\uff09\u539f\u5219\u7684\u7ebf\u6027\u6570\u636e\u7ed3\u6784\u3002

    \u6211\u4eec\u53ef\u4ee5\u5c06\u6808\u7c7b\u6bd4\u4e3a\u684c\u9762\u4e0a\u7684\u4e00\u645e\u76d8\u5b50\uff0c\u5982\u679c\u9700\u8981\u62ff\u51fa\u5e95\u90e8\u7684\u76d8\u5b50\uff0c\u5219\u9700\u8981\u5148\u5c06\u4e0a\u9762\u7684\u76d8\u5b50\u4f9d\u6b21\u53d6\u51fa\u3002\u6211\u4eec\u5c06\u76d8\u5b50\u66ff\u6362\u4e3a\u5404\u79cd\u7c7b\u578b\u7684\u5143\u7d20\uff08\u5982\u6574\u6570\u3001\u5b57\u7b26\u3001\u5bf9\u8c61\u7b49\uff09\uff0c\u5c31\u5f97\u5230\u4e86\u6808\u6570\u636e\u7ed3\u6784\u3002

    \u5728\u6808\u4e2d\uff0c\u6211\u4eec\u628a\u5806\u53e0\u5143\u7d20\u7684\u9876\u90e8\u79f0\u4e3a\u300c\u6808\u9876\u300d\uff0c\u5e95\u90e8\u79f0\u4e3a\u300c\u6808\u5e95\u300d\u3002\u5c06\u628a\u5143\u7d20\u6dfb\u52a0\u5230\u6808\u9876\u7684\u64cd\u4f5c\u53eb\u505a\u300c\u5165\u6808\u300d\uff0c\u800c\u5220\u9664\u6808\u9876\u5143\u7d20\u7684\u64cd\u4f5c\u53eb\u505a\u300c\u51fa\u6808\u300d\u3002

    Fig. \u6808\u7684\u5148\u5165\u540e\u51fa\u89c4\u5219

    "},{"location":"chapter_stack_and_queue/stack/#511","title":"5.1.1. \u00a0 \u6808\u5e38\u7528\u64cd\u4f5c","text":"

    \u6808\u7684\u5e38\u7528\u64cd\u4f5c\u5982\u4e0b\u8868\u6240\u793a\uff0c\u5177\u4f53\u7684\u65b9\u6cd5\u540d\u9700\u8981\u6839\u636e\u6240\u4f7f\u7528\u7684\u7f16\u7a0b\u8bed\u8a00\u6765\u786e\u5b9a\u3002\u5728\u6b64\uff0c\u6211\u4eec\u4ee5\u5e38\u89c1\u7684 push() , pop() , peek() \u547d\u540d\u4e3a\u4f8b\u3002

    \u65b9\u6cd5 \u63cf\u8ff0 \u65f6\u95f4\u590d\u6742\u5ea6 push() \u5143\u7d20\u5165\u6808\uff08\u6dfb\u52a0\u81f3\u6808\u9876\uff09 \\(O(1)\\) pop() \u6808\u9876\u5143\u7d20\u51fa\u6808 \\(O(1)\\) peek() \u8bbf\u95ee\u6808\u9876\u5143\u7d20 \\(O(1)\\)

    \u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u5185\u7f6e\u7684\u6808\u7c7b\u3002\u7136\u800c\uff0c\u67d0\u4e9b\u8bed\u8a00\u53ef\u80fd\u6ca1\u6709\u4e13\u95e8\u63d0\u4f9b\u6808\u7c7b\uff0c\u8fd9\u65f6\u6211\u4eec\u53ef\u4ee5\u5c06\u8be5\u8bed\u8a00\u7684\u300c\u6570\u7ec4\u300d\u6216\u300c\u94fe\u8868\u300d\u89c6\u4f5c\u6808\u6765\u4f7f\u7528\uff0c\u5e76\u901a\u8fc7\u201c\u8111\u8865\u201d\u6765\u5ffd\u7565\u4e0e\u6808\u65e0\u5173\u7684\u64cd\u4f5c\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart stack.java
    /* \u521d\u59cb\u5316\u6808 */\nStack<Integer> stack = new Stack<>();\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.peek();\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.pop();\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.size();\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = stack.isEmpty();\n
    stack.cpp
    /* \u521d\u59cb\u5316\u6808 */\nstack<int> stack;\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint top = stack.top();\n/* \u5143\u7d20\u51fa\u6808 */\nstack.pop(); // \u65e0\u8fd4\u56de\u503c\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.size();\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool empty = stack.empty();\n
    stack.py
    # \u521d\u59cb\u5316\u6808\n# Python \u6ca1\u6709\u5185\u7f6e\u7684\u6808\u7c7b\uff0c\u53ef\u4ee5\u628a List \u5f53\u4f5c\u6808\u6765\u4f7f\u7528 \nstack: List[int] = []\n# \u5143\u7d20\u5165\u6808\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n# \u8bbf\u95ee\u6808\u9876\u5143\u7d20\npeek: int = stack[-1]\n# \u5143\u7d20\u51fa\u6808\npop: int = stack.pop()\n# \u83b7\u53d6\u6808\u7684\u957f\u5ea6\nsize: int = len(stack)\n# \u5224\u65ad\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(stack) == 0\n
    stack_test.go
    /* \u521d\u59cb\u5316\u6808 */\n// \u5728 Go \u4e2d\uff0c\u63a8\u8350\u5c06 Slice \u5f53\u4f5c\u6808\u6765\u4f7f\u7528\nvar stack []int\n/* \u5143\u7d20\u5165\u6808 */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npeek := stack[len(stack)-1]\n/* \u5143\u7d20\u51fa\u6808 */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nsize := len(stack)\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nisEmpty := len(stack) == 0\n
    stack.js
    /* \u521d\u59cb\u5316\u6808 */\n// Javascript \u6ca1\u6709\u5185\u7f6e\u7684\u6808\u7c7b\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u6808\u6765\u4f7f\u7528 \nconst stack = [];\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nconst peek = stack[stack.length-1];\n/* \u5143\u7d20\u51fa\u6808 */\nconst pop = stack.pop();\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nconst size = stack.length;\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nconst is_empty = stack.length === 0;\n
    stack.ts
    /* \u521d\u59cb\u5316\u6808 */\n// Typescript \u6ca1\u6709\u5185\u7f6e\u7684\u6808\u7c7b\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u6808\u6765\u4f7f\u7528 \nconst stack: number[] = [];\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nconst peek = stack[stack.length - 1];\n/* \u5143\u7d20\u51fa\u6808 */\nconst pop = stack.pop();\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nconst size = stack.length;\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nconst is_empty = stack.length === 0;\n
    stack.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u6808\n
    stack.cs
    /* \u521d\u59cb\u5316\u6808 */\nStack<int> stack = new ();\n/* \u5143\u7d20\u5165\u6808 */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.Peek();\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.Pop();\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.Count();\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = stack.Count()==0;\n
    stack.swift
    /* \u521d\u59cb\u5316\u6808 */\n// Swift \u6ca1\u6709\u5185\u7f6e\u7684\u6808\u7c7b\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u6808\u6765\u4f7f\u7528\nvar stack: [Int] = []\n/* \u5143\u7d20\u5165\u6808 */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nlet peek = stack.last!\n/* \u5143\u7d20\u51fa\u6808 */\nlet pop = stack.removeLast()\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nlet size = stack.count\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = stack.isEmpty\n
    stack.zig
    \n
    stack.dart
    /* \u521d\u59cb\u5316\u6808 */\n// Dart \u6ca1\u6709\u5185\u7f6e\u7684\u6808\u7c7b\uff0c\u53ef\u4ee5\u628a List \u5f53\u4f5c\u6808\u6765\u4f7f\u7528\nList<int> stack = [];\n/* \u5143\u7d20\u5165\u6808 */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.last;\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.removeLast();\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.length;\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = stack.isEmpty;\n
    "},{"location":"chapter_stack_and_queue/stack/#512","title":"5.1.2. \u00a0 \u6808\u7684\u5b9e\u73b0","text":"

    \u4e3a\u4e86\u6df1\u5165\u4e86\u89e3\u6808\u7684\u8fd0\u884c\u673a\u5236\uff0c\u6211\u4eec\u6765\u5c1d\u8bd5\u81ea\u5df1\u5b9e\u73b0\u4e00\u4e2a\u6808\u7c7b\u3002

    \u6808\u9075\u5faa\u5148\u5165\u540e\u51fa\u7684\u539f\u5219\uff0c\u56e0\u6b64\u6211\u4eec\u53ea\u80fd\u5728\u6808\u9876\u6dfb\u52a0\u6216\u5220\u9664\u5143\u7d20\u3002\u7136\u800c\uff0c\u6570\u7ec4\u548c\u94fe\u8868\u90fd\u53ef\u4ee5\u5728\u4efb\u610f\u4f4d\u7f6e\u6dfb\u52a0\u548c\u5220\u9664\u5143\u7d20\uff0c\u56e0\u6b64\u6808\u53ef\u4ee5\u88ab\u89c6\u4e3a\u4e00\u79cd\u53d7\u9650\u5236\u7684\u6570\u7ec4\u6216\u94fe\u8868\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u6211\u4eec\u53ef\u4ee5\u201c\u5c4f\u853d\u201d\u6570\u7ec4\u6216\u94fe\u8868\u7684\u90e8\u5206\u65e0\u5173\u64cd\u4f5c\uff0c\u4f7f\u5176\u5bf9\u5916\u8868\u73b0\u7684\u903b\u8f91\u7b26\u5408\u6808\u7684\u7279\u6027\u3002

    "},{"location":"chapter_stack_and_queue/stack/#_1","title":"\u57fa\u4e8e\u94fe\u8868\u7684\u5b9e\u73b0","text":"

    \u4f7f\u7528\u94fe\u8868\u6765\u5b9e\u73b0\u6808\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u94fe\u8868\u7684\u5934\u8282\u70b9\u89c6\u4e3a\u6808\u9876\uff0c\u5c3e\u8282\u70b9\u89c6\u4e3a\u6808\u5e95\u3002

    \u5bf9\u4e8e\u5165\u6808\u64cd\u4f5c\uff0c\u6211\u4eec\u53ea\u9700\u5c06\u5143\u7d20\u63d2\u5165\u94fe\u8868\u5934\u90e8\uff0c\u8fd9\u79cd\u8282\u70b9\u63d2\u5165\u65b9\u6cd5\u88ab\u79f0\u4e3a\u201c\u5934\u63d2\u6cd5\u201d\u3002\u800c\u5bf9\u4e8e\u51fa\u6808\u64cd\u4f5c\uff0c\u53ea\u9700\u5c06\u5934\u8282\u70b9\u4ece\u94fe\u8868\u4e2d\u5220\u9664\u5373\u53ef\u3002

    LinkedListStackpush()pop()

    \u4ee5\u4e0b\u662f\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u6808\u7684\u793a\u4f8b\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linkedlist_stack.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nprivate ListNode stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nprivate int stkSize = 0; // \u6808\u7684\u957f\u5ea6\npublic LinkedListStack() {\nstackPeek = null;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\npublic int size() {\nreturn stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u6808 */\npublic void push(int num) {\nListNode node = new ListNode(num);\nnode.next = stackPeek;\nstackPeek = node;\nstkSize++;\n}\n/* \u51fa\u6808 */\npublic int pop() {\nint num = peek();\nstackPeek = stackPeek.next;\nstkSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npublic int peek() {\nif (size() == 0)\nthrow new IndexOutOfBoundsException();\nreturn stackPeek.val;\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic int[] toArray() {\nListNode node = stackPeek;\nint[] res = new int[size()];\nfor (int i = res.length - 1; i >= 0; i--) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_stack.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nprivate:\nListNode *stackTop; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nint stkSize;        // \u6808\u7684\u957f\u5ea6\npublic:\nLinkedListStack() {\nstackTop = nullptr;\nstkSize = 0;\n}\n~LinkedListStack() {\n// \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\nfreeMemoryLinkedList(stackTop);\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size() {\nreturn stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool empty() {\nreturn size() == 0;\n}\n/* \u5165\u6808 */\nvoid push(int num) {\nListNode *node = new ListNode(num);\nnode->next = stackTop;\nstackTop = node;\nstkSize++;\n}\n/* \u51fa\u6808 */\nvoid pop() {\nint num = top();\nListNode *tmp = stackTop;\nstackTop = stackTop->next;\n// \u91ca\u653e\u5185\u5b58\ndelete tmp;\nstkSize--;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint top() {\nif (size() == 0)\nthrow out_of_range(\"\u6808\u4e3a\u7a7a\");\nreturn stackTop->val;\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nvector<int> toVector() {\nListNode *node = stackTop;\nvector<int> res(size());\nfor (int i = res.size() - 1; i >= 0; i--) {\nres[i] = node->val;\nnode = node->next;\n}\nreturn res;\n}\n};\n
    linkedlist_stack.py
    class LinkedListStack:\n\"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__peek: ListNode | None = None\nself.__size: int = 0\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\nreturn self.__size\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn not self.__peek\ndef push(self, val: int) -> None:\n\"\"\"\u5165\u6808\"\"\"\nnode = ListNode(val)\nnode.next = self.__peek\nself.__peek = node\nself.__size += 1\ndef pop(self) -> int:\n\"\"\"\u51fa\u6808\"\"\"\nnum: int = self.peek()\nself.__peek = self.__peek.next\nself.__size -= 1\nreturn num\ndef peek(self) -> int:\n\"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\n# \u5224\u7a7a\u5904\u7406\nif not self.__peek:\nreturn None\nreturn self.__peek.val\ndef to_list(self) -> list[int]:\n\"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\narr = []\nnode = self.__peek\nwhile node:\narr.append(node.val)\nnode = node.next\narr.reverse()\nreturn arr\n
    linkedlist_stack.go
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\ntype linkedListStack struct {\n// \u4f7f\u7528\u5185\u7f6e\u5305 list \u6765\u5b9e\u73b0\u6808\ndata *list.List\n}\n/* \u521d\u59cb\u5316\u6808 */\nfunc newLinkedListStack() *linkedListStack {\nreturn &linkedListStack{\ndata: list.New(),\n}\n}\n/* \u5165\u6808 */\nfunc (s *linkedListStack) push(value int) {\ns.data.PushBack(value)\n}\n/* \u51fa\u6808 */\nfunc (s *linkedListStack) pop() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Back()\ns.data.Remove(e)\nreturn e.Value\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nfunc (s *linkedListStack) peek() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Back()\nreturn e.Value\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nfunc (s *linkedListStack) size() int {\nreturn s.data.Len()\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListStack) isEmpty() bool {\nreturn s.data.Len() == 0\n}\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListStack) toList() *list.List {\nreturn s.data\n}\n
    linkedlist_stack.js
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n#stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n#stkSize = 0; // \u6808\u7684\u957f\u5ea6\nconstructor() {\nthis.#stackPeek = null;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nget size() {\nreturn this.#stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nisEmpty() {\nreturn this.size == 0;\n}\n/* \u5165\u6808 */\npush(num) {\nconst node = new ListNode(num);\nnode.next = this.#stackPeek;\nthis.#stackPeek = node;\nthis.#stkSize++;\n}\n/* \u51fa\u6808 */\npop() {\nconst num = this.peek();\nthis.#stackPeek = this.#stackPeek.next;\nthis.#stkSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npeek() {\nif (!this.#stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.#stackPeek.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\ntoArray() {\nlet node = this.#stackPeek;\nconst res = new Array(this.size);\nfor (let i = res.length - 1; i >= 0; i--) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_stack.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nprivate stackPeek: ListNode | null; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nprivate stkSize: number = 0; // \u6808\u7684\u957f\u5ea6\nconstructor() {\nthis.stackPeek = null;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nget size(): number {\nreturn this.stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nisEmpty(): boolean {\nreturn this.size == 0;\n}\n/* \u5165\u6808 */\npush(num: number): void {\nconst node = new ListNode(num);\nnode.next = this.stackPeek;\nthis.stackPeek = node;\nthis.stkSize++;\n}\n/* \u51fa\u6808 */\npop(): number {\nconst num = this.peek();\nif (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\nthis.stackPeek = this.stackPeek.next;\nthis.stkSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npeek(): number {\nif (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.stackPeek.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\ntoArray(): number[] {\nlet node = this.stackPeek;\nconst res = new Array<number>(this.size);\nfor (let i = res.length - 1; i >= 0; i--) {\nres[i] = node!.val;\nnode = node!.next;\n}\nreturn res;\n}\n}\n
    linkedlist_stack.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nstruct linkedListStack {\nListNode *top; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nint size;      // \u6808\u7684\u957f\u5ea6\n};\ntypedef struct linkedListStack linkedListStack;\n/* \u6784\u9020\u51fd\u6570 */\nlinkedListStack *newLinkedListStack() {\nlinkedListStack *s = malloc(sizeof(linkedListStack));\ns->top = NULL;\ns->size = 0;\nreturn s;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListStack(linkedListStack *s) {\nwhile (s->top) {\nListNode *n = s->top->next;\nfree(s->top);\ns->top = n;\n}\nfree(s);\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(linkedListStack *s) {\nassert(s);\nreturn s->size;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(linkedListStack *s) {\nassert(s);\nreturn size(s) == 0;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(linkedListStack *s) {\nassert(s);\nassert(size(s) != 0);\nreturn s->top->val;\n}\n/* \u5165\u6808 */\nvoid push(linkedListStack *s, int num) {\nassert(s);\nListNode *node = (ListNode *)malloc(sizeof(ListNode));\nnode->next = s->top; // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6307\u9488\u57df\nnode->val = num;     // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6570\u636e\u57df\ns->top = node;       // \u66f4\u65b0\u6808\u9876\ns->size++;           // \u66f4\u65b0\u6808\u5927\u5c0f\n}\n/* \u51fa\u6808 */\nint pop(linkedListStack *s) {\nif (s->size == 0) {\nprintf(\"stack is empty.\\n\");\nreturn INT_MAX;\n}\nassert(s);\nint val = peek(s);\nListNode *tmp = s->top;\ns->top = s->top->next;\n// \u91ca\u653e\u5185\u5b58\nfree(tmp);\ns->size--;\nreturn val;\n}\n
    linkedlist_stack.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nprivate ListNode? stackPeek;  // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nprivate int stkSize = 0;   // \u6808\u7684\u957f\u5ea6\npublic LinkedListStack() {\nstackPeek = null;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\npublic int size() {\nreturn stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u6808 */\npublic void push(int num) {\nListNode node = new ListNode(num);\nnode.next = stackPeek;\nstackPeek = node;\nstkSize++;\n}\n/* \u51fa\u6808 */\npublic int pop() {\nif (stackPeek == null)\nthrow new Exception();\nint num = peek();\nstackPeek = stackPeek.next;\nstkSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npublic int peek() {\nif (size() == 0 || stackPeek == null)\nthrow new Exception();\nreturn stackPeek.val;\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic int[] toArray() {\nif (stackPeek == null)\nreturn Array.Empty<int>();\nListNode node = stackPeek;\nint[] res = new int[size()];\nfor (int i = res.Length - 1; i >= 0; i--) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_stack.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nprivate var _peek: ListNode? // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nprivate var _size = 0 // \u6808\u7684\u957f\u5ea6\ninit() {}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nfunc size() -> Int {\n_size\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nsize() == 0\n}\n/* \u5165\u6808 */\nfunc push(num: Int) {\nlet node = ListNode(x: num)\nnode.next = _peek\n_peek = node\n_size += 1\n}\n/* \u51fa\u6808 */\n@discardableResult\nfunc pop() -> Int {\nlet num = peek()\n_peek = _peek?.next\n_size -= 1\nreturn num\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nfunc peek() -> Int {\nif isEmpty() {\nfatalError(\"\u6808\u4e3a\u7a7a\")\n}\nreturn _peek!.val\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nfunc toArray() -> [Int] {\nvar node = _peek\nvar res = Array(repeating: 0, count: _size)\nfor i in sequence(first: res.count - 1, next: { $0 >= 0 + 1 ? $0 - 1 : nil }) {\nres[i] = node!.val\nnode = node?.next\n}\nreturn res\n}\n}\n
    linkedlist_stack.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\nfn LinkedListStack(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nstack_top: ?*inc.ListNode(T) = null,             // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nstk_size: usize = 0,                             // \u6808\u7684\u957f\u5ea6\nmem_arena: ?std.heap.ArenaAllocator = null,\nmem_allocator: std.mem.Allocator = undefined,    // \u5185\u5b58\u5206\u914d\u5668\n// \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator) !void {\nif (self.mem_arena == null) {\nself.mem_arena = std.heap.ArenaAllocator.init(allocator);\nself.mem_allocator = self.mem_arena.?.allocator();\n}\nself.stack_top = null;\nself.stk_size = 0;\n}\n// \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.mem_arena == null) return;\nself.mem_arena.?.deinit();\n}\n// \u83b7\u53d6\u6808\u7684\u957f\u5ea6\npub fn size(self: *Self) usize {\nreturn self.stk_size;\n}\n// \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\npub fn isEmpty(self: *Self) bool {\nreturn self.size() == 0;\n}\n// \u8bbf\u95ee\u6808\u9876\u5143\u7d20\npub fn peek(self: *Self) T {\nif (self.size() == 0) @panic(\"\u6808\u4e3a\u7a7a\");\nreturn self.stack_top.?.val;\n}  // \u5165\u6808\npub fn push(self: *Self, num: T) !void {\nvar node = try self.mem_allocator.create(inc.ListNode(T));\nnode.init(num);\nnode.next = self.stack_top;\nself.stack_top = node;\nself.stk_size += 1;\n} // \u51fa\u6808\npub fn pop(self: *Self) T {\nvar num = self.peek();\nself.stack_top = self.stack_top.?.next;\nself.stk_size -= 1;\nreturn num;\n} // \u5c06\u6808\u8f6c\u6362\u4e3a\u6570\u7ec4\npub fn toArray(self: *Self) ![]T {\nvar node = self.stack_top;\nvar res = try self.mem_allocator.alloc(T, self.size());\n@memset(res, @as(T, 0));\nvar i: usize = 0;\nwhile (i < res.len) : (i += 1) {\nres[res.len - i - 1] = node.?.val;\nnode = node.?.next;\n}\nreturn res;\n}\n};\n}\n
    linkedlist_stack.dart
    /* \u57fa\u4e8e\u94fe\u8868\u7c7b\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nListNode? _stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nint _stkSize = 0; // \u6808\u7684\u957f\u5ea6\nLinkedListStack() {\n_stackPeek = null;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size() {\nreturn _stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn _stkSize == 0;\n}\n/* \u5165\u6808 */\nvoid push(int num) {\nfinal ListNode node = ListNode(num);\nnode.next = _stackPeek;\n_stackPeek = node;\n_stkSize++;\n}\n/* \u51fa\u6808 */\nint pop() {\nfinal int num = peek();\n_stackPeek = _stackPeek!.next;\n_stkSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek() {\nif (_stackPeek == null) {\nthrow Exception(\"\u6808\u4e3a\u7a7a\");\n}\nreturn _stackPeek!.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a List \u5e76\u8fd4\u56de */\nList<int> toList() {\nListNode? node = _stackPeek;\nList<int> list = [];\nwhile (node != null) {\nlist.add(node.val);\nnode = node.next;\n}\nlist = list.reversed.toList();\nreturn list;\n}\n}\n
    "},{"location":"chapter_stack_and_queue/stack/#_2","title":"\u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u5728\u57fa\u4e8e\u300c\u6570\u7ec4\u300d\u5b9e\u73b0\u6808\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u7ec4\u7684\u5c3e\u90e8\u4f5c\u4e3a\u6808\u9876\u3002\u5728\u8fd9\u6837\u7684\u8bbe\u8ba1\u4e0b\uff0c\u5165\u6808\u4e0e\u51fa\u6808\u64cd\u4f5c\u5c31\u5206\u522b\u5bf9\u5e94\u5728\u6570\u7ec4\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\u4e0e\u5220\u9664\u5143\u7d20\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(1)\\) \u3002

    ArrayStackpush()pop()

    \u7531\u4e8e\u5165\u6808\u7684\u5143\u7d20\u53ef\u80fd\u4f1a\u6e90\u6e90\u4e0d\u65ad\u5730\u589e\u52a0\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u52a8\u6001\u6570\u7ec4\uff0c\u8fd9\u6837\u5c31\u65e0\u9700\u81ea\u884c\u5904\u7406\u6570\u7ec4\u6269\u5bb9\u95ee\u9898\u3002\u4ee5\u4e0b\u4e3a\u793a\u4f8b\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array_stack.java
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nprivate ArrayList<Integer> stack;\npublic ArrayStack() {\n// \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\nstack = new ArrayList<>();\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\npublic int size() {\nreturn stack.size();\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u6808 */\npublic void push(int num) {\nstack.add(num);\n}\n/* \u51fa\u6808 */\npublic int pop() {\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\nreturn stack.remove(size() - 1);\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npublic int peek() {\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\nreturn stack.get(size() - 1);\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic Object[] toArray() {\nreturn stack.toArray();\n}\n}\n
    array_stack.cpp
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nprivate:\nvector<int> stack;\npublic:\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size() {\nreturn stack.size();\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool empty() {\nreturn stack.empty();\n}\n/* \u5165\u6808 */\nvoid push(int num) {\nstack.push_back(num);\n}\n/* \u51fa\u6808 */\nvoid pop() {\nint oldTop = top();\nstack.pop_back();\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint top() {\nif (empty())\nthrow out_of_range(\"\u6808\u4e3a\u7a7a\");\nreturn stack.back();\n}\n/* \u8fd4\u56de Vector */\nvector<int> toVector() {\nreturn stack;\n}\n};\n
    array_stack.py
    class ArrayStack:\n\"\"\"\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\"\"\"\ndef __init__(self) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__stack: list[int] = []\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\nreturn len(self.__stack)\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn self.__stack == []\ndef push(self, item: int) -> None:\n\"\"\"\u5165\u6808\"\"\"\nself.__stack.append(item)\ndef pop(self) -> int:\n\"\"\"\u51fa\u6808\"\"\"\nif self.is_empty():\nraise IndexError(\"\u6808\u4e3a\u7a7a\")\nreturn self.__stack.pop()\ndef peek(self) -> int:\n\"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\nif self.is_empty():\nraise IndexError(\"\u6808\u4e3a\u7a7a\")\nreturn self.__stack[-1]\ndef to_list(self) -> list[int]:\n\"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\nreturn self.__stack\n
    array_stack.go
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\ntype arrayStack struct {\ndata []int // \u6570\u636e\n}\n/* \u521d\u59cb\u5316\u6808 */\nfunc newArrayStack() *arrayStack {\nreturn &arrayStack{\n// \u8bbe\u7f6e\u6808\u7684\u957f\u5ea6\u4e3a 0\uff0c\u5bb9\u91cf\u4e3a 16\ndata: make([]int, 0, 16),\n}\n}\n/* \u6808\u7684\u957f\u5ea6 */\nfunc (s *arrayStack) size() int {\nreturn len(s.data)\n}\n/* \u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *arrayStack) isEmpty() bool {\nreturn s.size() == 0\n}\n/* \u5165\u6808 */\nfunc (s *arrayStack) push(v int) {\n// \u5207\u7247\u4f1a\u81ea\u52a8\u6269\u5bb9\ns.data = append(s.data, v)\n}\n/* \u51fa\u6808 */\nfunc (s *arrayStack) pop() any {\nval := s.peek()\ns.data = s.data[:len(s.data)-1]\nreturn val\n}\n/* \u83b7\u53d6\u6808\u9876\u5143\u7d20 */\nfunc (s *arrayStack) peek() any {\nif s.isEmpty() {\nreturn nil\n}\nval := s.data[len(s.data)-1]\nreturn val\n}\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (s *arrayStack) toSlice() []int {\nreturn s.data\n}\n
    array_stack.js
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n#stack;\nconstructor() {\nthis.#stack = [];\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nget size() {\nreturn this.#stack.length;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nempty() {\nreturn this.#stack.length === 0;\n}\n/* \u5165\u6808 */\npush(num) {\nthis.#stack.push(num);\n}\n/* \u51fa\u6808 */\npop() {\nif (this.empty()) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.#stack.pop();\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\ntop() {\nif (this.empty()) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.#stack[this.#stack.length - 1];\n}\n/* \u8fd4\u56de Array */\ntoArray() {\nreturn this.#stack;\n}\n}\n
    array_stack.ts
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nprivate stack: number[];\nconstructor() {\nthis.stack = [];\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nget size(): number {\nreturn this.stack.length;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nempty(): boolean {\nreturn this.stack.length === 0;\n}\n/* \u5165\u6808 */\npush(num: number): void {\nthis.stack.push(num);\n}\n/* \u51fa\u6808 */\npop(): number | undefined {\nif (this.empty()) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.stack.pop();\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\ntop(): number | undefined {\nif (this.empty()) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.stack[this.stack.length - 1];\n}\n/* \u8fd4\u56de Array */\ntoArray() {\nreturn this.stack;\n}\n}\n
    array_stack.c
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nstruct arrayStack {\nint *data;\nint size;\n};\ntypedef struct arrayStack arrayStack;\n/* \u6784\u9020\u51fd\u6570 */\narrayStack *newArrayStack() {\narrayStack *s = malloc(sizeof(arrayStack));\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5927\u5bb9\u91cf\uff0c\u907f\u514d\u6269\u5bb9\ns->data = malloc(sizeof(int) * MAX_SIZE);\ns->size = 0;\nreturn s;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(arrayStack *s) {\nreturn s->size;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(arrayStack *s) {\nreturn s->size == 0;\n}\n/* \u5165\u6808 */\nvoid push(arrayStack *s, int num) {\nif (s->size == MAX_SIZE) {\nprintf(\"stack is full.\\n\");\nreturn;\n}\ns->data[s->size] = num;\ns->size++;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(arrayStack *s) {\nif (s->size == 0) {\nprintf(\"stack is empty.\\n\");\nreturn INT_MAX;\n}\nreturn s->data[s->size - 1];\n}\n/* \u51fa\u6808 */\nint pop(arrayStack *s) {\nif (s->size == 0) {\nprintf(\"stack is empty.\\n\");\nreturn INT_MAX;\n}\nint val = peek(s);\ns->size--;\nreturn val;\n}\n
    array_stack.cs
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nprivate List<int> stack;\npublic ArrayStack() {\n// \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\nstack = new();\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\npublic int size() {\nreturn stack.Count();\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u6808 */\npublic void push(int num) {\nstack.Add(num);\n}\n/* \u51fa\u6808 */\npublic int pop() {\nif (isEmpty())\nthrow new Exception();\nvar val = peek();\nstack.RemoveAt(size() - 1);\nreturn val;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npublic int peek() {\nif (isEmpty())\nthrow new Exception();\nreturn stack[size() - 1];\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic int[] toArray() {\nreturn stack.ToArray();\n}\n}\n
    array_stack.swift
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nprivate var stack: [Int]\ninit() {\n// \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\nstack = []\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nfunc size() -> Int {\nstack.count\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nstack.isEmpty\n}\n/* \u5165\u6808 */\nfunc push(num: Int) {\nstack.append(num)\n}\n/* \u51fa\u6808 */\n@discardableResult\nfunc pop() -> Int {\nif isEmpty() {\nfatalError(\"\u6808\u4e3a\u7a7a\")\n}\nreturn stack.removeLast()\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nfunc peek() -> Int {\nif isEmpty() {\nfatalError(\"\u6808\u4e3a\u7a7a\")\n}\nreturn stack.last!\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nfunc toArray() -> [Int] {\nstack\n}\n}\n
    array_stack.zig
    // \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\nfn ArrayStack(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nstack: ?std.ArrayList(T) = null,     // \u6784\u9020\u65b9\u6cd5\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator) void {\nif (self.stack == null) {\nself.stack = std.ArrayList(T).init(allocator);\n}\n}\n// \u6790\u6784\u65b9\u6cd5\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.stack == null) return;\nself.stack.?.deinit();\n}\n// \u83b7\u53d6\u6808\u7684\u957f\u5ea6\npub fn size(self: *Self) usize {\nreturn self.stack.?.items.len;\n}\n// \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\npub fn isEmpty(self: *Self) bool {\nreturn self.size() == 0;\n}\n// \u8bbf\u95ee\u6808\u9876\u5143\u7d20\npub fn peek(self: *Self) T {\nif (self.isEmpty()) @panic(\"\u6808\u4e3a\u7a7a\");\nreturn self.stack.?.items[self.size() - 1];\n}  // \u5165\u6808\npub fn push(self: *Self, num: T) !void {\ntry self.stack.?.append(num);\n} // \u51fa\u6808\npub fn pop(self: *Self) T {\nvar num = self.stack.?.pop();\nreturn num;\n} // \u8fd4\u56de ArrayList\npub fn toList(self: *Self) std.ArrayList(T) {\nreturn self.stack.?;\n}\n};\n}\n
    array_stack.dart
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nlate List<int> _stack;\nArrayStack() {\n_stack = [];\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size() {\nreturn _stack.length;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn _stack.isEmpty;\n}\n/* \u5165\u6808 */\nvoid push(int num) {\n_stack.add(num);\n}\n/* \u51fa\u6808 */\nint pop() {\nif (isEmpty()) {\nthrow Exception(\"\u6808\u4e3a\u7a7a\");\n}\nreturn _stack.removeLast();\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek() {\nif (isEmpty()) {\nthrow Exception(\"\u6808\u4e3a\u7a7a\");\n}\nreturn _stack.last;\n}\n/* \u5c06\u6808\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nList<int> toArray() => _stack;\n}\n
    "},{"location":"chapter_stack_and_queue/stack/#513","title":"5.1.3. \u00a0 \u4e24\u79cd\u5b9e\u73b0\u5bf9\u6bd4","text":""},{"location":"chapter_stack_and_queue/stack/#_3","title":"\u652f\u6301\u64cd\u4f5c","text":"

    \u4e24\u79cd\u5b9e\u73b0\u90fd\u652f\u6301\u6808\u5b9a\u4e49\u4e2d\u7684\u5404\u9879\u64cd\u4f5c\u3002\u6570\u7ec4\u5b9e\u73b0\u989d\u5916\u652f\u6301\u968f\u673a\u8bbf\u95ee\uff0c\u4f46\u8fd9\u5df2\u8d85\u51fa\u4e86\u6808\u7684\u5b9a\u4e49\u8303\u7574\uff0c\u56e0\u6b64\u4e00\u822c\u4e0d\u4f1a\u7528\u5230\u3002

    "},{"location":"chapter_stack_and_queue/stack/#_4","title":"\u65f6\u95f4\u6548\u7387","text":"

    \u5728\u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0\u4e2d\uff0c\u5165\u6808\u548c\u51fa\u6808\u64cd\u4f5c\u90fd\u662f\u5728\u9884\u5148\u5206\u914d\u597d\u7684\u8fde\u7eed\u5185\u5b58\u4e2d\u8fdb\u884c\uff0c\u5177\u6709\u5f88\u597d\u7684\u7f13\u5b58\u672c\u5730\u6027\uff0c\u56e0\u6b64\u6548\u7387\u8f83\u9ad8\u3002\u7136\u800c\uff0c\u5982\u679c\u5165\u6808\u65f6\u8d85\u51fa\u6570\u7ec4\u5bb9\u91cf\uff0c\u4f1a\u89e6\u53d1\u6269\u5bb9\u673a\u5236\uff0c\u5bfc\u81f4\u8be5\u6b21\u5165\u6808\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u53d8\u4e3a \\(O(n)\\) \u3002

    \u5728\u94fe\u8868\u5b9e\u73b0\u4e2d\uff0c\u94fe\u8868\u7684\u6269\u5bb9\u975e\u5e38\u7075\u6d3b\uff0c\u4e0d\u5b58\u5728\u4e0a\u8ff0\u6570\u7ec4\u6269\u5bb9\u65f6\u6548\u7387\u964d\u4f4e\u7684\u95ee\u9898\u3002\u4f46\u662f\uff0c\u5165\u6808\u64cd\u4f5c\u9700\u8981\u521d\u59cb\u5316\u8282\u70b9\u5bf9\u8c61\u5e76\u4fee\u6539\u6307\u9488\uff0c\u56e0\u6b64\u6548\u7387\u76f8\u5bf9\u8f83\u4f4e\u3002\u4e0d\u8fc7\uff0c\u5982\u679c\u5165\u6808\u5143\u7d20\u672c\u8eab\u5c31\u662f\u8282\u70b9\u5bf9\u8c61\uff0c\u90a3\u4e48\u53ef\u4ee5\u7701\u53bb\u521d\u59cb\u5316\u6b65\u9aa4\uff0c\u4ece\u800c\u63d0\u9ad8\u6548\u7387\u3002

    \u7efc\u4e0a\u6240\u8ff0\uff0c\u5f53\u5165\u6808\u4e0e\u51fa\u6808\u64cd\u4f5c\u7684\u5143\u7d20\u662f\u57fa\u672c\u6570\u636e\u7c7b\u578b\uff08\u5982 int , double \uff09\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u51fa\u4ee5\u4e0b\u7ed3\u8bba\uff1a

    • \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\u5728\u89e6\u53d1\u6269\u5bb9\u65f6\u6548\u7387\u4f1a\u964d\u4f4e\uff0c\u4f46\u7531\u4e8e\u6269\u5bb9\u662f\u4f4e\u9891\u64cd\u4f5c\uff0c\u56e0\u6b64\u5e73\u5747\u6548\u7387\u66f4\u9ad8\uff1b
    • \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\u53ef\u4ee5\u63d0\u4f9b\u66f4\u52a0\u7a33\u5b9a\u7684\u6548\u7387\u8868\u73b0\uff1b
    "},{"location":"chapter_stack_and_queue/stack/#_5","title":"\u7a7a\u95f4\u6548\u7387","text":"

    \u5728\u521d\u59cb\u5316\u5217\u8868\u65f6\uff0c\u7cfb\u7edf\u4f1a\u4e3a\u5217\u8868\u5206\u914d\u201c\u521d\u59cb\u5bb9\u91cf\u201d\uff0c\u8be5\u5bb9\u91cf\u53ef\u80fd\u8d85\u8fc7\u5b9e\u9645\u9700\u6c42\u3002\u5e76\u4e14\uff0c\u6269\u5bb9\u673a\u5236\u901a\u5e38\u662f\u6309\u7167\u7279\u5b9a\u500d\u7387\uff08\u4f8b\u5982 2 \u500d\uff09\u8fdb\u884c\u6269\u5bb9\uff0c\u6269\u5bb9\u540e\u7684\u5bb9\u91cf\u4e5f\u53ef\u80fd\u8d85\u51fa\u5b9e\u9645\u9700\u6c42\u3002\u56e0\u6b64\uff0c\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\u53ef\u80fd\u9020\u6210\u4e00\u5b9a\u7684\u7a7a\u95f4\u6d6a\u8d39\u3002

    \u7136\u800c\uff0c\u7531\u4e8e\u94fe\u8868\u8282\u70b9\u9700\u8981\u989d\u5916\u5b58\u50a8\u6307\u9488\uff0c\u56e0\u6b64\u94fe\u8868\u8282\u70b9\u5360\u7528\u7684\u7a7a\u95f4\u76f8\u5bf9\u8f83\u5927\u3002

    \u7efc\u4e0a\uff0c\u6211\u4eec\u4e0d\u80fd\u7b80\u5355\u5730\u786e\u5b9a\u54ea\u79cd\u5b9e\u73b0\u66f4\u52a0\u8282\u7701\u5185\u5b58\uff0c\u9700\u8981\u9488\u5bf9\u5177\u4f53\u60c5\u51b5\u8fdb\u884c\u5206\u6790\u3002

    "},{"location":"chapter_stack_and_queue/stack/#514","title":"5.1.4. \u00a0 \u6808\u5178\u578b\u5e94\u7528","text":"
    • \u6d4f\u89c8\u5668\u4e2d\u7684\u540e\u9000\u4e0e\u524d\u8fdb\u3001\u8f6f\u4ef6\u4e2d\u7684\u64a4\u9500\u4e0e\u53cd\u64a4\u9500\u3002\u6bcf\u5f53\u6211\u4eec\u6253\u5f00\u65b0\u7684\u7f51\u9875\uff0c\u6d4f\u89c8\u5668\u5c31\u4f1a\u5c06\u4e0a\u4e00\u4e2a\u7f51\u9875\u6267\u884c\u5165\u6808\uff0c\u8fd9\u6837\u6211\u4eec\u5c31\u53ef\u4ee5\u901a\u8fc7\u300c\u540e\u9000\u300d\u64cd\u4f5c\u56de\u5230\u4e0a\u4e00\u9875\u9762\u3002\u540e\u9000\u64cd\u4f5c\u5b9e\u9645\u4e0a\u662f\u5728\u6267\u884c\u51fa\u6808\u3002\u5982\u679c\u8981\u540c\u65f6\u652f\u6301\u540e\u9000\u548c\u524d\u8fdb\uff0c\u90a3\u4e48\u9700\u8981\u4e24\u4e2a\u6808\u6765\u914d\u5408\u5b9e\u73b0\u3002
    • \u7a0b\u5e8f\u5185\u5b58\u7ba1\u7406\u3002\u6bcf\u6b21\u8c03\u7528\u51fd\u6570\u65f6\uff0c\u7cfb\u7edf\u90fd\u4f1a\u5728\u6808\u9876\u6dfb\u52a0\u4e00\u4e2a\u6808\u5e27\uff0c\u7528\u4e8e\u8bb0\u5f55\u51fd\u6570\u7684\u4e0a\u4e0b\u6587\u4fe1\u606f\u3002\u5728\u9012\u5f52\u51fd\u6570\u4e2d\uff0c\u5411\u4e0b\u9012\u63a8\u9636\u6bb5\u4f1a\u4e0d\u65ad\u6267\u884c\u5165\u6808\u64cd\u4f5c\uff0c\u800c\u5411\u4e0a\u56de\u6eaf\u9636\u6bb5\u5219\u4f1a\u6267\u884c\u51fa\u6808\u64cd\u4f5c\u3002
    "},{"location":"chapter_stack_and_queue/summary/","title":"5.4. \u00a0 \u5c0f\u7ed3","text":"
    • \u6808\u662f\u4e00\u79cd\u9075\u5faa\u5148\u5165\u540e\u51fa\u539f\u5219\u7684\u6570\u636e\u7ed3\u6784\uff0c\u53ef\u901a\u8fc7\u6570\u7ec4\u6216\u94fe\u8868\u6765\u5b9e\u73b0\u3002
    • \u4ece\u65f6\u95f4\u6548\u7387\u89d2\u5ea6\u770b\uff0c\u6808\u7684\u6570\u7ec4\u5b9e\u73b0\u5177\u6709\u8f83\u9ad8\u7684\u5e73\u5747\u6548\u7387\uff0c\u4f46\u5728\u6269\u5bb9\u8fc7\u7a0b\u4e2d\uff0c\u5355\u6b21\u5165\u6808\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4f1a\u964d\u4f4e\u81f3 \\(O(n)\\) \u3002\u76f8\u6bd4\u4e4b\u4e0b\uff0c\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\u5177\u6709\u66f4\u4e3a\u7a33\u5b9a\u7684\u6548\u7387\u8868\u73b0\u3002
    • \u5728\u7a7a\u95f4\u6548\u7387\u65b9\u9762\uff0c\u6808\u7684\u6570\u7ec4\u5b9e\u73b0\u53ef\u80fd\u5bfc\u81f4\u4e00\u5b9a\u7a0b\u5ea6\u7684\u7a7a\u95f4\u6d6a\u8d39\u3002\u4f46\u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u94fe\u8868\u8282\u70b9\u6240\u5360\u7528\u7684\u5185\u5b58\u7a7a\u95f4\u6bd4\u6570\u7ec4\u5143\u7d20\u66f4\u5927\u3002
    • \u961f\u5217\u662f\u4e00\u79cd\u9075\u5faa\u5148\u5165\u5148\u51fa\u539f\u5219\u7684\u6570\u636e\u7ed3\u6784\uff0c\u540c\u6837\u53ef\u4ee5\u901a\u8fc7\u6570\u7ec4\u6216\u94fe\u8868\u6765\u5b9e\u73b0\u3002\u5728\u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u7684\u5bf9\u6bd4\u4e0a\uff0c\u961f\u5217\u7684\u7ed3\u8bba\u4e0e\u524d\u8ff0\u6808\u7684\u7ed3\u8bba\u76f8\u4f3c\u3002
    • \u53cc\u5411\u961f\u5217\u662f\u4e00\u79cd\u5177\u6709\u66f4\u9ad8\u81ea\u7531\u5ea6\u7684\u961f\u5217\uff0c\u5b83\u5141\u8bb8\u5728\u4e24\u7aef\u8fdb\u884c\u5143\u7d20\u7684\u6dfb\u52a0\u548c\u5220\u9664\u64cd\u4f5c\u3002
    "},{"location":"chapter_stack_and_queue/summary/#541-q-a","title":"5.4.1. \u00a0 Q & A","text":"

    \u6d4f\u89c8\u5668\u7684\u524d\u8fdb\u540e\u9000\u662f\u5426\u662f\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\uff1f

    \u6d4f\u89c8\u5668\u7684\u524d\u8fdb\u540e\u9000\u529f\u80fd\u672c\u8d28\u4e0a\u662f\u201c\u6808\u201d\u7684\u4f53\u73b0\u3002\u5f53\u7528\u6237\u8bbf\u95ee\u4e00\u4e2a\u65b0\u9875\u9762\u65f6\uff0c\u8be5\u9875\u9762\u4f1a\u88ab\u6dfb\u52a0\u5230\u6808\u9876\uff1b\u5f53\u7528\u6237\u70b9\u51fb\u540e\u9000\u6309\u94ae\u65f6\uff0c\u8be5\u9875\u9762\u4f1a\u4ece\u6808\u9876\u5f39\u51fa\u3002\u4f7f\u7528\u53cc\u5411\u961f\u5217\u53ef\u4ee5\u65b9\u4fbf\u5b9e\u73b0\u4e00\u4e9b\u989d\u5916\u64cd\u4f5c\uff0c\u8fd9\u4e2a\u5728\u53cc\u5411\u961f\u5217\u7ae0\u8282\u6709\u63d0\u5230\u3002

    \u5728\u51fa\u6808\u540e\uff0c\u662f\u5426\u9700\u8981\u91ca\u653e\u51fa\u6808\u8282\u70b9\u7684\u5185\u5b58\uff1f

    \u5982\u679c\u540e\u7eed\u4ecd\u9700\u8981\u4f7f\u7528\u5f39\u51fa\u8282\u70b9\uff0c\u5219\u4e0d\u9700\u8981\u91ca\u653e\u5185\u5b58\u3002\u82e5\u4e4b\u540e\u4e0d\u9700\u8981\u7528\u5230\uff0cJava \u548c Python \u7b49\u8bed\u8a00\u62e5\u6709\u81ea\u52a8\u5783\u573e\u56de\u6536\u673a\u5236\uff0c\u56e0\u6b64\u4e0d\u9700\u8981\u624b\u52a8\u91ca\u653e\u5185\u5b58\uff1b\u5728 C \u548c C++ \u4e2d\u9700\u8981\u624b\u52a8\u91ca\u653e\u5185\u5b58\u3002

    \u53cc\u5411\u961f\u5217\u50cf\u662f\u4e24\u4e2a\u6808\u62fc\u63a5\u5728\u4e86\u4e00\u8d77\uff0c\u5b83\u7684\u7528\u9014\u662f\u4ec0\u4e48\uff1f

    \u53cc\u5411\u961f\u5217\u5c31\u50cf\u662f\u6808\u548c\u961f\u5217\u7684\u7ec4\u5408\uff0c\u6216\u8005\u662f\u4e24\u4e2a\u6808\u62fc\u5728\u4e86\u4e00\u8d77\u3002\u5b83\u8868\u73b0\u7684\u662f\u6808 + \u961f\u5217\u7684\u903b\u8f91\uff0c\u56e0\u6b64\u53ef\u4ee5\u5b9e\u73b0\u6808\u4e0e\u961f\u5217\u7684\u6240\u6709\u5e94\u7528\uff0c\u5e76\u4e14\u66f4\u52a0\u7075\u6d3b\u3002

    "},{"location":"chapter_tree/","title":"7. \u00a0 \u6811","text":""},{"location":"chapter_tree/array_representation_of_tree/","title":"7.3. \u00a0 \u4e8c\u53c9\u6811\u6570\u7ec4\u8868\u793a","text":"

    \u5728\u94fe\u8868\u8868\u793a\u4e0b\uff0c\u4e8c\u53c9\u6811\u7684\u5b58\u50a8\u5355\u5143\u4e3a\u8282\u70b9 TreeNode \uff0c\u8282\u70b9\u4e4b\u95f4\u901a\u8fc7\u6307\u9488\u76f8\u8fde\u63a5\u3002\u5728\u4e0a\u8282\u4e2d\uff0c\u6211\u4eec\u5b66\u4e60\u4e86\u5728\u94fe\u8868\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7684\u5404\u9879\u57fa\u672c\u64cd\u4f5c\u3002

    \u90a3\u4e48\uff0c\u80fd\u5426\u7528\u300c\u6570\u7ec4\u300d\u6765\u8868\u793a\u4e8c\u53c9\u6811\u5462\uff1f\u7b54\u6848\u662f\u80af\u5b9a\u7684\u3002

    "},{"location":"chapter_tree/array_representation_of_tree/#731","title":"7.3.1. \u00a0 \u8868\u793a\u5b8c\u7f8e\u4e8c\u53c9\u6811","text":"

    \u5148\u5206\u6790\u4e00\u4e2a\u7b80\u5355\u6848\u4f8b\uff0c\u7ed9\u5b9a\u4e00\u4e2a\u5b8c\u7f8e\u4e8c\u53c9\u6811\uff0c\u6211\u4eec\u5c06\u8282\u70b9\u6309\u7167\u5c42\u5e8f\u904d\u5386\u7684\u987a\u5e8f\u7f16\u53f7\uff08\u4ece \\(0\\) \u5f00\u59cb\uff09\uff0c\u6b64\u65f6\u6bcf\u4e2a\u8282\u70b9\u90fd\u5bf9\u5e94\u552f\u4e00\u7684\u7d22\u5f15\u3002

    \u6839\u636e\u5c42\u5e8f\u904d\u5386\u7684\u7279\u6027\uff0c\u6211\u4eec\u53ef\u4ee5\u63a8\u5bfc\u51fa\u7236\u8282\u70b9\u7d22\u5f15\u4e0e\u5b50\u8282\u70b9\u7d22\u5f15\u4e4b\u95f4\u7684\u201c\u6620\u5c04\u516c\u5f0f\u201d\uff1a\u82e5\u8282\u70b9\u7684\u7d22\u5f15\u4e3a \\(i\\) \uff0c\u5219\u8be5\u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7d22\u5f15\u4e3a \\(2i + 1\\) \uff0c\u53f3\u5b50\u8282\u70b9\u7d22\u5f15\u4e3a \\(2i + 2\\) \u3002

    Fig. \u5b8c\u7f8e\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    \u6620\u5c04\u516c\u5f0f\u7684\u4f5c\u7528\u76f8\u5f53\u4e8e\u94fe\u8868\u4e2d\u7684\u6307\u9488\u3002\u5982\u679c\u6211\u4eec\u5c06\u8282\u70b9\u6309\u7167\u5c42\u5e8f\u904d\u5386\u7684\u987a\u5e8f\u5b58\u50a8\u5728\u4e00\u4e2a\u6570\u7ec4\u4e2d\uff0c\u90a3\u4e48\u5bf9\u4e8e\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u8282\u70b9\uff0c\u6211\u4eec\u90fd\u53ef\u4ee5\u901a\u8fc7\u6620\u5c04\u516c\u5f0f\u6765\u8bbf\u95ee\u5176\u5b50\u8282\u70b9\u3002

    "},{"location":"chapter_tree/array_representation_of_tree/#732","title":"7.3.2. \u00a0 \u8868\u793a\u4efb\u610f\u4e8c\u53c9\u6811","text":"

    \u7136\u800c\uff0c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u53ea\u662f\u4e00\u4e2a\u7279\u4f8b\u3002\u5728\u4e8c\u53c9\u6811\u7684\u4e2d\u95f4\u5c42\uff0c\u901a\u5e38\u5b58\u5728\u8bb8\u591a \\(\\text{None}\\) \uff0c\u800c\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u5e76\u4e0d\u5305\u542b\u8fd9\u4e9b \\(\\text{None}\\) \u3002\u6211\u4eec\u65e0\u6cd5\u4ec5\u51ed\u8be5\u5e8f\u5217\u6765\u63a8\u6d4b \\(\\text{None}\\) \u7684\u6570\u91cf\u548c\u5206\u5e03\u4f4d\u7f6e\uff0c\u8fd9\u610f\u5473\u7740\u5b58\u5728\u591a\u79cd\u4e8c\u53c9\u6811\u7ed3\u6784\u90fd\u7b26\u5408\u8be5\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u3002\u663e\u7136\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u4e0a\u8ff0\u7684\u6570\u7ec4\u8868\u793a\u65b9\u6cd5\u5df2\u7ecf\u5931\u6548\u3002

    Fig. \u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u5bf9\u5e94\u591a\u79cd\u4e8c\u53c9\u6811\u53ef\u80fd\u6027

    \u4e3a\u4e86\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u8003\u8651\u5728\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u4e2d\u663e\u5f0f\u5730\u5199\u51fa\u6240\u6709 \\(\\text{None}\\)\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u8fd9\u6837\u5904\u7406\u540e\uff0c\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u5c31\u53ef\u4ee5\u552f\u4e00\u8868\u793a\u4e8c\u53c9\u6811\u4e86\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 int \u7684\u5305\u88c5\u7c7b Integer \uff0c\u5c31\u53ef\u4ee5\u4f7f\u7528 null \u6765\u6807\u8bb0\u7a7a\u4f4d\nInteger[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 int \u6700\u5927\u503c\u6807\u8bb0\u7a7a\u4f4d\uff0c\u56e0\u6b64\u8981\u6c42\u8282\u70b9\u503c\u4e0d\u80fd\u4e3a INT_MAX\nvector<int> tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n
    # \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a\n# \u76f4\u63a5\u4f7f\u7528 None \u6765\u8868\u793a\u7a7a\u4f4d\ntree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 any \u7c7b\u578b\u7684\u5207\u7247, \u5c31\u53ef\u4ee5\u4f7f\u7528 nil \u6765\u6807\u8bb0\u7a7a\u4f4d\ntree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u76f4\u63a5\u4f7f\u7528 null \u6765\u8868\u793a\u7a7a\u4f4d\nlet tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u76f4\u63a5\u4f7f\u7528 null \u6765\u8868\u793a\u7a7a\u4f4d\nlet tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 int \u6700\u5927\u503c\u6807\u8bb0\u7a7a\u4f4d\uff0c\u56e0\u6b64\u8981\u6c42\u8282\u70b9\u503c\u4e0d\u80fd\u4e3a INT_MAX\nint tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 int? \u53ef\u7a7a\u7c7b\u578b \uff0c\u5c31\u53ef\u4ee5\u4f7f\u7528 null \u6765\u6807\u8bb0\u7a7a\u4f4d\nint?[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 Int? \u53ef\u7a7a\u7c7b\u578b \uff0c\u5c31\u53ef\u4ee5\u4f7f\u7528 nil \u6765\u6807\u8bb0\u7a7a\u4f4d\nlet tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n
    \n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 int? \u53ef\u7a7a\u7c7b\u578b \uff0c\u5c31\u53ef\u4ee5\u4f7f\u7528 null \u6765\u6807\u8bb0\u7a7a\u4f4d\nList<int?> tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n

    Fig. \u4efb\u610f\u7c7b\u578b\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    "},{"location":"chapter_tree/array_representation_of_tree/#733","title":"7.3.3. \u00a0 \u4f18\u52bf\u4e0e\u5c40\u9650\u6027","text":"

    \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a\u5b58\u5728\u4ee5\u4e0b\u4f18\u70b9\uff1a

    • \u6570\u7ec4\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\uff0c\u7f13\u5b58\u53cb\u597d\uff0c\u8bbf\u95ee\u4e0e\u904d\u5386\u901f\u5ea6\u8f83\u5feb\uff1b
    • \u4e0d\u9700\u8981\u5b58\u50a8\u6307\u9488\uff0c\u6bd4\u8f83\u8282\u7701\u7a7a\u95f4\uff1b
    • \u5141\u8bb8\u968f\u673a\u8bbf\u95ee\u8282\u70b9\uff1b

    \u7136\u800c\uff0c\u6570\u7ec4\u8868\u793a\u4e5f\u5177\u6709\u4e00\u4e9b\u5c40\u9650\u6027\uff1a

    • \u6570\u7ec4\u5b58\u50a8\u9700\u8981\u8fde\u7eed\u5185\u5b58\u7a7a\u95f4\uff0c\u56e0\u6b64\u4e0d\u9002\u5408\u5b58\u50a8\u6570\u636e\u91cf\u8fc7\u5927\u7684\u6811\u3002
    • \u589e\u5220\u8282\u70b9\u9700\u8981\u901a\u8fc7\u6570\u7ec4\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u5b9e\u73b0\uff0c\u6548\u7387\u8f83\u4f4e\uff1b
    • \u5f53\u4e8c\u53c9\u6811\u4e2d\u5b58\u5728\u5927\u91cf \\(\\text{None}\\) \u65f6\uff0c\u6570\u7ec4\u4e2d\u5305\u542b\u7684\u8282\u70b9\u6570\u636e\u6bd4\u91cd\u8f83\u4f4e\uff0c\u7a7a\u95f4\u5229\u7528\u7387\u8f83\u4f4e\u3002

    \u5b8c\u5168\u4e8c\u53c9\u6811\u975e\u5e38\u9002\u5408\u4f7f\u7528\u6570\u7ec4\u6765\u8868\u793a\u3002\u56de\u987e\u5b8c\u5168\u4e8c\u53c9\u6811\u7684\u5b9a\u4e49\uff0c\\(\\text{None}\\) \u53ea\u51fa\u73b0\u5728\u6700\u5e95\u5c42\u4e14\u9760\u53f3\u7684\u4f4d\u7f6e\uff0c\u8fd9\u610f\u5473\u7740\u6240\u6709 \\(\\text{None}\\) \u4e00\u5b9a\u51fa\u73b0\u5728\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u7684\u672b\u5c3e\u3002\u56e0\u6b64\uff0c\u5728\u4f7f\u7528\u6570\u7ec4\u8868\u793a\u5b8c\u5168\u4e8c\u53c9\u6811\u65f6\uff0c\u53ef\u4ee5\u7701\u7565\u5b58\u50a8\u6240\u6709 \\(\\text{None}\\) \u3002

    Fig. \u5b8c\u5168\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    "},{"location":"chapter_tree/avl_tree/","title":"7.5. \u00a0 AVL \u6811 *","text":"

    \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u7ae0\u8282\u4e2d\uff0c\u6211\u4eec\u63d0\u5230\u4e86\u5728\u591a\u6b21\u63d2\u5165\u548c\u5220\u9664\u64cd\u4f5c\u540e\uff0c\u4e8c\u53c9\u641c\u7d22\u6811\u53ef\u80fd\u9000\u5316\u4e3a\u94fe\u8868\u3002\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u6240\u6709\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5c06\u4ece \\(O(\\log n)\\) \u6076\u5316\u4e3a \\(O(n)\\)\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u7ecf\u8fc7\u4e24\u6b21\u5220\u9664\u8282\u70b9\u64cd\u4f5c\uff0c\u8fd9\u4e2a\u4e8c\u53c9\u641c\u7d22\u6811\u4fbf\u4f1a\u9000\u5316\u4e3a\u94fe\u8868\u3002

    Fig. AVL \u6811\u5728\u5220\u9664\u8282\u70b9\u540e\u53d1\u751f\u9000\u5316

    \u518d\u4f8b\u5982\uff0c\u5728\u4ee5\u4e0b\u5b8c\u7f8e\u4e8c\u53c9\u6811\u4e2d\u63d2\u5165\u4e24\u4e2a\u8282\u70b9\u540e\uff0c\u6811\u5c06\u4e25\u91cd\u5411\u5de6\u503e\u659c\uff0c\u67e5\u627e\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e5f\u968f\u4e4b\u6076\u5316\u3002

    Fig. AVL \u6811\u5728\u63d2\u5165\u8282\u70b9\u540e\u53d1\u751f\u9000\u5316

    G. M. Adelson-Velsky \u548c E. M. Landis \u5728\u5176 1962 \u5e74\u53d1\u8868\u7684\u8bba\u6587 \"An algorithm for the organization of information\" \u4e2d\u63d0\u51fa\u4e86\u300cAVL \u6811\u300d\u3002\u8bba\u6587\u4e2d\u8be6\u7ec6\u63cf\u8ff0\u4e86\u4e00\u7cfb\u5217\u64cd\u4f5c\uff0c\u786e\u4fdd\u5728\u6301\u7eed\u6dfb\u52a0\u548c\u5220\u9664\u8282\u70b9\u540e\uff0cAVL \u6811\u4e0d\u4f1a\u9000\u5316\uff0c\u4ece\u800c\u4f7f\u5f97\u5404\u79cd\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4fdd\u6301\u5728 \\(O(\\log n)\\) \u7ea7\u522b\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u5728\u9700\u8981\u9891\u7e41\u8fdb\u884c\u589e\u5220\u67e5\u6539\u64cd\u4f5c\u7684\u573a\u666f\u4e2d\uff0cAVL \u6811\u80fd\u59cb\u7ec8\u4fdd\u6301\u9ad8\u6548\u7684\u6570\u636e\u64cd\u4f5c\u6027\u80fd\uff0c\u5177\u6709\u5f88\u597d\u7684\u5e94\u7528\u4ef7\u503c\u3002

    "},{"location":"chapter_tree/avl_tree/#751-avl","title":"7.5.1. \u00a0 AVL \u6811\u5e38\u89c1\u672f\u8bed","text":"

    \u300cAVL \u6811\u300d\u65e2\u662f\u4e8c\u53c9\u641c\u7d22\u6811\u4e5f\u662f\u5e73\u8861\u4e8c\u53c9\u6811\uff0c\u540c\u65f6\u6ee1\u8db3\u8fd9\u4e24\u7c7b\u4e8c\u53c9\u6811\u7684\u6240\u6709\u6027\u8d28\uff0c\u56e0\u6b64\u4e5f\u88ab\u79f0\u4e3a\u300c\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811\u300d\u3002

    "},{"location":"chapter_tree/avl_tree/#_1","title":"\u8282\u70b9\u9ad8\u5ea6","text":"

    \u5728\u64cd\u4f5c AVL \u6811\u65f6\uff0c\u6211\u4eec\u9700\u8981\u83b7\u53d6\u8282\u70b9\u7684\u9ad8\u5ea6\uff0c\u56e0\u6b64\u9700\u8981\u4e3a AVL \u6811\u7684\u8282\u70b9\u7c7b\u6dfb\u52a0 height \u53d8\u91cf\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\npublic int val;        // \u8282\u70b9\u503c\npublic int height;     // \u8282\u70b9\u9ad8\u5ea6\npublic TreeNode left;  // \u5de6\u5b50\u8282\u70b9\npublic TreeNode right; // \u53f3\u5b50\u8282\u70b9\npublic TreeNode(int x) { val = x; }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nstruct TreeNode {\nint val{};          // \u8282\u70b9\u503c\nint height = 0;     // \u8282\u70b9\u9ad8\u5ea6\nTreeNode *left{};   // \u5de6\u5b50\u8282\u70b9\nTreeNode *right{};  // \u53f3\u5b50\u8282\u70b9\nTreeNode() = default;\nexplicit TreeNode(int x) : val(x){}\n};\n
    class TreeNode:\n\"\"\"AVL \u6811\u8282\u70b9\u7c7b\"\"\"\ndef __init__(self, val: int):\nself.val: int = val                    # \u8282\u70b9\u503c\nself.height: int = 0                   # \u8282\u70b9\u9ad8\u5ea6\nself.left: Optional[TreeNode] = None   # \u5de6\u5b50\u8282\u70b9\u5f15\u7528\nself.right: Optional[TreeNode] = None  # \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n
    /* AVL \u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype TreeNode struct {\nVal    int       // \u8282\u70b9\u503c\nHeight int       // \u8282\u70b9\u9ad8\u5ea6\nLeft   *TreeNode // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\nRight  *TreeNode // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nval; // \u8282\u70b9\u503c\nheight; //\u8282\u70b9\u9ad8\u5ea6\nleft; // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nright; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nconstructor(val, left, right, height) {\nthis.val = val === undefined ? 0 : val;\nthis.height = height === undefined ? 0 : height;\nthis.left = left === undefined ? null : left;\nthis.right = right === undefined ? null : right;\n}\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nval: number;            // \u8282\u70b9\u503c\nheight: number;         // \u8282\u70b9\u9ad8\u5ea6\nleft: TreeNode | null;  // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nright: TreeNode | null; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nconstructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\nthis.val = val === undefined ? 0 : val;\nthis.height = height === undefined ? 0 : height; this.left = left === undefined ? null : left; this.right = right === undefined ? null : right; }\n}\n
    /* AVL \u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\nint val;\nint height;\nstruct TreeNode *left;\nstruct TreeNode *right;\n};\ntypedef struct TreeNode TreeNode;\n/* \u6784\u9020\u51fd\u6570 */\nTreeNode *newTreeNode(int val) {\nTreeNode *node;\nnode = (TreeNode *)malloc(sizeof(TreeNode));\nnode->val = val;\nnode->height = 0;\nnode->left = NULL;\nnode->right = NULL;\nreturn node;\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\npublic int val;          // \u8282\u70b9\u503c\npublic int height;       // \u8282\u70b9\u9ad8\u5ea6\npublic TreeNode? left;   // \u5de6\u5b50\u8282\u70b9\npublic TreeNode? right;  // \u53f3\u5b50\u8282\u70b9\npublic TreeNode(int x) { val = x; }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nvar val: Int // \u8282\u70b9\u503c\nvar height: Int // \u8282\u70b9\u9ad8\u5ea6\nvar left: TreeNode? // \u5de6\u5b50\u8282\u70b9\nvar right: TreeNode? // \u53f3\u5b50\u8282\u70b9\ninit(x: Int) {\nval = x\nheight = 0\n}\n}\n
    \n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nint val;         // \u8282\u70b9\u503c\nint height;      // \u8282\u70b9\u9ad8\u5ea6\nTreeNode? left;  // \u5de6\u5b50\u8282\u70b9\nTreeNode? right; // \u53f3\u5b50\u8282\u70b9\nTreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n

    \u300c\u8282\u70b9\u9ad8\u5ea6\u300d\u662f\u6307\u4ece\u8be5\u8282\u70b9\u5230\u6700\u8fdc\u53f6\u8282\u70b9\u7684\u8ddd\u79bb\uff0c\u5373\u6240\u7ecf\u8fc7\u7684\u201c\u8fb9\u201d\u7684\u6570\u91cf\u3002\u9700\u8981\u7279\u522b\u6ce8\u610f\u7684\u662f\uff0c\u53f6\u8282\u70b9\u7684\u9ad8\u5ea6\u4e3a 0 \uff0c\u800c\u7a7a\u8282\u70b9\u7684\u9ad8\u5ea6\u4e3a -1 \u3002\u6211\u4eec\u5c06\u521b\u5efa\u4e24\u4e2a\u5de5\u5177\u51fd\u6570\uff0c\u5206\u522b\u7528\u4e8e\u83b7\u53d6\u548c\u66f4\u65b0\u8282\u70b9\u7684\u9ad8\u5ea6\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nint height(TreeNode node) {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn node == null ? -1 : node.height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode node) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.height = Math.max(height(node.left), height(node.right)) + 1;\n}\n
    avl_tree.cpp
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nint height(TreeNode *node) {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn node == nullptr ? -1 : node->height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode *node) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode->height = max(height(node->left), height(node->right)) + 1;\n}\n
    avl_tree.py
    def height(self, node: TreeNode | None) -> int:\n\"\"\"\u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6\"\"\"\n# \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nif node is not None:\nreturn node.height\nreturn -1\ndef __update_height(self, node: TreeNode | None):\n\"\"\"\u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\"\"\"\n# \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.height = max([self.height(node.left), self.height(node.right)]) + 1\n
    avl_tree.go
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nfunc (t *aVLTree) height(node *TreeNode) int {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nif node != nil {\nreturn node.Height\n}\nreturn -1\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\nlh := t.height(node.Left)\nrh := t.height(node.Right)\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nif lh > rh {\nnode.Height = lh + 1\n} else {\nnode.Height = rh + 1\n}\n}\n
    avl_tree.js
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nheight(node) {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn node === null ? -1 : node.height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\n#updateHeight(node) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.height =\nMath.max(this.height(node.left), this.height(node.right)) + 1;\n}\n
    avl_tree.ts
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nheight(node: TreeNode): number {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn node === null ? -1 : node.height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nupdateHeight(node: TreeNode): void {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.height =\nMath.max(this.height(node.left), this.height(node.right)) + 1;\n}\n
    avl_tree.c
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nint height(TreeNode *node) {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nif (node != NULL) {\nreturn node->height;\n}\nreturn -1;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode *node) {\nint lh = height(node->left);\nint rh = height(node->right);\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nif (lh > rh) {\nnode->height = lh + 1;\n} else {\nnode->height = rh + 1;\n}\n}\n
    avl_tree.cs
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nint height(TreeNode? node) {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn node == null ? -1 : node.height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode node) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.height = Math.Max(height(node.left), height(node.right)) + 1;\n}\n
    avl_tree.swift
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nfunc height(node: TreeNode?) -> Int {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nnode == nil ? -1 : node!.height\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfunc updateHeight(node: TreeNode?) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode?.height = max(height(node: node?.left), height(node: node?.right)) + 1\n}\n
    avl_tree.zig
    // \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6\nfn height(self: *Self, node: ?*inc.TreeNode(T)) i32 {\n_ = self;\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn if (node == null) -1 else node.?.height;\n}\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nfn updateHeight(self: *Self, node: ?*inc.TreeNode(T)) void {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.?.height = @max(self.height(node.?.left), self.height(node.?.right)) + 1;\n}\n
    avl_tree.dart
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nint height(TreeNode? node) {\nreturn node == null ? -1 : node.height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode? node) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode!.height = max(height(node.left), height(node.right)) + 1;\n}\n
    "},{"location":"chapter_tree/avl_tree/#_2","title":"\u8282\u70b9\u5e73\u8861\u56e0\u5b50","text":"

    \u8282\u70b9\u7684\u300c\u5e73\u8861\u56e0\u5b50 Balance Factor\u300d\u5b9a\u4e49\u4e3a\u8282\u70b9\u5de6\u5b50\u6811\u7684\u9ad8\u5ea6\u51cf\u53bb\u53f3\u5b50\u6811\u7684\u9ad8\u5ea6\uff0c\u540c\u65f6\u89c4\u5b9a\u7a7a\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50\u4e3a 0 \u3002\u6211\u4eec\u540c\u6837\u5c06\u83b7\u53d6\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u7684\u529f\u80fd\u5c01\u88c5\u6210\u51fd\u6570\uff0c\u65b9\u4fbf\u540e\u7eed\u4f7f\u7528\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == null)\nreturn 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node.left) - height(node.right);\n}\n
    avl_tree.cpp
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode *node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == nullptr)\nreturn 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node->left) - height(node->right);\n}\n
    avl_tree.py
    def balance_factor(self, node: TreeNode | None) -> int:\n\"\"\"\u83b7\u53d6\u5e73\u8861\u56e0\u5b50\"\"\"\n# \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif node is None:\nreturn 0\n# \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn self.height(node.left) - self.height(node.right)\n
    avl_tree.go
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nfunc (t *aVLTree) balanceFactor(node *TreeNode) int {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif node == nil {\nreturn 0\n}\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn t.height(node.Left) - t.height(node.Right)\n}\n
    avl_tree.js
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nbalanceFactor(node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node === null) return 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn this.height(node.left) - this.height(node.right);\n}\n
    avl_tree.ts
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nbalanceFactor(node: TreeNode): number {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node === null) return 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn this.height(node.left) - this.height(node.right);\n}\n
    avl_tree.c
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode *node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == NULL) {\nreturn 0;\n}\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node->left) - height(node->right);\n}\n
    avl_tree.cs
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode? node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == null) return 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node.left) - height(node.right);\n}\n
    avl_tree.swift
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nfunc balanceFactor(node: TreeNode?) -> Int {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nguard let node = node else { return 0 }\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node: node.left) - height(node: node.right)\n}\n
    avl_tree.zig
    // \u83b7\u53d6\u5e73\u8861\u56e0\u5b50\nfn balanceFactor(self: *Self, node: ?*inc.TreeNode(T)) i32 {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == null) return 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn self.height(node.?.left) - self.height(node.?.right);\n}\n
    avl_tree.dart
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode? node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == null) return 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node.left) - height(node.right);\n}\n

    Note

    \u8bbe\u5e73\u8861\u56e0\u5b50\u4e3a \\(f\\) \uff0c\u5219\u4e00\u68f5 AVL \u6811\u7684\u4efb\u610f\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50\u7686\u6ee1\u8db3 \\(-1 \\le f \\le 1\\) \u3002

    "},{"location":"chapter_tree/avl_tree/#752-avl","title":"7.5.2. \u00a0 AVL \u6811\u65cb\u8f6c","text":"

    AVL \u6811\u7684\u7279\u70b9\u5728\u4e8e\u300c\u65cb\u8f6c Rotation\u300d\u64cd\u4f5c\uff0c\u5b83\u80fd\u591f\u5728\u4e0d\u5f71\u54cd\u4e8c\u53c9\u6811\u7684\u4e2d\u5e8f\u904d\u5386\u5e8f\u5217\u7684\u524d\u63d0\u4e0b\uff0c\u4f7f\u5931\u8861\u8282\u70b9\u91cd\u65b0\u6062\u590d\u5e73\u8861\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u65cb\u8f6c\u64cd\u4f5c\u65e2\u80fd\u4fdd\u6301\u6811\u7684\u300c\u4e8c\u53c9\u641c\u7d22\u6811\u300d\u5c5e\u6027\uff0c\u4e5f\u80fd\u4f7f\u6811\u91cd\u65b0\u53d8\u4e3a\u300c\u5e73\u8861\u4e8c\u53c9\u6811\u300d\u3002

    \u6211\u4eec\u5c06\u5e73\u8861\u56e0\u5b50\u7edd\u5bf9\u503c \\(> 1\\) \u7684\u8282\u70b9\u79f0\u4e3a\u300c\u5931\u8861\u8282\u70b9\u300d\u3002\u6839\u636e\u8282\u70b9\u5931\u8861\u60c5\u51b5\u7684\u4e0d\u540c\uff0c\u65cb\u8f6c\u64cd\u4f5c\u5206\u4e3a\u56db\u79cd\uff1a\u53f3\u65cb\u3001\u5de6\u65cb\u3001\u5148\u53f3\u65cb\u540e\u5de6\u65cb\u3001\u5148\u5de6\u65cb\u540e\u53f3\u65cb\u3002\u4e0b\u9762\u6211\u4eec\u5c06\u8be6\u7ec6\u4ecb\u7ecd\u8fd9\u4e9b\u65cb\u8f6c\u64cd\u4f5c\u3002

    "},{"location":"chapter_tree/avl_tree/#_3","title":"\u53f3\u65cb","text":"

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u8282\u70b9\u4e0b\u65b9\u4e3a\u5e73\u8861\u56e0\u5b50\u3002\u4ece\u5e95\u81f3\u9876\u770b\uff0c\u4e8c\u53c9\u6811\u4e2d\u9996\u4e2a\u5931\u8861\u8282\u70b9\u662f\u201c\u8282\u70b9 3\u201d\u3002\u6211\u4eec\u5173\u6ce8\u4ee5\u8be5\u5931\u8861\u8282\u70b9\u4e3a\u6839\u8282\u70b9\u7684\u5b50\u6811\uff0c\u5c06\u8be5\u8282\u70b9\u8bb0\u4e3a node \uff0c\u5176\u5de6\u5b50\u8282\u70b9\u8bb0\u4e3a child \uff0c\u6267\u884c\u300c\u53f3\u65cb\u300d\u64cd\u4f5c\u3002\u5b8c\u6210\u53f3\u65cb\u540e\uff0c\u5b50\u6811\u5df2\u7ecf\u6062\u590d\u5e73\u8861\uff0c\u5e76\u4e14\u4ecd\u7136\u4fdd\u6301\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u7279\u6027\u3002

    <1><2><3><4>

    \u6b64\u5916\uff0c\u5982\u679c\u8282\u70b9 child \u672c\u8eab\u6709\u53f3\u5b50\u8282\u70b9\uff08\u8bb0\u4e3a grandChild \uff09\uff0c\u5219\u9700\u8981\u5728\u300c\u53f3\u65cb\u300d\u4e2d\u6dfb\u52a0\u4e00\u6b65\uff1a\u5c06 grandChild \u4f5c\u4e3a node \u7684\u5de6\u5b50\u8282\u70b9\u3002

    Fig. \u6709 grandChild \u7684\u53f3\u65cb\u64cd\u4f5c

    \u201c\u5411\u53f3\u65cb\u8f6c\u201d\u662f\u4e00\u79cd\u5f62\u8c61\u5316\u7684\u8bf4\u6cd5\uff0c\u5b9e\u9645\u4e0a\u9700\u8981\u901a\u8fc7\u4fee\u6539\u8282\u70b9\u6307\u9488\u6765\u5b9e\u73b0\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode rightRotate(TreeNode node) {\nTreeNode child = node.left;\nTreeNode grandChild = child.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node;\nnode.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.cpp
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode *rightRotate(TreeNode *node) {\nTreeNode *child = node->left;\nTreeNode *grandChild = child->right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild->right = node;\nnode->left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.py
    def __right_rotate(self, node: TreeNode | None) -> TreeNode | None:\n\"\"\"\u53f3\u65cb\u64cd\u4f5c\"\"\"\nchild = node.left\ngrand_child = child.right\n# \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node\nnode.left = grand_child\n# \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.__update_height(node)\nself.__update_height(child)\n# \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n
    avl_tree.go
    /* \u53f3\u65cb\u64cd\u4f5c */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\nchild := node.Left\ngrandChild := child.Right\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.Right = node\nnode.Left = grandChild\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nt.updateHeight(node)\nt.updateHeight(child)\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n}\n
    avl_tree.js
    /* \u53f3\u65cb\u64cd\u4f5c */\n#rightRotate(node) {\nconst child = node.left;\nconst grandChild = child.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node;\nnode.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nthis.#updateHeight(node);\nthis.#updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.ts
    /* \u53f3\u65cb\u64cd\u4f5c */\nrightRotate(node: TreeNode): TreeNode {\nconst child = node.left;\nconst grandChild = child.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node;\nnode.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nthis.updateHeight(node);\nthis.updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.c
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode *rightRotate(TreeNode *node) {\nTreeNode *child, *grandChild;\nchild = node->left;\ngrandChild = child->right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild->right = node;\nnode->left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.cs
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode? rightRotate(TreeNode? node) {\nTreeNode? child = node.left;\nTreeNode? grandChild = child?.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node;\nnode.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.swift
    /* \u53f3\u65cb\u64cd\u4f5c */\nfunc rightRotate(node: TreeNode?) -> TreeNode? {\nlet child = node?.left\nlet grandChild = child?.right\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild?.right = node\nnode?.left = grandChild\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node: node)\nupdateHeight(node: child)\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n}\n
    avl_tree.zig
    // \u53f3\u65cb\u64cd\u4f5c\nfn rightRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\nvar child = node.?.left;\nvar grandChild = child.?.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.?.right = node;\nnode.?.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.updateHeight(node);\nself.updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.dart
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode? rightRotate(TreeNode? node) {\nTreeNode? child = node!.left;\nTreeNode? grandChild = child!.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node;\nnode.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    "},{"location":"chapter_tree/avl_tree/#_4","title":"\u5de6\u65cb","text":"

    \u76f8\u5e94\u7684\uff0c\u5982\u679c\u8003\u8651\u4e0a\u8ff0\u5931\u8861\u4e8c\u53c9\u6811\u7684\u201c\u955c\u50cf\u201d\uff0c\u5219\u9700\u8981\u6267\u884c\u300c\u5de6\u65cb\u300d\u64cd\u4f5c\u3002

    Fig. \u5de6\u65cb\u64cd\u4f5c

    \u540c\u7406\uff0c\u82e5\u8282\u70b9 child \u672c\u8eab\u6709\u5de6\u5b50\u8282\u70b9\uff08\u8bb0\u4e3a grandChild \uff09\uff0c\u5219\u9700\u8981\u5728\u300c\u5de6\u65cb\u300d\u4e2d\u6dfb\u52a0\u4e00\u6b65\uff1a\u5c06 grandChild \u4f5c\u4e3a node \u7684\u53f3\u5b50\u8282\u70b9\u3002

    Fig. \u6709 grandChild \u7684\u5de6\u65cb\u64cd\u4f5c

    \u53ef\u4ee5\u89c2\u5bdf\u5230\uff0c\u53f3\u65cb\u548c\u5de6\u65cb\u64cd\u4f5c\u5728\u903b\u8f91\u4e0a\u662f\u955c\u50cf\u5bf9\u79f0\u7684\uff0c\u5b83\u4eec\u5206\u522b\u89e3\u51b3\u7684\u4e24\u79cd\u5931\u8861\u60c5\u51b5\u4e5f\u662f\u5bf9\u79f0\u7684\u3002\u57fa\u4e8e\u5bf9\u79f0\u6027\uff0c\u6211\u4eec\u53ef\u4ee5\u8f7b\u677e\u5730\u4ece\u53f3\u65cb\u7684\u4ee3\u7801\u63a8\u5bfc\u51fa\u5de6\u65cb\u7684\u4ee3\u7801\u3002\u5177\u4f53\u5730\uff0c\u53ea\u9700\u5c06\u300c\u53f3\u65cb\u300d\u4ee3\u7801\u4e2d\u7684\u628a\u6240\u6709\u7684 left \u66ff\u6362\u4e3a right \uff0c\u5c06\u6240\u6709\u7684 right \u66ff\u6362\u4e3a left \uff0c\u5373\u53ef\u5f97\u5230\u300c\u5de6\u65cb\u300d\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode leftRotate(TreeNode node) {\nTreeNode child = node.right;\nTreeNode grandChild = child.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node;\nnode.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.cpp
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode *leftRotate(TreeNode *node) {\nTreeNode *child = node->right;\nTreeNode *grandChild = child->left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild->left = node;\nnode->right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.py
    def __left_rotate(self, node: TreeNode | None) -> TreeNode | None:\n\"\"\"\u5de6\u65cb\u64cd\u4f5c\"\"\"\nchild = node.right\ngrand_child = child.left\n# \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node\nnode.right = grand_child\n# \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.__update_height(node)\nself.__update_height(child)\n# \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n
    avl_tree.go
    /* \u5de6\u65cb\u64cd\u4f5c */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\nchild := node.Right\ngrandChild := child.Left\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.Left = node\nnode.Right = grandChild\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nt.updateHeight(node)\nt.updateHeight(child)\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n}\n
    avl_tree.js
    /* \u5de6\u65cb\u64cd\u4f5c */\n#leftRotate(node) {\nconst child = node.right;\nconst grandChild = child.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node;\nnode.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nthis.#updateHeight(node);\nthis.#updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.ts
    /* \u5de6\u65cb\u64cd\u4f5c */\nleftRotate(node: TreeNode): TreeNode {\nconst child = node.right;\nconst grandChild = child.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node;\nnode.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nthis.updateHeight(node);\nthis.updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.c
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode *leftRotate(TreeNode *node) {\nTreeNode *child, *grandChild;\nchild = node->right;\ngrandChild = child->left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild->left = node;\nnode->right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.cs
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode? leftRotate(TreeNode? node) {\nTreeNode? child = node.right;\nTreeNode? grandChild = child?.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node;\nnode.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.swift
    /* \u5de6\u65cb\u64cd\u4f5c */\nfunc leftRotate(node: TreeNode?) -> TreeNode? {\nlet child = node?.right\nlet grandChild = child?.left\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild?.left = node\nnode?.right = grandChild\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node: node)\nupdateHeight(node: child)\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n}\n
    avl_tree.zig
    // \u5de6\u65cb\u64cd\u4f5c\nfn leftRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\nvar child = node.?.right;\nvar grandChild = child.?.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.?.left = node;\nnode.?.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.updateHeight(node);\nself.updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.dart
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode? leftRotate(TreeNode? node) {\nTreeNode? child = node!.right;\nTreeNode? grandChild = child!.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node;\nnode.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    "},{"location":"chapter_tree/avl_tree/#_5","title":"\u5148\u5de6\u65cb\u540e\u53f3\u65cb","text":"

    \u5bf9\u4e8e\u4e0b\u56fe\u4e2d\u7684\u5931\u8861\u8282\u70b9 3\uff0c\u4ec5\u4f7f\u7528\u5de6\u65cb\u6216\u53f3\u65cb\u90fd\u65e0\u6cd5\u4f7f\u5b50\u6811\u6062\u590d\u5e73\u8861\u3002\u6b64\u65f6\u9700\u8981\u5148\u5de6\u65cb\u540e\u53f3\u65cb\uff0c\u5373\u5148\u5bf9 child \u6267\u884c\u300c\u5de6\u65cb\u300d\uff0c\u518d\u5bf9 node \u6267\u884c\u300c\u53f3\u65cb\u300d\u3002

    Fig. \u5148\u5de6\u65cb\u540e\u53f3\u65cb

    "},{"location":"chapter_tree/avl_tree/#_6","title":"\u5148\u53f3\u65cb\u540e\u5de6\u65cb","text":"

    \u540c\u7406\uff0c\u5bf9\u4e8e\u4e0a\u8ff0\u5931\u8861\u4e8c\u53c9\u6811\u7684\u955c\u50cf\u60c5\u51b5\uff0c\u9700\u8981\u5148\u53f3\u65cb\u540e\u5de6\u65cb\uff0c\u5373\u5148\u5bf9 child \u6267\u884c\u300c\u53f3\u65cb\u300d\uff0c\u7136\u540e\u5bf9 node \u6267\u884c\u300c\u5de6\u65cb\u300d\u3002

    Fig. \u5148\u53f3\u65cb\u540e\u5de6\u65cb

    "},{"location":"chapter_tree/avl_tree/#_7","title":"\u65cb\u8f6c\u7684\u9009\u62e9","text":"

    \u4e0b\u56fe\u5c55\u793a\u7684\u56db\u79cd\u5931\u8861\u60c5\u51b5\u4e0e\u4e0a\u8ff0\u6848\u4f8b\u9010\u4e2a\u5bf9\u5e94\uff0c\u5206\u522b\u9700\u8981\u91c7\u7528\u53f3\u65cb\u3001\u5de6\u65cb\u3001\u5148\u53f3\u540e\u5de6\u3001\u5148\u5de6\u540e\u53f3\u7684\u65cb\u8f6c\u64cd\u4f5c\u3002

    Fig. AVL \u6811\u7684\u56db\u79cd\u65cb\u8f6c\u60c5\u51b5

    \u5728\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u901a\u8fc7\u5224\u65ad\u5931\u8861\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50\u4ee5\u53ca\u8f83\u9ad8\u4e00\u4fa7\u5b50\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50\u7684\u6b63\u8d1f\u53f7\uff0c\u6765\u786e\u5b9a\u5931\u8861\u8282\u70b9\u5c5e\u4e8e\u4e0a\u56fe\u4e2d\u7684\u54ea\u79cd\u60c5\u51b5\u3002

    \u5931\u8861\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50 \u5b50\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50 \u5e94\u91c7\u7528\u7684\u65cb\u8f6c\u65b9\u6cd5 \\(>1\\) \uff08\u5373\u5de6\u504f\u6811\uff09 \\(\\geq 0\\) \u53f3\u65cb \\(>1\\) \uff08\u5373\u5de6\u504f\u6811\uff09 \\(<0\\) \u5148\u5de6\u65cb\u540e\u53f3\u65cb \\(<-1\\) \uff08\u5373\u53f3\u504f\u6811\uff09 \\(\\leq 0\\) \u5de6\u65cb \\(<-1\\) \uff08\u5373\u53f3\u504f\u6811\uff09 \\(>0\\) \u5148\u53f3\u65cb\u540e\u5de6\u65cb

    \u4e3a\u4e86\u4fbf\u4e8e\u4f7f\u7528\uff0c\u6211\u4eec\u5c06\u65cb\u8f6c\u64cd\u4f5c\u5c01\u88c5\u6210\u4e00\u4e2a\u51fd\u6570\u3002\u6709\u4e86\u8fd9\u4e2a\u51fd\u6570\uff0c\u6211\u4eec\u5c31\u80fd\u5bf9\u5404\u79cd\u5931\u8861\u60c5\u51b5\u8fdb\u884c\u65cb\u8f6c\uff0c\u4f7f\u5931\u8861\u8282\u70b9\u91cd\u65b0\u6062\u590d\u5e73\u8861\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nTreeNode rotate(TreeNode node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nint balanceFactor = balanceFactor(node);\n// \u5de6\u504f\u6811\nif (balanceFactor > 1) {\nif (balanceFactor(node.left) >= 0) {\n// \u53f3\u65cb\nreturn rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = leftRotate(node.left);\nreturn rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (balanceFactor < -1) {\nif (balanceFactor(node.right) <= 0) {\n// \u5de6\u65cb\nreturn leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = rightRotate(node.right);\nreturn leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.cpp
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nTreeNode *rotate(TreeNode *node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nint _balanceFactor = balanceFactor(node);\n// \u5de6\u504f\u6811\nif (_balanceFactor > 1) {\nif (balanceFactor(node->left) >= 0) {\n// \u53f3\u65cb\nreturn rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode->left = leftRotate(node->left);\nreturn rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (_balanceFactor < -1) {\nif (balanceFactor(node->right) <= 0) {\n// \u5de6\u65cb\nreturn leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode->right = rightRotate(node->right);\nreturn leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.py
    def __rotate(self, node: TreeNode | None) -> TreeNode | None:\n\"\"\"\u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\"\"\"\n# \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nbalance_factor = self.balance_factor(node)\n# \u5de6\u504f\u6811\nif balance_factor > 1:\nif self.balance_factor(node.left) >= 0:\n# \u53f3\u65cb\nreturn self.__right_rotate(node)\nelse:\n# \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = self.__left_rotate(node.left)\nreturn self.__right_rotate(node)\n# \u53f3\u504f\u6811\nelif balance_factor < -1:\nif self.balance_factor(node.right) <= 0:\n# \u5de6\u65cb\nreturn self.__left_rotate(node)\nelse:\n# \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = self.__right_rotate(node.right)\nreturn self.__left_rotate(node)\n# \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node\n
    avl_tree.go
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nfunc (t *aVLTree) rotate(node *TreeNode) *TreeNode {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\n// Go \u63a8\u8350\u77ed\u53d8\u91cf\uff0c\u8fd9\u91cc bf \u6307\u4ee3 t.balanceFactor\nbf := t.balanceFactor(node)\n// \u5de6\u504f\u6811\nif bf > 1 {\nif t.balanceFactor(node.Left) >= 0 {\n// \u53f3\u65cb\nreturn t.rightRotate(node)\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.Left = t.leftRotate(node.Left)\nreturn t.rightRotate(node)\n}\n}\n// \u53f3\u504f\u6811\nif bf < -1 {\nif t.balanceFactor(node.Right) <= 0 {\n// \u5de6\u65cb\nreturn t.leftRotate(node)\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.Right = t.rightRotate(node.Right)\nreturn t.leftRotate(node)\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node\n}\n
    avl_tree.js
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n#rotate(node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nconst balanceFactor = this.balanceFactor(node);\n// \u5de6\u504f\u6811\nif (balanceFactor > 1) {\nif (this.balanceFactor(node.left) >= 0) {\n// \u53f3\u65cb\nreturn this.#rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = this.#leftRotate(node.left);\nreturn this.#rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (balanceFactor < -1) {\nif (this.balanceFactor(node.right) <= 0) {\n// \u5de6\u65cb\nreturn this.#leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = this.#rightRotate(node.right);\nreturn this.#leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.ts
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nrotate(node: TreeNode): TreeNode {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nconst balanceFactor = this.balanceFactor(node);\n// \u5de6\u504f\u6811\nif (balanceFactor > 1) {\nif (this.balanceFactor(node.left) >= 0) {\n// \u53f3\u65cb\nreturn this.rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = this.leftRotate(node.left);\nreturn this.rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (balanceFactor < -1) {\nif (this.balanceFactor(node.right) <= 0) {\n// \u5de6\u65cb\nreturn this.leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = this.rightRotate(node.right);\nreturn this.leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.c
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nTreeNode *rotate(TreeNode *node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nint bf = balanceFactor(node);\n// \u5de6\u504f\u6811\nif (bf > 1) {\nif (balanceFactor(node->left) >= 0) {\n// \u53f3\u65cb\nreturn rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode->left = leftRotate(node->left);\nreturn rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (bf < -1) {\nif (balanceFactor(node->right) <= 0) {\n// \u5de6\u65cb\nreturn leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode->right = rightRotate(node->right);\nreturn leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.cs
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nTreeNode? rotate(TreeNode? node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nint balanceFactorInt = balanceFactor(node);\n// \u5de6\u504f\u6811\nif (balanceFactorInt > 1) {\nif (balanceFactor(node.left) >= 0) {\n// \u53f3\u65cb\nreturn rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = leftRotate(node?.left);\nreturn rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (balanceFactorInt < -1) {\nif (balanceFactor(node.right) <= 0) {\n// \u5de6\u65cb\nreturn leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = rightRotate(node?.right);\nreturn leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.swift
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nfunc rotate(node: TreeNode?) -> TreeNode? {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nlet balanceFactor = balanceFactor(node: node)\n// \u5de6\u504f\u6811\nif balanceFactor > 1 {\nif self.balanceFactor(node: node?.left) >= 0 {\n// \u53f3\u65cb\nreturn rightRotate(node: node)\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode?.left = leftRotate(node: node?.left)\nreturn rightRotate(node: node)\n}\n}\n// \u53f3\u504f\u6811\nif balanceFactor < -1 {\nif self.balanceFactor(node: node?.right) <= 0 {\n// \u5de6\u65cb\nreturn leftRotate(node: node)\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode?.right = rightRotate(node: node?.right)\nreturn leftRotate(node: node)\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node\n}\n
    avl_tree.zig
    // \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\nfn rotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nvar balance_factor = self.balanceFactor(node);\n// \u5de6\u504f\u6811\nif (balance_factor > 1) {\nif (self.balanceFactor(node.?.left) >= 0) {\n// \u53f3\u65cb\nreturn self.rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.?.left = self.leftRotate(node.?.left);\nreturn self.rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (balance_factor < -1) {\nif (self.balanceFactor(node.?.right) <= 0) {\n// \u5de6\u65cb\nreturn self.leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.?.right = self.rightRotate(node.?.right);\nreturn self.leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.dart
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nTreeNode? rotate(TreeNode? node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nint factor = balanceFactor(node);\n// \u5de6\u504f\u6811\nif (factor > 1) {\nif (balanceFactor(node!.left) >= 0) {\n// \u53f3\u65cb\nreturn rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = leftRotate(node.left);\nreturn rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (factor < -1) {\nif (balanceFactor(node!.right) <= 0) {\n// \u5de6\u65cb\nreturn leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = rightRotate(node.right);\nreturn leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#753-avl","title":"7.5.3. \u00a0 AVL \u6811\u5e38\u7528\u64cd\u4f5c","text":""},{"location":"chapter_tree/avl_tree/#_8","title":"\u63d2\u5165\u8282\u70b9","text":"

    \u300cAVL \u6811\u300d\u7684\u8282\u70b9\u63d2\u5165\u64cd\u4f5c\u4e0e\u300c\u4e8c\u53c9\u641c\u7d22\u6811\u300d\u5728\u4e3b\u4f53\u4e0a\u7c7b\u4f3c\u3002\u552f\u4e00\u7684\u533a\u522b\u5728\u4e8e\uff0c\u5728 AVL \u6811\u4e2d\u63d2\u5165\u8282\u70b9\u540e\uff0c\u4ece\u8be5\u8282\u70b9\u5230\u6839\u8282\u70b9\u7684\u8def\u5f84\u4e0a\u53ef\u80fd\u4f1a\u51fa\u73b0\u4e00\u7cfb\u5217\u5931\u8861\u8282\u70b9\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u9700\u8981\u4ece\u8fd9\u4e2a\u8282\u70b9\u5f00\u59cb\uff0c\u81ea\u5e95\u5411\u4e0a\u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u6240\u6709\u5931\u8861\u8282\u70b9\u6062\u590d\u5e73\u8861\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\nroot = insertHelper(root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode insertHelper(TreeNode node, int val) {\nif (node == null)\nreturn new TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node.val)\nnode.left = insertHelper(node.left, val);\nelse if (val > node.val)\nnode.right = insertHelper(node.right, val);\nelse\nreturn node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.cpp
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\nroot = insertHelper(root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode *insertHelper(TreeNode *node, int val) {\nif (node == nullptr)\nreturn new TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node->val)\nnode->left = insertHelper(node->left, val);\nelse if (val > node->val)\nnode->right = insertHelper(node->right, val);\nelse\nreturn node;    // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.py
    def insert(self, val) -> None:\n\"\"\"\u63d2\u5165\u8282\u70b9\"\"\"\nself.root = self.__insert_helper(self.root, val)\ndef __insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:\n\"\"\"\u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\"\"\"\nif node is None:\nreturn TreeNode(val)\n# 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9\nif val < node.val:\nnode.left = self.__insert_helper(node.left, val)\nelif val > node.val:\nnode.right = self.__insert_helper(node.right, val)\nelse:\n# \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node\n# \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.__update_height(node)\n# 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\nreturn self.__rotate(node)\n
    avl_tree.go
    /* \u63d2\u5165\u8282\u70b9 */\nfunc (t *aVLTree) insert(val int) {\nt.root = t.insertHelper(t.root, val)\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\nif node == nil {\nreturn NewTreeNode(val)\n}\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif val < node.Val {\nnode.Left = t.insertHelper(node.Left, val)\n} else if val > node.Val {\nnode.Right = t.insertHelper(node.Right, val)\n} else {\n// \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node\n}\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nt.updateHeight(node)\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = t.rotate(node)\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node\n}\n
    avl_tree.js
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(val) {\nthis.root = this.#insertHelper(this.root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\n#insertHelper(node, val) {\nif (node === null) return new TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node.val) node.left = this.#insertHelper(node.left, val);\nelse if (val > node.val)\nnode.right = this.#insertHelper(node.right, val);\nelse return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nthis.#updateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = this.#rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.ts
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(val: number): void {\nthis.root = this.insertHelper(this.root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\ninsertHelper(node: TreeNode, val: number): TreeNode {\nif (node === null) return new TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node.val) {\nnode.left = this.insertHelper(node.left, val);\n} else if (val > node.val) {\nnode.right = this.insertHelper(node.right, val);\n} else {\nreturn node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n}\nthis.updateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = this.rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.c
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(aVLTree *tree, int val) {\ntree->root = insertHelper(tree->root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nTreeNode *insertHelper(TreeNode *node, int val) {\nif (node == NULL) {\nreturn newTreeNode(val);\n}\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node->val) {\nnode->left = insertHelper(node->left, val);\n} else if (val > node->val) {\nnode->right = insertHelper(node->right, val);\n} else {\n// \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.cs
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\nroot = insertHelper(root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? insertHelper(TreeNode? node, int val) {\nif (node == null) return new TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node.val)\nnode.left = insertHelper(node.left, val);\nelse if (val > node.val)\nnode.right = insertHelper(node.right, val);\nelse\nreturn node;     // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nupdateHeight(node);  // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.swift
    /* \u63d2\u5165\u8282\u70b9 */\n@discardableResult\nfunc insert(val: Int) {\nroot = insertHelper(node: root, val: val)\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfunc insertHelper(node: TreeNode?, val: Int) -> TreeNode? {\nvar node = node\nif node == nil {\nreturn TreeNode(x: val)\n}\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif val < node!.val {\nnode?.left = insertHelper(node: node?.left, val: val)\n} else if val > node!.val {\nnode?.right = insertHelper(node: node?.right, val: val)\n} else {\nreturn node // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n}\nupdateHeight(node: node) // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node: node)\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node\n}\n
    avl_tree.zig
    // \u63d2\u5165\u8282\u70b9\nfn insert(self: *Self, val: T) !void {\nself.root = (try self.insertHelper(self.root, val)).?;\n}\n// \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\nfn insertHelper(self: *Self, node_: ?*inc.TreeNode(T), val: T) !?*inc.TreeNode(T) {\nvar node = node_;\nif (node == null) {\nvar tmp_node = try self.mem_allocator.create(inc.TreeNode(T));\ntmp_node.init(val);\nreturn tmp_node;\n}\n// 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9\nif (val < node.?.val) {\nnode.?.left = try self.insertHelper(node.?.left, val);\n} else if (val > node.?.val) {\nnode.?.right = try self.insertHelper(node.?.right, val);\n} else {\nreturn node;            // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n}\nself.updateHeight(node);    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n// 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\nnode = self.rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.dart
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\nroot = insertHelper(root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? insertHelper(TreeNode? node, int val) {\nif (node == null) return TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node.val)\nnode.left = insertHelper(node.left, val);\nelse if (val > node.val)\nnode.right = insertHelper(node.right, val);\nelse\nreturn node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#_9","title":"\u5220\u9664\u8282\u70b9","text":"

    \u7c7b\u4f3c\u5730\uff0c\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u5220\u9664\u8282\u70b9\u65b9\u6cd5\u7684\u57fa\u7840\u4e0a\uff0c\u9700\u8981\u4ece\u5e95\u81f3\u9876\u5730\u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u6240\u6709\u5931\u8861\u8282\u70b9\u6062\u590d\u5e73\u8861\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\nroot = removeHelper(root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode removeHelper(TreeNode node, int val) {\nif (node == null)\nreturn null;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node.val)\nnode.left = removeHelper(node.left, val);\nelse if (val > node.val)\nnode.right = removeHelper(node.right, val);\nelse {\nif (node.left == null || node.right == null) {\nTreeNode child = node.left != null ? node.left : node.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == null)\nreturn null;\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse\nnode = child;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nTreeNode temp = node.right;\nwhile (temp.left != null) {\ntemp = temp.left;\n}\nnode.right = removeHelper(node.right, temp.val);\nnode.val = temp.val;\n}\n}\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.cpp
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\nroot = removeHelper(root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode *removeHelper(TreeNode *node, int val) {\nif (node == nullptr)\nreturn nullptr;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node->val)\nnode->left = removeHelper(node->left, val);\nelse if (val > node->val)\nnode->right = removeHelper(node->right, val);\nelse {\nif (node->left == nullptr || node->right == nullptr) {\nTreeNode *child = node->left != nullptr ? node->left : node->right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == nullptr) {\ndelete node;\nreturn nullptr;\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse {\ndelete node;\nnode = child;\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nTreeNode *temp = node->right;\nwhile (temp->left != nullptr) {\ntemp = temp->left;\n}\nint tempVal = temp->val;\nnode->right = removeHelper(node->right, temp->val);\nnode->val = tempVal;\n}\n}\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.py
    def remove(self, val: int) -> None:\n\"\"\"\u5220\u9664\u8282\u70b9\"\"\"\nself.root = self.__remove_helper(self.root, val)\ndef __remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:\n\"\"\"\u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\"\"\"\nif node is None:\nreturn None\n# 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b\nif val < node.val:\nnode.left = self.__remove_helper(node.left, val)\nelif val > node.val:\nnode.right = self.__remove_helper(node.right, val)\nelse:\nif node.left is None or node.right is None:\nchild = node.left or node.right\n# \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif child is None:\nreturn None\n# \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse:\nnode = child\nelse:\n# \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\ntemp = node.right\nwhile temp.left is not None:\ntemp = temp.left\nnode.right = self.__remove_helper(node.right, temp.val)\nnode.val = temp.val\n# \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.__update_height(node)\n# 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\nreturn self.__rotate(node)\n
    avl_tree.go
    /* \u5220\u9664\u8282\u70b9 */\nfunc (t *aVLTree) remove(val int) {\nt.root = t.removeHelper(t.root, val)\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\nif node == nil {\nreturn nil\n}\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif val < node.Val {\nnode.Left = t.removeHelper(node.Left, val)\n} else if val > node.Val {\nnode.Right = t.removeHelper(node.Right, val)\n} else {\nif node.Left == nil || node.Right == nil {\nchild := node.Left\nif node.Right != nil {\nchild = node.Right\n}\nif child == nil {\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nreturn nil\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nnode = child\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\ntemp := node.Right\nfor temp.Left != nil {\ntemp = temp.Left\n}\nnode.Right = t.removeHelper(node.Right, temp.Val)\nnode.Val = temp.Val\n}\n}\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nt.updateHeight(node)\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = t.rotate(node)\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node\n}\n
    avl_tree.js
    /* \u5220\u9664\u8282\u70b9 */\nremove(val) {\nthis.root = this.#removeHelper(this.root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\n#removeHelper(node, val) {\nif (node === null) return null;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node.val) node.left = this.#removeHelper(node.left, val);\nelse if (val > node.val)\nnode.right = this.#removeHelper(node.right, val);\nelse {\nif (node.left === null || node.right === null) {\nconst child = node.left !== null ? node.left : node.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child === null) return null;\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse node = child;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nlet temp = node.right;\nwhile (temp.left !== null) {\ntemp = temp.left;\n}\nnode.right = this.#removeHelper(node.right, temp.val);\nnode.val = temp.val;\n}\n}\nthis.#updateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = this.#rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.ts
    /* \u5220\u9664\u8282\u70b9 */\nremove(val: number): void {\nthis.root = this.removeHelper(this.root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nremoveHelper(node: TreeNode, val: number): TreeNode {\nif (node === null) return null;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node.val) {\nnode.left = this.removeHelper(node.left, val);\n} else if (val > node.val) {\nnode.right = this.removeHelper(node.right, val);\n} else {\nif (node.left === null || node.right === null) {\nconst child = node.left !== null ? node.left : node.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child === null) {\nreturn null;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nnode = child;\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nlet temp = node.right;\nwhile (temp.left !== null) {\ntemp = temp.left;\n}\nnode.right = this.removeHelper(node.right, temp.val);\nnode.val = temp.val;\n}\n}\nthis.updateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = this.rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.c
    /* \u5220\u9664\u8282\u70b9 */\n// \u7531\u4e8e\u5f15\u5165\u4e86 stdio.h \uff0c\u6b64\u5904\u65e0\u6cd5\u4f7f\u7528 remove \u5173\u952e\u8bcd\nvoid removeNode(aVLTree *tree, int val) {\nTreeNode *root = removeHelper(tree->root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nTreeNode *removeHelper(TreeNode *node, int val) {\nTreeNode *child, *grandChild;\nif (node == NULL) {\nreturn NULL;\n}\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node->val) {\nnode->left = removeHelper(node->left, val);\n} else if (val > node->val) {\nnode->right = removeHelper(node->right, val);\n} else {\nif (node->left == NULL || node->right == NULL) {\nchild = node->left;\nif (node->right != NULL) {\nchild = node->right;\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == NULL) {\nreturn NULL;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nnode = child;\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nTreeNode *temp = node->right;\nwhile (temp->left != NULL) {\ntemp = temp->left;\n}\nint tempVal = temp->val;\nnode->right = removeHelper(node->right, temp->val);\nnode->val = tempVal;\n}\n}\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.cs
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\nroot = removeHelper(root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? removeHelper(TreeNode? node, int val) {\nif (node == null) return null;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node.val)\nnode.left = removeHelper(node.left, val);\nelse if (val > node.val)\nnode.right = removeHelper(node.right, val);\nelse {\nif (node.left == null || node.right == null) {\nTreeNode? child = node.left != null ? node.left : node.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == null)\nreturn null;\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse\nnode = child;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nTreeNode? temp = node.right;\nwhile (temp.left != null) {\ntemp = temp.left;\n}\nnode.right = removeHelper(node.right, temp.val);\nnode.val = temp.val;\n}\n}\nupdateHeight(node);  // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.swift
    /* \u5220\u9664\u8282\u70b9 */\n@discardableResult\nfunc remove(val: Int) {\nroot = removeHelper(node: root, val: val)\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfunc removeHelper(node: TreeNode?, val: Int) -> TreeNode? {\nvar node = node\nif node == nil {\nreturn nil\n}\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif val < node!.val {\nnode?.left = removeHelper(node: node?.left, val: val)\n} else if val > node!.val {\nnode?.right = removeHelper(node: node?.right, val: val)\n} else {\nif node?.left == nil || node?.right == nil {\nlet child = node?.left != nil ? node?.left : node?.right\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif child == nil {\nreturn nil\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse {\nnode = child\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nvar temp = node?.right\nwhile temp?.left != nil {\ntemp = temp?.left\n}\nnode?.right = removeHelper(node: node?.right, val: temp!.val)\nnode?.val = temp!.val\n}\n}\nupdateHeight(node: node) // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node: node)\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node\n}\n
    avl_tree.zig
    // \u5220\u9664\u8282\u70b9\nfn remove(self: *Self, val: T) void {\nself.root = self.removeHelper(self.root, val).?;\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\nfn removeHelper(self: *Self, node_: ?*inc.TreeNode(T), val: T) ?*inc.TreeNode(T) {\nvar node = node_;\nif (node == null) return null;\n// 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b\nif (val < node.?.val) {\nnode.?.left = self.removeHelper(node.?.left, val);\n} else if (val > node.?.val) {\nnode.?.right = self.removeHelper(node.?.right, val);\n} else {\nif (node.?.left == null or node.?.right == null) {\nvar child = if (node.?.left != null) node.?.left else node.?.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == null) {\nreturn null;\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n} else {\nnode = child;\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nvar temp = node.?.right;\nwhile (temp.?.left != null) {\ntemp = temp.?.left;\n}\nnode.?.right = self.removeHelper(node.?.right, temp.?.val);\nnode.?.val = temp.?.val;\n}\n}\nself.updateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n// 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\nnode = self.rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.dart
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\nroot = removeHelper(root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? removeHelper(TreeNode? node, int val) {\nif (node == null) return null;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node.val)\nnode.left = removeHelper(node.left, val);\nelse if (val > node.val)\nnode.right = removeHelper(node.right, val);\nelse {\nif (node.left == null || node.right == null) {\nTreeNode? child = node.left ?? node.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == null)\nreturn null;\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse\nnode = child;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nTreeNode? temp = node.right;\nwhile (temp!.left != null) {\ntemp = temp.left;\n}\nnode.right = removeHelper(node.right, temp.val);\nnode.val = temp.val;\n}\n}\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#_10","title":"\u67e5\u627e\u8282\u70b9","text":"

    AVL \u6811\u7684\u8282\u70b9\u67e5\u627e\u64cd\u4f5c\u4e0e\u4e8c\u53c9\u641c\u7d22\u6811\u4e00\u81f4\uff0c\u5728\u6b64\u4e0d\u518d\u8d58\u8ff0\u3002

    "},{"location":"chapter_tree/avl_tree/#754-avl","title":"7.5.4. \u00a0 AVL \u6811\u5178\u578b\u5e94\u7528","text":"
    • \u7ec4\u7ec7\u548c\u5b58\u50a8\u5927\u578b\u6570\u636e\uff0c\u9002\u7528\u4e8e\u9ad8\u9891\u67e5\u627e\u3001\u4f4e\u9891\u589e\u5220\u7684\u573a\u666f\uff1b
    • \u7528\u4e8e\u6784\u5efa\u6570\u636e\u5e93\u4e2d\u7684\u7d22\u5f15\u7cfb\u7edf\uff1b

    \u4e3a\u4ec0\u4e48\u7ea2\u9ed1\u6811\u6bd4 AVL \u6811\u66f4\u53d7\u6b22\u8fce\uff1f

    \u7ea2\u9ed1\u6811\u7684\u5e73\u8861\u6761\u4ef6\u76f8\u5bf9\u5bbd\u677e\uff0c\u56e0\u6b64\u5728\u7ea2\u9ed1\u6811\u4e2d\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u6240\u9700\u7684\u65cb\u8f6c\u64cd\u4f5c\u76f8\u5bf9\u8f83\u5c11\uff0c\u5728\u8282\u70b9\u589e\u5220\u64cd\u4f5c\u4e0a\u7684\u5e73\u5747\u6548\u7387\u9ad8\u4e8e AVL \u6811\u3002

    "},{"location":"chapter_tree/binary_search_tree/","title":"7.4. \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811","text":"

    \u300c\u4e8c\u53c9\u641c\u7d22\u6811 Binary Search Tree\u300d\u6ee1\u8db3\u4ee5\u4e0b\u6761\u4ef6\uff1a

    1. \u5bf9\u4e8e\u6839\u8282\u70b9\uff0c\u5de6\u5b50\u6811\u4e2d\u6240\u6709\u8282\u70b9\u7684\u503c \\(<\\) \u6839\u8282\u70b9\u7684\u503c \\(<\\) \u53f3\u5b50\u6811\u4e2d\u6240\u6709\u8282\u70b9\u7684\u503c\uff1b
    2. \u4efb\u610f\u8282\u70b9\u7684\u5de6\u3001\u53f3\u5b50\u6811\u4e5f\u662f\u4e8c\u53c9\u641c\u7d22\u6811\uff0c\u5373\u540c\u6837\u6ee1\u8db3\u6761\u4ef6 1. \uff1b

    Fig. \u4e8c\u53c9\u641c\u7d22\u6811

    "},{"location":"chapter_tree/binary_search_tree/#741","title":"7.4.1. \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u64cd\u4f5c","text":""},{"location":"chapter_tree/binary_search_tree/#_1","title":"\u67e5\u627e\u8282\u70b9","text":"

    \u7ed9\u5b9a\u76ee\u6807\u8282\u70b9\u503c num \uff0c\u53ef\u4ee5\u6839\u636e\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u6027\u8d28\u6765\u67e5\u627e\u3002\u6211\u4eec\u58f0\u660e\u4e00\u4e2a\u8282\u70b9 cur \uff0c\u4ece\u4e8c\u53c9\u6811\u7684\u6839\u8282\u70b9 root \u51fa\u53d1\uff0c\u5faa\u73af\u6bd4\u8f83\u8282\u70b9\u503c cur.val \u548c num \u4e4b\u95f4\u7684\u5927\u5c0f\u5173\u7cfb

    • \u82e5 cur.val < num \uff0c\u8bf4\u660e\u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\uff0c\u56e0\u6b64\u6267\u884c cur = cur.right \uff1b
    • \u82e5 cur.val > num \uff0c\u8bf4\u660e\u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\uff0c\u56e0\u6b64\u6267\u884c cur = cur.left \uff1b
    • \u82e5 cur.val = num \uff0c\u8bf4\u660e\u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\u5e76\u8fd4\u56de\u8be5\u8282\u70b9\uff1b
    <1><2><3><4>

    \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u67e5\u627e\u64cd\u4f5c\u4e0e\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u7684\u5de5\u4f5c\u539f\u7406\u4e00\u81f4\uff0c\u90fd\u662f\u6bcf\u8f6e\u6392\u9664\u4e00\u534a\u60c5\u51b5\u3002\u5faa\u73af\u6b21\u6570\u6700\u591a\u4e3a\u4e8c\u53c9\u6811\u7684\u9ad8\u5ea6\uff0c\u5f53\u4e8c\u53c9\u6811\u5e73\u8861\u65f6\uff0c\u4f7f\u7528 \\(O(\\log n)\\) \u65f6\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search_tree.java
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode search(int num) {\nTreeNode cur = root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num)\ncur = cur.right;\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse if (cur.val > num)\ncur = cur.left;\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse\nbreak;\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.cpp
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode *search(int num) {\nTreeNode *cur = root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != nullptr) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur->val < num)\ncur = cur->right;\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse if (cur->val > num)\ncur = cur->left;\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse\nbreak;\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.py
    def search(self, num: int) -> TreeNode | None:\n\"\"\"\u67e5\u627e\u8282\u70b9\"\"\"\ncur: TreeNode | None = self.root\n# \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile cur is not None:\n# \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur.val < num:\ncur = cur.right\n# \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelif cur.val > num:\ncur = cur.left\n# \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse:\nbreak\nreturn cur\n
    binary_search_tree.go
    /* \u67e5\u627e\u8282\u70b9 */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\nnode := bst.root\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nfor node != nil {\nif node.Val < num {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nnode = node.Right\n} else if node.Val > num {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nnode = node.Left\n} else {\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nbreak\n}\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn node\n}\n
    binary_search_tree.js
    /* \u67e5\u627e\u8282\u70b9 */\nfunction search(num) {\nlet cur = root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num) cur = cur.right;\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse if (cur.val > num) cur = cur.left;\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse break;\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.ts
    /* \u67e5\u627e\u8282\u70b9 */\nfunction search(num: number): TreeNode | null {\nlet cur = root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\nif (cur.val < num) {\ncur = cur.right; // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n} else if (cur.val > num) {\ncur = cur.left; // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n} else {\nbreak; // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n}\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.c
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode *search(binarySearchTree *bst, int num) {\nTreeNode *cur = bst->root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != NULL) {\nif (cur->val < num) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\ncur = cur->right;\n} else if (cur->val > num) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\ncur = cur->left;\n} else {\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nbreak;\n}\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.cs
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode? search(int num) {\nTreeNode? cur = root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num) cur =\ncur.right;\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse if (cur.val > num)\ncur = cur.left;\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse\nbreak;\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.swift
    /* \u67e5\u627e\u8282\u70b9 */\nfunc search(num: Int) -> TreeNode? {\nvar cur = root\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile cur != nil {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur!.val < num {\ncur = cur?.right\n}\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse if cur!.val > num {\ncur = cur?.left\n}\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse {\nbreak\n}\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur\n}\n
    binary_search_tree.zig
    // \u67e5\u627e\u8282\u70b9\nfn search(self: *Self, num: T) ?*inc.TreeNode(T) {\nvar cur = self.root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.?.val < num) {\ncur = cur.?.right;\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n} else if (cur.?.val > num) {\ncur = cur.?.left;\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n} else {\nbreak;\n}\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.dart
    [class]{BinarySearchTree}-[func]{search}\n
    "},{"location":"chapter_tree/binary_search_tree/#_2","title":"\u63d2\u5165\u8282\u70b9","text":"

    \u7ed9\u5b9a\u4e00\u4e2a\u5f85\u63d2\u5165\u5143\u7d20 num \uff0c\u4e3a\u4e86\u4fdd\u6301\u4e8c\u53c9\u641c\u7d22\u6811\u201c\u5de6\u5b50\u6811 < \u6839\u8282\u70b9 < \u53f3\u5b50\u6811\u201d\u7684\u6027\u8d28\uff0c\u63d2\u5165\u64cd\u4f5c\u5206\u4e3a\u4e24\u6b65\uff1a

    1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff1a\u4e0e\u67e5\u627e\u64cd\u4f5c\u76f8\u4f3c\uff0c\u4ece\u6839\u8282\u70b9\u51fa\u53d1\uff0c\u6839\u636e\u5f53\u524d\u8282\u70b9\u503c\u548c num \u7684\u5927\u5c0f\u5173\u7cfb\u5faa\u73af\u5411\u4e0b\u641c\u7d22\uff0c\u76f4\u5230\u8d8a\u8fc7\u53f6\u8282\u70b9\uff08\u904d\u5386\u81f3 \\(\\text{None}\\) \uff09\u65f6\u8df3\u51fa\u5faa\u73af\uff1b
    2. \u5728\u8be5\u4f4d\u7f6e\u63d2\u5165\u8282\u70b9\uff1a\u521d\u59cb\u5316\u8282\u70b9 num \uff0c\u5c06\u8be5\u8282\u70b9\u7f6e\u4e8e \\(\\text{None}\\) \u7684\u4f4d\u7f6e\uff1b

    \u4e8c\u53c9\u641c\u7d22\u6811\u4e0d\u5141\u8bb8\u5b58\u5728\u91cd\u590d\u8282\u70b9\uff0c\u5426\u5219\u5c06\u8fdd\u53cd\u5176\u5b9a\u4e49\u3002\u56e0\u6b64\uff0c\u82e5\u5f85\u63d2\u5165\u8282\u70b9\u5728\u6811\u4e2d\u5df2\u5b58\u5728\uff0c\u5219\u4e0d\u6267\u884c\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\u3002

    Fig. \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u63d2\u5165\u8282\u70b9

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search_tree.java
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == null)\nreturn;\nTreeNode cur = root, pre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur.val == num)\nreturn;\npre = cur;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num)\ncur = cur.right;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur.left;\n}\n// \u63d2\u5165\u8282\u70b9\nTreeNode node = new TreeNode(num);\nif (pre.val < num)\npre.right = node;\nelse\npre.left = node;\n}\n
    binary_search_tree.cpp
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == nullptr)\nreturn;\nTreeNode *cur = root, *pre = nullptr;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != nullptr) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur->val == num)\nreturn;\npre = cur;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur->val < num)\ncur = cur->right;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur->left;\n}\n// \u63d2\u5165\u8282\u70b9\nTreeNode *node = new TreeNode(num);\nif (pre->val < num)\npre->right = node;\nelse\npre->left = node;\n}\n
    binary_search_tree.py
    def insert(self, num: int) -> None:\n\"\"\"\u63d2\u5165\u8282\u70b9\"\"\"\n# \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif self.root is None:\nreturn\n# \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\ncur, pre = self.root, None\nwhile cur is not None:\n# \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif cur.val == num:\nreturn\npre = cur\n# \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur.val < num:\ncur = cur.right\n# \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse:\ncur = cur.left\n# \u63d2\u5165\u8282\u70b9\nnode = TreeNode(num)\nif pre.val < num:\npre.right = node\nelse:\npre.left = node\n
    binary_search_tree.go
    /* \u63d2\u5165\u8282\u70b9 */\nfunc (bst *binarySearchTree) insert(num int) {\ncur := bst.root\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif cur == nil {\nreturn\n}\n// \u5f85\u63d2\u5165\u8282\u70b9\u4e4b\u524d\u7684\u8282\u70b9\u4f4d\u7f6e\nvar pre *TreeNode = nil\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nfor cur != nil {\nif cur.Val == num {\nreturn\n}\npre = cur\nif cur.Val < num {\ncur = cur.Right\n} else {\ncur = cur.Left\n}\n}\n// \u63d2\u5165\u8282\u70b9\nnode := NewTreeNode(num)\nif pre.Val < num {\npre.Right = node\n} else {\npre.Left = node\n}\n}\n
    binary_search_tree.js
    /* \u63d2\u5165\u8282\u70b9 */\nfunction insert(num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root === null) return;\nlet cur = root,\npre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur.val === num) return;\npre = cur;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num) cur = cur.right;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse cur = cur.left;\n}\n// \u63d2\u5165\u8282\u70b9\nlet node = new TreeNode(num);\nif (pre.val < num) pre.right = node;\nelse pre.left = node;\n}\n
    binary_search_tree.ts
    /* \u63d2\u5165\u8282\u70b9 */\nfunction insert(num: number): void {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root === null) {\nreturn;\n}\nlet cur = root,\npre: TreeNode | null = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\nif (cur.val === num) {\nreturn; // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n}\npre = cur;\nif (cur.val < num) {\ncur = cur.right as TreeNode; // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n} else {\ncur = cur.left as TreeNode; // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n}\n}\n// \u63d2\u5165\u8282\u70b9\nlet node = new TreeNode(num);\nif (pre!.val < num) {\npre!.right = node;\n} else {\npre!.left = node;\n}\n}\n
    binary_search_tree.c
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(binarySearchTree *bst, int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (bst->root == NULL)\nreturn;\nTreeNode *cur = bst->root, *pre = NULL;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != NULL) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur->val == num) {\nreturn;\n}\npre = cur;\nif (cur->val < num) {\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\ncur = cur->right;\n} else {\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\ncur = cur->left;\n}\n}\n// \u63d2\u5165\u8282\u70b9\nTreeNode *node = newTreeNode(num);\nif (pre->val < num) {\npre->right = node;\n} else {\npre->left = node;\n}\n}\n
    binary_search_tree.cs
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == null)\nreturn;\nTreeNode? cur = root, pre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur.val == num)\nreturn;\npre = cur;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num)\ncur = cur.right;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur.left;\n}\n// \u63d2\u5165\u8282\u70b9\nTreeNode node = new TreeNode(num);\nif (pre != null) {\nif (pre.val < num)\npre.right = node;\nelse\npre.left = node;\n}\n}\n
    binary_search_tree.swift
    /* \u63d2\u5165\u8282\u70b9 */\nfunc insert(num: Int) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif root == nil {\nreturn\n}\nvar cur = root\nvar pre: TreeNode?\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile cur != nil {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif cur!.val == num {\nreturn\n}\npre = cur\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur!.val < num {\ncur = cur?.right\n}\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse {\ncur = cur?.left\n}\n}\n// \u63d2\u5165\u8282\u70b9\nlet node = TreeNode(x: num)\nif pre!.val < num {\npre?.right = node\n} else {\npre?.left = node\n}\n}\n
    binary_search_tree.zig
    // \u63d2\u5165\u8282\u70b9\nfn insert(self: *Self, num: T) !void {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (self.root == null) return;\nvar cur = self.root;\nvar pre: ?*inc.TreeNode(T) = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur.?.val == num) return;\npre = cur;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.?.val < num) {\ncur = cur.?.right;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n} else {\ncur = cur.?.left;\n}\n}\n// \u63d2\u5165\u8282\u70b9\nvar node = try self.mem_allocator.create(inc.TreeNode(T));\nnode.init(num);\nif (pre.?.val < num) {\npre.?.right = node;\n} else {\npre.?.left = node;\n}\n}\n
    binary_search_tree.dart
    [class]{BinarySearchTree}-[func]{insert}\n

    \u4e3a\u4e86\u63d2\u5165\u8282\u70b9\uff0c\u6211\u4eec\u9700\u8981\u5229\u7528\u8f85\u52a9\u8282\u70b9 pre \u4fdd\u5b58\u4e0a\u4e00\u8f6e\u5faa\u73af\u7684\u8282\u70b9\uff0c\u8fd9\u6837\u5728\u904d\u5386\u81f3 \\(\\text{None}\\) \u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u83b7\u53d6\u5230\u5176\u7236\u8282\u70b9\uff0c\u4ece\u800c\u5b8c\u6210\u8282\u70b9\u63d2\u5165\u64cd\u4f5c\u3002

    \u4e0e\u67e5\u627e\u8282\u70b9\u76f8\u540c\uff0c\u63d2\u5165\u8282\u70b9\u4f7f\u7528 \\(O(\\log n)\\) \u65f6\u95f4\u3002

    "},{"location":"chapter_tree/binary_search_tree/#_3","title":"\u5220\u9664\u8282\u70b9","text":"

    \u4e0e\u63d2\u5165\u8282\u70b9\u7c7b\u4f3c\uff0c\u6211\u4eec\u9700\u8981\u5728\u5220\u9664\u64cd\u4f5c\u540e\u7ef4\u6301\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u201c\u5de6\u5b50\u6811 < \u6839\u8282\u70b9 < \u53f3\u5b50\u6811\u201d\u7684\u6027\u8d28\u3002\u9996\u5148\uff0c\u6211\u4eec\u9700\u8981\u5728\u4e8c\u53c9\u6811\u4e2d\u6267\u884c\u67e5\u627e\u64cd\u4f5c\uff0c\u83b7\u53d6\u5f85\u5220\u9664\u8282\u70b9\u3002\u63a5\u4e0b\u6765\uff0c\u6839\u636e\u5f85\u5220\u9664\u8282\u70b9\u7684\u5b50\u8282\u70b9\u6570\u91cf\uff0c\u5220\u9664\u64cd\u4f5c\u9700\u5206\u4e3a\u4e09\u79cd\u60c5\u51b5\uff1a

    \u5f53\u5f85\u5220\u9664\u8282\u70b9\u7684\u5ea6\u4e3a \\(0\\) \u65f6\uff0c\u8868\u793a\u5f85\u5220\u9664\u8282\u70b9\u662f\u53f6\u8282\u70b9\uff0c\u53ef\u4ee5\u76f4\u63a5\u5220\u9664\u3002

    Fig. \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u5220\u9664\u8282\u70b9\uff08\u5ea6\u4e3a 0\uff09

    \u5f53\u5f85\u5220\u9664\u8282\u70b9\u7684\u5ea6\u4e3a \\(1\\) \u65f6\uff0c\u5c06\u5f85\u5220\u9664\u8282\u70b9\u66ff\u6362\u4e3a\u5176\u5b50\u8282\u70b9\u5373\u53ef\u3002

    Fig. \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u5220\u9664\u8282\u70b9\uff08\u5ea6\u4e3a 1\uff09

    \u5f53\u5f85\u5220\u9664\u8282\u70b9\u7684\u5ea6\u4e3a \\(2\\) \u65f6\uff0c\u6211\u4eec\u65e0\u6cd5\u76f4\u63a5\u5220\u9664\u5b83\uff0c\u800c\u9700\u8981\u4f7f\u7528\u4e00\u4e2a\u8282\u70b9\u66ff\u6362\u8be5\u8282\u70b9\u3002\u7531\u4e8e\u8981\u4fdd\u6301\u4e8c\u53c9\u641c\u7d22\u6811\u201c\u5de6 \\(<\\) \u6839 \\(<\\) \u53f3\u201d\u7684\u6027\u8d28\uff0c\u56e0\u6b64\u8fd9\u4e2a\u8282\u70b9\u53ef\u4ee5\u662f\u53f3\u5b50\u6811\u7684\u6700\u5c0f\u8282\u70b9\u6216\u5de6\u5b50\u6811\u7684\u6700\u5927\u8282\u70b9\u3002\u5047\u8bbe\u6211\u4eec\u9009\u62e9\u53f3\u5b50\u6811\u7684\u6700\u5c0f\u8282\u70b9\uff08\u6216\u8005\u79f0\u4e3a\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\uff09\uff0c\u5219\u5220\u9664\u64cd\u4f5c\u4e3a\uff1a

    1. \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\u5728\u201c\u4e2d\u5e8f\u904d\u5386\u5e8f\u5217\u201d\u4e2d\u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\uff0c\u8bb0\u4e3a tmp \uff1b
    2. \u5c06 tmp \u7684\u503c\u8986\u76d6\u5f85\u5220\u9664\u8282\u70b9\u7684\u503c\uff0c\u5e76\u5728\u6811\u4e2d\u9012\u5f52\u5220\u9664\u8282\u70b9 tmp \uff1b
    <1><2><3><4>

    \u5220\u9664\u8282\u70b9\u64cd\u4f5c\u540c\u6837\u4f7f\u7528 \\(O(\\log n)\\) \u65f6\u95f4\uff0c\u5176\u4e2d\u67e5\u627e\u5f85\u5220\u9664\u8282\u70b9\u9700\u8981 \\(O(\\log n)\\) \u65f6\u95f4\uff0c\u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u540e\u7ee7\u8282\u70b9\u9700\u8981 \\(O(\\log n)\\) \u65f6\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search_tree.java
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == null)\nreturn;\nTreeNode cur = root, pre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur.val == num)\nbreak;\npre = cur;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num)\ncur = cur.right;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur.left;\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur == null)\nreturn;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur.left == null || cur.right == null) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nTreeNode child = cur.left != null ? cur.left : cur.right;\n// \u5220\u9664\u8282\u70b9 cur\nif (cur != root) {\nif (pre.left == cur)\npre.left = child;\nelse\npre.right = child;\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child;\n}\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nTreeNode tmp = cur.right;\nwhile (tmp.left != null) {\ntmp = tmp.left;\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(tmp.val);\n// \u7528 tmp \u8986\u76d6 cur\ncur.val = tmp.val;\n}\n}\n
    binary_search_tree.cpp
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == nullptr)\nreturn;\nTreeNode *cur = root, *pre = nullptr;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != nullptr) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur->val == num)\nbreak;\npre = cur;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur->val < num)\ncur = cur->right;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur->left;\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur == nullptr)\nreturn;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur->left == nullptr || cur->right == nullptr) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = nullptr / \u8be5\u5b50\u8282\u70b9\nTreeNode *child = cur->left != nullptr ? cur->left : cur->right;\n// \u5220\u9664\u8282\u70b9 cur\nif (cur != root) {\nif (pre->left == cur)\npre->left = child;\nelse\npre->right = child;\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child;\n}\n// \u91ca\u653e\u5185\u5b58\ndelete cur;\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nTreeNode *tmp = cur->right;\nwhile (tmp->left != nullptr) {\ntmp = tmp->left;\n}\nint tmpVal = tmp->val;\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(tmp->val);\n// \u7528 tmp \u8986\u76d6 cur\ncur->val = tmpVal;\n}\n}\n
    binary_search_tree.py
    def remove(self, num: int) -> None:\n\"\"\"\u5220\u9664\u8282\u70b9\"\"\"\n# \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif self.root is None:\nreturn\n# \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\ncur, pre = self.root, None\nwhile cur is not None:\n# \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif cur.val == num:\nbreak\npre = cur\n# \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur.val < num:\ncur = cur.right\n# \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse:\ncur = cur.left\n# \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif cur is None:\nreturn\n# \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif cur.left is None or cur.right is None:\n# \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nchild = cur.left or cur.right\n# \u5220\u9664\u8282\u70b9 cur\nif cur != self.root:\nif pre.left == cur:\npre.left = child\nelse:\npre.right = child\nelse:\n# \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nself.root = child\n# \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse:\n# \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\ntmp: TreeNode = cur.right\nwhile tmp.left is not None:\ntmp = tmp.left\n# \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nself.remove(tmp.val)\n# \u7528 tmp \u8986\u76d6 cur\ncur.val = tmp.val\n
    binary_search_tree.go
    /* \u5220\u9664\u8282\u70b9 */\nfunc (bst *binarySearchTree) remove(num int) {\ncur := bst.root\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif cur == nil {\nreturn\n}\n// \u5f85\u5220\u9664\u8282\u70b9\u4e4b\u524d\u7684\u8282\u70b9\u4f4d\u7f6e\nvar pre *TreeNode = nil\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nfor cur != nil {\nif cur.Val == num {\nbreak\n}\npre = cur\nif cur.Val < num {\n// \u5f85\u5220\u9664\u8282\u70b9\u5728\u53f3\u5b50\u6811\u4e2d\ncur = cur.Right\n} else {\n// \u5f85\u5220\u9664\u8282\u70b9\u5728\u5de6\u5b50\u6811\u4e2d\ncur = cur.Left\n}\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif cur == nil {\nreturn\n}\n// \u5b50\u8282\u70b9\u6570\u4e3a 0 \u6216 1\nif cur.Left == nil || cur.Right == nil {\nvar child *TreeNode = nil\n// \u53d6\u51fa\u5f85\u5220\u9664\u8282\u70b9\u7684\u5b50\u8282\u70b9\nif cur.Left != nil {\nchild = cur.Left\n} else {\nchild = cur.Right\n}\n// \u5220\u9664\u8282\u70b9 cur\nif cur != bst.root {\nif pre.Left == cur {\npre.Left = child\n} else {\npre.Right = child\n}\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nbst.root = child\n}\n// \u5b50\u8282\u70b9\u6570\u4e3a 2\n} else {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d\u5f85\u5220\u9664\u8282\u70b9 cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\ntmp := cur.Right\nfor tmp.Left != nil {\ntmp = tmp.Left\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nbst.remove(tmp.Val)\n// \u7528 tmp \u8986\u76d6 cur\ncur.Val = tmp.Val\n}\n}\n
    binary_search_tree.js
    /* \u5220\u9664\u8282\u70b9 */\nfunction remove(num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root === null) return;\nlet cur = root,\npre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur.val === num) break;\npre = cur;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num) cur = cur.right;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse cur = cur.left;\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur === null) return;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur.left === null || cur.right === null) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nlet child = cur.left !== null ? cur.left : cur.right;\n// \u5220\u9664\u8282\u70b9 cur\nif (cur != root) {\nif (pre.left === cur) pre.left = child;\nelse pre.right = child;\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child;\n}\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nlet tmp = cur.right;\nwhile (tmp.left !== null) {\ntmp = tmp.left;\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(tmp.val);\n// \u7528 tmp \u8986\u76d6 cur\ncur.val = tmp.val;\n}\n}\n
    binary_search_tree.ts
    /* \u5220\u9664\u8282\u70b9 */\nfunction remove(num: number): void {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root === null) {\nreturn;\n}\nlet cur = root,\npre: TreeNode | null = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur.val === num) {\nbreak;\n}\npre = cur;\nif (cur.val < num) {\ncur = cur.right as TreeNode; // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n} else {\ncur = cur.left as TreeNode; // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n}\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur === null) {\nreturn;\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur.left === null || cur.right === null) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nlet child = cur.left !== null ? cur.left : cur.right;\n// \u5220\u9664\u8282\u70b9 cur\nif (cur != root) {\nif (pre!.left === cur) {\npre!.left = child;\n} else {\npre!.right = child;\n}\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child;\n}\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nlet tmp = cur.right;\nwhile (tmp.left !== null) {\ntmp = tmp.left;\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(tmp!.val);\n// \u7528 tmp \u8986\u76d6 cur\ncur.val = tmp.val;\n}\n}\n
    binary_search_tree.c
    /* \u5220\u9664\u8282\u70b9 */\n// \u7531\u4e8e\u5f15\u5165\u4e86 stdio.h \uff0c\u6b64\u5904\u65e0\u6cd5\u4f7f\u7528 remove \u5173\u952e\u8bcd\nvoid removeNode(binarySearchTree *bst, int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (bst->root == NULL)\nreturn;\nTreeNode *cur = bst->root, *pre = NULL;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != NULL) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur->val == num)\nbreak;\npre = cur;\nif (cur->val < num) {\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 root \u7684\u53f3\u5b50\u6811\u4e2d\ncur = cur->right;\n} else {\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 root \u7684\u5de6\u5b50\u6811\u4e2d\ncur = cur->left;\n}\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur == NULL)\nreturn;\n// \u5224\u65ad\u5f85\u5220\u9664\u8282\u70b9\u662f\u5426\u5b58\u5728\u5b50\u8282\u70b9\nif (cur->left == NULL || cur->right == NULL) {\n/* \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1 */\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = nullptr / \u8be5\u5b50\u8282\u70b9\nTreeNode *child = cur->left != NULL ? cur->left : cur->right;\n// \u5220\u9664\u8282\u70b9 cur\nif (pre->left == cur) {\npre->left = child;\n} else {\npre->right = child;\n}\n} else {\n/* \u5b50\u8282\u70b9\u6570\u91cf = 2 */\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nTreeNode *tmp = cur->right;\nwhile (tmp->left != NULL) {\ntmp = tmp->left;\n}\nint tmpVal = tmp->val;\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremoveNode(bst, tmp->val);\n// \u7528 tmp \u8986\u76d6 cur\ncur->val = tmpVal;\n}\n}\n
    binary_search_tree.cs
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == null)\nreturn;\nTreeNode? cur = root, pre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur.val == num)\nbreak;\npre = cur;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num)\ncur = cur.right;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur.left;\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur == null || pre == null)\nreturn;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur.left == null || cur.right == null) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nTreeNode? child = cur.left != null ? cur.left : cur.right;\n// \u5220\u9664\u8282\u70b9 cur\nif (cur != root) {\nif (pre.left == cur)\npre.left = child;\nelse\npre.right = child;\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child;\n}\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nTreeNode? tmp = cur.right;\nwhile (tmp.left != null) {\ntmp = tmp.left;\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(tmp.val);\n// \u7528 tmp \u8986\u76d6 cur\ncur.val = tmp.val;\n}\n}\n
    binary_search_tree.swift
    /* \u5220\u9664\u8282\u70b9 */\n@discardableResult\nfunc remove(num: Int) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif root == nil {\nreturn\n}\nvar cur = root\nvar pre: TreeNode?\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile cur != nil {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif cur!.val == num {\nbreak\n}\npre = cur\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur!.val < num {\ncur = cur?.right\n}\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse {\ncur = cur?.left\n}\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif cur == nil {\nreturn\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif cur?.left == nil || cur?.right == nil {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nlet child = cur?.left != nil ? cur?.left : cur?.right\n// \u5220\u9664\u8282\u70b9 cur\nif cur !== root {\nif pre?.left === cur {\npre?.left = child\n} else {\npre?.right = child\n}\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child\n}\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nvar tmp = cur?.right\nwhile tmp?.left != nil {\ntmp = tmp?.left\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(num: tmp!.val)\n// \u7528 tmp \u8986\u76d6 cur\ncur?.val = tmp!.val\n}\n}\n
    binary_search_tree.zig
    // \u5220\u9664\u8282\u70b9\nfn remove(self: *Self, num: T) void {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (self.root == null) return;\nvar cur = self.root;\nvar pre: ?*inc.TreeNode(T) = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur.?.val == num) break;\npre = cur;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.?.val < num) {\ncur = cur.?.right;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n} else {\ncur = cur.?.left;\n}\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur == null) return;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur.?.left == null or cur.?.right == null) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nvar child = if (cur.?.left != null) cur.?.left else cur.?.right;\n// \u5220\u9664\u8282\u70b9 cur\nif (pre.?.left == cur) {\npre.?.left = child;\n} else {\npre.?.right = child;\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\n} else {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nvar tmp = cur.?.right;\nwhile (tmp.?.left != null) {\ntmp = tmp.?.left;\n}\nvar tmp_val = tmp.?.val;\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nself.remove(tmp.?.val);\n// \u7528 tmp \u8986\u76d6 cur\ncur.?.val = tmp_val;\n}\n}\n
    binary_search_tree.dart
    [class]{BinarySearchTree}-[func]{remove}\n
    "},{"location":"chapter_tree/binary_search_tree/#_4","title":"\u6392\u5e8f","text":"

    \u6211\u4eec\u77e5\u9053\uff0c\u4e8c\u53c9\u6811\u7684\u4e2d\u5e8f\u904d\u5386\u9075\u5faa\u201c\u5de6 \\(\\rightarrow\\) \u6839 \\(\\rightarrow\\) \u53f3\u201d\u7684\u904d\u5386\u987a\u5e8f\uff0c\u800c\u4e8c\u53c9\u641c\u7d22\u6811\u6ee1\u8db3\u201c\u5de6\u5b50\u8282\u70b9 \\(<\\) \u6839\u8282\u70b9 \\(<\\) \u53f3\u5b50\u8282\u70b9\u201d\u7684\u5927\u5c0f\u5173\u7cfb\u3002\u56e0\u6b64\uff0c\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u8fdb\u884c\u4e2d\u5e8f\u904d\u5386\u65f6\uff0c\u603b\u662f\u4f1a\u4f18\u5148\u904d\u5386\u4e0b\u4e00\u4e2a\u6700\u5c0f\u8282\u70b9\uff0c\u4ece\u800c\u5f97\u51fa\u4e00\u4e2a\u91cd\u8981\u6027\u8d28\uff1a\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u4e2d\u5e8f\u904d\u5386\u5e8f\u5217\u662f\u5347\u5e8f\u7684\u3002

    \u5229\u7528\u4e2d\u5e8f\u904d\u5386\u5347\u5e8f\u7684\u6027\u8d28\uff0c\u6211\u4eec\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u83b7\u53d6\u6709\u5e8f\u6570\u636e\u4ec5\u9700 \\(O(n)\\) \u65f6\u95f4\uff0c\u65e0\u9700\u989d\u5916\u6392\u5e8f\uff0c\u975e\u5e38\u9ad8\u6548\u3002

    Fig. \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u4e2d\u5e8f\u904d\u5386\u5e8f\u5217

    "},{"location":"chapter_tree/binary_search_tree/#742","title":"7.4.2. \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u6548\u7387","text":"

    \u7ed9\u5b9a\u4e00\u7ec4\u6570\u636e\uff0c\u6211\u4eec\u8003\u8651\u4f7f\u7528\u6570\u7ec4\u6216\u4e8c\u53c9\u641c\u7d22\u6811\u5b58\u50a8\u3002

    \u89c2\u5bdf\u53ef\u77e5\uff0c\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u5404\u9879\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u662f\u5bf9\u6570\u9636\uff0c\u5177\u6709\u7a33\u5b9a\u4e14\u9ad8\u6548\u7684\u6027\u80fd\u8868\u73b0\u3002\u53ea\u6709\u5728\u9ad8\u9891\u6dfb\u52a0\u3001\u4f4e\u9891\u67e5\u627e\u5220\u9664\u7684\u6570\u636e\u9002\u7528\u573a\u666f\u4e0b\uff0c\u6570\u7ec4\u6bd4\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u6548\u7387\u66f4\u9ad8\u3002

    \u65e0\u5e8f\u6570\u7ec4 \u4e8c\u53c9\u641c\u7d22\u6811 \u67e5\u627e\u5143\u7d20 \\(O(n)\\) \\(O(\\log n)\\) \u63d2\u5165\u5143\u7d20 \\(O(1)\\) \\(O(\\log n)\\) \u5220\u9664\u5143\u7d20 \\(O(n)\\) \\(O(\\log n)\\)

    \u5728\u7406\u60f3\u60c5\u51b5\u4e0b\uff0c\u4e8c\u53c9\u641c\u7d22\u6811\u662f\u201c\u5e73\u8861\u201d\u7684\uff0c\u8fd9\u6837\u5c31\u53ef\u4ee5\u5728 \\(\\log n\\) \u8f6e\u5faa\u73af\u5185\u67e5\u627e\u4efb\u610f\u8282\u70b9\u3002

    \u7136\u800c\uff0c\u5982\u679c\u6211\u4eec\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u4e0d\u65ad\u5730\u63d2\u5165\u548c\u5220\u9664\u8282\u70b9\uff0c\u53ef\u80fd\u5bfc\u81f4\u4e8c\u53c9\u6811\u9000\u5316\u4e3a\u94fe\u8868\uff0c\u8fd9\u65f6\u5404\u79cd\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e5f\u4f1a\u9000\u5316\u4e3a \\(O(n)\\) \u3002

    Fig. \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u5e73\u8861\u4e0e\u9000\u5316

    "},{"location":"chapter_tree/binary_search_tree/#743","title":"7.4.3. \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\u5e38\u89c1\u5e94\u7528","text":"
    • \u7528\u4f5c\u7cfb\u7edf\u4e2d\u7684\u591a\u7ea7\u7d22\u5f15\uff0c\u5b9e\u73b0\u9ad8\u6548\u7684\u67e5\u627e\u3001\u63d2\u5165\u3001\u5220\u9664\u64cd\u4f5c\u3002
    • \u4f5c\u4e3a\u67d0\u4e9b\u641c\u7d22\u7b97\u6cd5\u7684\u5e95\u5c42\u6570\u636e\u7ed3\u6784\u3002
    • \u7528\u4e8e\u5b58\u50a8\u6570\u636e\u6d41\uff0c\u4ee5\u4fdd\u6301\u5176\u6709\u5e8f\u72b6\u6001\u3002
    "},{"location":"chapter_tree/binary_tree/","title":"7.1. \u00a0 \u4e8c\u53c9\u6811","text":"

    \u300c\u4e8c\u53c9\u6811 Binary Tree\u300d\u662f\u4e00\u79cd\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u4ee3\u8868\u7740\u7956\u5148\u4e0e\u540e\u4ee3\u4e4b\u95f4\u7684\u6d3e\u751f\u5173\u7cfb\uff0c\u4f53\u73b0\u7740\u201c\u4e00\u5206\u4e3a\u4e8c\u201d\u7684\u5206\u6cbb\u903b\u8f91\u3002\u4e0e\u94fe\u8868\u7c7b\u4f3c\uff0c\u4e8c\u53c9\u6811\u7684\u57fa\u672c\u5355\u5143\u662f\u8282\u70b9\uff0c\u6bcf\u4e2a\u8282\u70b9\u5305\u542b\u4e00\u4e2a\u300c\u503c\u300d\u548c\u4e24\u4e2a\u300c\u6307\u9488\u300d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nint val;         // \u8282\u70b9\u503c\nTreeNode left;   // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nTreeNode right;  // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nTreeNode(int x) { val = x; }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\nint val;          // \u8282\u70b9\u503c\nTreeNode *left;   // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nTreeNode *right;  // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nTreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n
    class TreeNode:\n\"\"\"\u4e8c\u53c9\u6811\u8282\u70b9\u7c7b\"\"\"\ndef __init__(self, val: int):\nself.val: int = val                   # \u8282\u70b9\u503c\nself.left: Optional[TreeNode] = None  # \u5de6\u5b50\u8282\u70b9\u6307\u9488\nself.right: Optional[TreeNode] = None # \u53f3\u5b50\u8282\u70b9\u6307\u9488\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype TreeNode struct {\nVal   int\nLeft  *TreeNode\nRight *TreeNode\n}\n/* \u8282\u70b9\u521d\u59cb\u5316\u65b9\u6cd5 */\nfunc NewTreeNode(v int) *TreeNode {\nreturn &TreeNode{\nLeft:  nil,\nRight: nil,\nVal:   v,\n}\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nfunction TreeNode(val, left, right) {\nthis.val = (val === undefined ? 0 : val); // \u8282\u70b9\u503c\nthis.left = (left === undefined ? null : left); // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nthis.right = (right === undefined ? null : right); // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nval: number;\nleft: TreeNode | null;\nright: TreeNode | null;\nconstructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\nthis.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\nthis.left = left === undefined ? null : left; // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nthis.right = right === undefined ? null : right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n}\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\nint val;                // \u8282\u70b9\u503c\nint height;             // \u8282\u70b9\u9ad8\u5ea6\nstruct TreeNode *left;  // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nstruct TreeNode *right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n};\ntypedef struct TreeNode TreeNode;\n/* \u6784\u9020\u51fd\u6570 */\nTreeNode *newTreeNode(int val) {\nTreeNode *node;\nnode = (TreeNode *)malloc(sizeof(TreeNode));\nnode->val = val;\nnode->height = 0;\nnode->left = NULL;\nnode->right = NULL;\nreturn node;\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nint val;          // \u8282\u70b9\u503c\nTreeNode? left;   // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nTreeNode? right;  // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nTreeNode(int x) { val = x; }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nvar val: Int // \u8282\u70b9\u503c\nvar left: TreeNode? // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nvar right: TreeNode? // \u53f3\u5b50\u8282\u70b9\u6307\u9488\ninit(x: Int) {\nval = x\n}\n}\n
    \n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nint val;         // \u8282\u70b9\u503c\nTreeNode? left;  // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nTreeNode? right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nTreeNode(this.val, [this.left, this.right]);\n}\n

    \u8282\u70b9\u7684\u4e24\u4e2a\u6307\u9488\u5206\u522b\u6307\u5411\u300c\u5de6\u5b50\u8282\u70b9\u300d\u548c\u300c\u53f3\u5b50\u8282\u70b9\u300d\uff0c\u540c\u65f6\u8be5\u8282\u70b9\u88ab\u79f0\u4e3a\u8fd9\u4e24\u4e2a\u5b50\u8282\u70b9\u7684\u300c\u7236\u8282\u70b9\u300d\u3002\u5f53\u7ed9\u5b9a\u4e00\u4e2a\u4e8c\u53c9\u6811\u7684\u8282\u70b9\u65f6\uff0c\u6211\u4eec\u5c06\u8be5\u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u53ca\u5176\u4ee5\u4e0b\u8282\u70b9\u5f62\u6210\u7684\u6811\u79f0\u4e3a\u8be5\u8282\u70b9\u7684\u300c\u5de6\u5b50\u6811\u300d\uff0c\u540c\u7406\u53ef\u5f97\u300c\u53f3\u5b50\u6811\u300d\u3002

    \u5728\u4e8c\u53c9\u6811\u4e2d\uff0c\u9664\u53f6\u8282\u70b9\u5916\uff0c\u5176\u4ed6\u6240\u6709\u8282\u70b9\u90fd\u5305\u542b\u5b50\u8282\u70b9\u548c\u975e\u7a7a\u5b50\u6811\u3002\u4f8b\u5982\uff0c\u5728\u4ee5\u4e0b\u793a\u4f8b\u4e2d\uff0c\u82e5\u5c06\u201c\u8282\u70b9 2\u201d\u89c6\u4e3a\u7236\u8282\u70b9\uff0c\u5219\u5176\u5de6\u5b50\u8282\u70b9\u548c\u53f3\u5b50\u8282\u70b9\u5206\u522b\u662f\u201c\u8282\u70b9 4\u201d\u548c\u201c\u8282\u70b9 5\u201d\uff0c\u5de6\u5b50\u6811\u662f\u201c\u8282\u70b9 4 \u53ca\u5176\u4ee5\u4e0b\u8282\u70b9\u5f62\u6210\u7684\u6811\u201d\uff0c\u53f3\u5b50\u6811\u662f\u201c\u8282\u70b9 5 \u53ca\u5176\u4ee5\u4e0b\u8282\u70b9\u5f62\u6210\u7684\u6811\u201d\u3002

    Fig. \u7236\u8282\u70b9\u3001\u5b50\u8282\u70b9\u3001\u5b50\u6811

    "},{"location":"chapter_tree/binary_tree/#711","title":"7.1.1. \u00a0 \u4e8c\u53c9\u6811\u5e38\u89c1\u672f\u8bed","text":"

    \u4e8c\u53c9\u6811\u6d89\u53ca\u7684\u672f\u8bed\u8f83\u591a\uff0c\u5efa\u8bae\u5c3d\u91cf\u7406\u89e3\u5e76\u8bb0\u4f4f\u3002

    • \u300c\u6839\u8282\u70b9 Root Node\u300d\uff1a\u4f4d\u4e8e\u4e8c\u53c9\u6811\u9876\u5c42\u7684\u8282\u70b9\uff0c\u6ca1\u6709\u7236\u8282\u70b9\uff1b
    • \u300c\u53f6\u8282\u70b9 Leaf Node\u300d\uff1a\u6ca1\u6709\u5b50\u8282\u70b9\u7684\u8282\u70b9\uff0c\u5176\u4e24\u4e2a\u6307\u9488\u5747\u6307\u5411 \\(\\text{None}\\) \uff1b
    • \u8282\u70b9\u7684\u300c\u5c42 Level\u300d\uff1a\u4ece\u9876\u81f3\u5e95\u9012\u589e\uff0c\u6839\u8282\u70b9\u6240\u5728\u5c42\u4e3a 1 \uff1b
    • \u8282\u70b9\u7684\u300c\u5ea6 Degree\u300d\uff1a\u8282\u70b9\u7684\u5b50\u8282\u70b9\u7684\u6570\u91cf\u3002\u5728\u4e8c\u53c9\u6811\u4e2d\uff0c\u5ea6\u7684\u8303\u56f4\u662f 0, 1, 2 \uff1b
    • \u300c\u8fb9 Edge\u300d\uff1a\u8fde\u63a5\u4e24\u4e2a\u8282\u70b9\u7684\u7ebf\u6bb5\uff0c\u5373\u8282\u70b9\u6307\u9488\uff1b
    • \u4e8c\u53c9\u6811\u7684\u300c\u9ad8\u5ea6\u300d\uff1a\u4ece\u6839\u8282\u70b9\u5230\u6700\u8fdc\u53f6\u8282\u70b9\u6240\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\uff1b
    • \u8282\u70b9\u7684\u300c\u6df1\u5ea6 Depth\u300d \uff1a\u4ece\u6839\u8282\u70b9\u5230\u8be5\u8282\u70b9\u6240\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\uff1b
    • \u8282\u70b9\u7684\u300c\u9ad8\u5ea6 Height\u300d\uff1a\u4ece\u6700\u8fdc\u53f6\u8282\u70b9\u5230\u8be5\u8282\u70b9\u6240\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\uff1b

    Fig. \u4e8c\u53c9\u6811\u7684\u5e38\u7528\u672f\u8bed

    \u9ad8\u5ea6\u4e0e\u6df1\u5ea6\u7684\u5b9a\u4e49

    \u8bf7\u6ce8\u610f\uff0c\u6211\u4eec\u901a\u5e38\u5c06\u300c\u9ad8\u5ea6\u300d\u548c\u300c\u6df1\u5ea6\u300d\u5b9a\u4e49\u4e3a\u201c\u8d70\u8fc7\u8fb9\u7684\u6570\u91cf\u201d\uff0c\u4f46\u6709\u4e9b\u9898\u76ee\u6216\u6559\u6750\u53ef\u80fd\u4f1a\u5c06\u5176\u5b9a\u4e49\u4e3a\u201c\u8d70\u8fc7\u8282\u70b9\u7684\u6570\u91cf\u201d\u3002\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u9ad8\u5ea6\u548c\u6df1\u5ea6\u90fd\u9700\u8981\u52a0 1 \u3002

    "},{"location":"chapter_tree/binary_tree/#712","title":"7.1.2. \u00a0 \u4e8c\u53c9\u6811\u57fa\u672c\u64cd\u4f5c","text":"

    \u521d\u59cb\u5316\u4e8c\u53c9\u6811\u3002\u4e0e\u94fe\u8868\u7c7b\u4f3c\uff0c\u9996\u5148\u521d\u59cb\u5316\u8282\u70b9\uff0c\u7136\u540e\u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_tree.java
    // \u521d\u59cb\u5316\u8282\u70b9\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.cpp
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nTreeNode* n1 = new TreeNode(1);\nTreeNode* n2 = new TreeNode(2);\nTreeNode* n3 = new TreeNode(3);\nTreeNode* n4 = new TreeNode(4);\nTreeNode* n5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1->left = n2;\nn1->right = n3;\nn2->left = n4;\nn2->right = n5;\n
    binary_tree.py
    # \u521d\u59cb\u5316\u4e8c\u53c9\u6811\n# \u521d\u59cb\u5316\u8282\u70b9\nn1 = TreeNode(val=1)\nn2 = TreeNode(val=2)\nn3 = TreeNode(val=3)\nn4 = TreeNode(val=4)\nn5 = TreeNode(val=5)\n# \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n
    binary_tree.go
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nn1 := NewTreeNode(1)\nn2 := NewTreeNode(2)\nn3 := NewTreeNode(3)\nn4 := NewTreeNode(4)\nn5 := NewTreeNode(5)\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.Left = n2\nn1.Right = n3\nn2.Left = n4\nn2.Right = n5\n
    binary_tree.js
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nlet n1 = new TreeNode(1),\nn2 = new TreeNode(2),\nn3 = new TreeNode(3),\nn4 = new TreeNode(4),\nn5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.ts
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nlet n1 = new TreeNode(1),\nn2 = new TreeNode(2),\nn3 = new TreeNode(3),\nn4 = new TreeNode(4),\nn5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.c
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nTreeNode *n1 = newTreeNode(1);\nTreeNode *n2 = newTreeNode(2);\nTreeNode *n3 = newTreeNode(3);\nTreeNode *n4 = newTreeNode(4);\nTreeNode *n5 = newTreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1->left = n2;\nn1->right = n3;\nn2->left = n4;\nn2->right = n5;\n
    binary_tree.cs
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.swift
    // \u521d\u59cb\u5316\u8282\u70b9\nlet n1 = TreeNode(x: 1)\nlet n2 = TreeNode(x: 2)\nlet n3 = TreeNode(x: 3)\nlet n4 = TreeNode(x: 4)\nlet n5 = TreeNode(x: 5)\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n
    binary_tree.zig
    \n
    binary_tree.dart
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n

    \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u3002\u4e0e\u94fe\u8868\u7c7b\u4f3c\uff0c\u901a\u8fc7\u4fee\u6539\u6307\u9488\u6765\u5b9e\u73b0\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u3002

    Fig. \u5728\u4e8c\u53c9\u6811\u4e2d\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_tree.java
    TreeNode P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P;\nP.left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2;\n
    binary_tree.cpp
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nTreeNode* P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1->left = P;\nP->left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1->left = n2;\n
    binary_tree.py
    # \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\np = TreeNode(0)\n# \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = p\np.left = n2\n# \u5220\u9664\u8282\u70b9 P\nn1.left = n2\n
    binary_tree.go
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\np := NewTreeNode(0)\nn1.Left = p\np.Left = n2\n// \u5220\u9664\u8282\u70b9 P\nn1.Left = n2\n
    binary_tree.js
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nlet P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P;\nP.left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2;\n
    binary_tree.ts
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nconst P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P;\nP.left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2;\n
    binary_tree.c
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nTreeNode *P = newTreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1->left = P;\nP->left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1->left = n2;\n
    binary_tree.cs
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nTreeNode P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P;\nP.left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2;\n
    binary_tree.swift
    let P = TreeNode(x: 0)\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P\nP.left = n2\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2\n
    binary_tree.zig
    \n
    binary_tree.dart
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nTreeNode P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P;\nP.left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2;\n

    Note

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u63d2\u5165\u8282\u70b9\u53ef\u80fd\u4f1a\u6539\u53d8\u4e8c\u53c9\u6811\u7684\u539f\u6709\u903b\u8f91\u7ed3\u6784\uff0c\u800c\u5220\u9664\u8282\u70b9\u901a\u5e38\u610f\u5473\u7740\u5220\u9664\u8be5\u8282\u70b9\u53ca\u5176\u6240\u6709\u5b50\u6811\u3002\u56e0\u6b64\uff0c\u5728\u4e8c\u53c9\u6811\u4e2d\uff0c\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u901a\u5e38\u662f\u7531\u4e00\u5957\u64cd\u4f5c\u914d\u5408\u5b8c\u6210\u7684\uff0c\u4ee5\u5b9e\u73b0\u6709\u5b9e\u9645\u610f\u4e49\u7684\u64cd\u4f5c\u3002

    "},{"location":"chapter_tree/binary_tree/#713","title":"7.1.3. \u00a0 \u5e38\u89c1\u4e8c\u53c9\u6811\u7c7b\u578b","text":""},{"location":"chapter_tree/binary_tree/#_1","title":"\u5b8c\u7f8e\u4e8c\u53c9\u6811","text":"

    \u300c\u5b8c\u7f8e\u4e8c\u53c9\u6811 Perfect Binary Tree\u300d\u9664\u4e86\u6700\u5e95\u5c42\u5916\uff0c\u5176\u4f59\u6240\u6709\u5c42\u7684\u8282\u70b9\u90fd\u88ab\u5b8c\u5168\u586b\u6ee1\u3002\u5728\u5b8c\u7f8e\u4e8c\u53c9\u6811\u4e2d\uff0c\u53f6\u8282\u70b9\u7684\u5ea6\u4e3a \\(0\\) \uff0c\u5176\u4f59\u6240\u6709\u8282\u70b9\u7684\u5ea6\u90fd\u4e3a \\(2\\) \uff1b\u82e5\u6811\u9ad8\u5ea6\u4e3a \\(h\\) \uff0c\u5219\u8282\u70b9\u603b\u6570\u4e3a \\(2^{h+1} - 1\\) \uff0c\u5448\u73b0\u6807\u51c6\u7684\u6307\u6570\u7ea7\u5173\u7cfb\uff0c\u53cd\u6620\u4e86\u81ea\u7136\u754c\u4e2d\u5e38\u89c1\u7684\u7ec6\u80de\u5206\u88c2\u73b0\u8c61\u3002

    Tip

    \u5728\u4e2d\u6587\u793e\u533a\u4e2d\uff0c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u5e38\u88ab\u79f0\u4e3a\u300c\u6ee1\u4e8c\u53c9\u6811\u300d\uff0c\u8bf7\u6ce8\u610f\u533a\u5206\u3002

    Fig. \u5b8c\u7f8e\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#_2","title":"\u5b8c\u5168\u4e8c\u53c9\u6811","text":"

    \u300c\u5b8c\u5168\u4e8c\u53c9\u6811 Complete Binary Tree\u300d\u53ea\u6709\u6700\u5e95\u5c42\u7684\u8282\u70b9\u672a\u88ab\u586b\u6ee1\uff0c\u4e14\u6700\u5e95\u5c42\u8282\u70b9\u5c3d\u91cf\u9760\u5de6\u586b\u5145\u3002

    Fig. \u5b8c\u5168\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#_3","title":"\u5b8c\u6ee1\u4e8c\u53c9\u6811","text":"

    \u300c\u5b8c\u6ee1\u4e8c\u53c9\u6811 Full Binary Tree\u300d\u9664\u4e86\u53f6\u8282\u70b9\u4e4b\u5916\uff0c\u5176\u4f59\u6240\u6709\u8282\u70b9\u90fd\u6709\u4e24\u4e2a\u5b50\u8282\u70b9\u3002

    Fig. \u5b8c\u6ee1\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#_4","title":"\u5e73\u8861\u4e8c\u53c9\u6811","text":"

    \u300c\u5e73\u8861\u4e8c\u53c9\u6811 Balanced Binary Tree\u300d\u4e2d\u4efb\u610f\u8282\u70b9\u7684\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\u7684\u9ad8\u5ea6\u4e4b\u5dee\u7684\u7edd\u5bf9\u503c\u4e0d\u8d85\u8fc7 1 \u3002

    Fig. \u5e73\u8861\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#714","title":"7.1.4. \u00a0 \u4e8c\u53c9\u6811\u7684\u9000\u5316","text":"

    \u5f53\u4e8c\u53c9\u6811\u7684\u6bcf\u5c42\u8282\u70b9\u90fd\u88ab\u586b\u6ee1\u65f6\uff0c\u8fbe\u5230\u300c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u300d\uff1b\u800c\u5f53\u6240\u6709\u8282\u70b9\u90fd\u504f\u5411\u4e00\u4fa7\u65f6\uff0c\u4e8c\u53c9\u6811\u9000\u5316\u4e3a\u300c\u94fe\u8868\u300d\u3002

    • \u5b8c\u7f8e\u4e8c\u53c9\u6811\u662f\u7406\u60f3\u60c5\u51b5\uff0c\u53ef\u4ee5\u5145\u5206\u53d1\u6325\u4e8c\u53c9\u6811\u201c\u5206\u6cbb\u201d\u7684\u4f18\u52bf\uff1b
    • \u94fe\u8868\u5219\u662f\u53e6\u4e00\u4e2a\u6781\u7aef\uff0c\u5404\u9879\u64cd\u4f5c\u90fd\u53d8\u4e3a\u7ebf\u6027\u64cd\u4f5c\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u9000\u5316\u81f3 \\(O(n)\\) \uff1b

    Fig. \u4e8c\u53c9\u6811\u7684\u6700\u4f73\u4e0e\u6700\u5dee\u7ed3\u6784

    \u5982\u4e0b\u8868\u6240\u793a\uff0c\u5728\u6700\u4f73\u548c\u6700\u5dee\u7ed3\u6784\u4e0b\uff0c\u4e8c\u53c9\u6811\u7684\u53f6\u8282\u70b9\u6570\u91cf\u3001\u8282\u70b9\u603b\u6570\u3001\u9ad8\u5ea6\u7b49\u8fbe\u5230\u6781\u5927\u6216\u6781\u5c0f\u503c\u3002

    \u5b8c\u7f8e\u4e8c\u53c9\u6811 \u94fe\u8868 \u7b2c \\(i\\) \u5c42\u7684\u8282\u70b9\u6570\u91cf \\(2^{i-1}\\) \\(1\\) \u6811\u7684\u9ad8\u5ea6\u4e3a \\(h\\) \u65f6\u7684\u53f6\u8282\u70b9\u6570\u91cf \\(2^h\\) \\(1\\) \u6811\u7684\u9ad8\u5ea6\u4e3a \\(h\\) \u65f6\u7684\u8282\u70b9\u603b\u6570 \\(2^{h+1} - 1\\) \\(h + 1\\) \u6811\u7684\u8282\u70b9\u603b\u6570\u4e3a \\(n\\) \u65f6\u7684\u9ad8\u5ea6 \\(\\log_2 (n+1) - 1\\) \\(n - 1\\)"},{"location":"chapter_tree/binary_tree_traversal/","title":"7.2. \u00a0 \u4e8c\u53c9\u6811\u904d\u5386","text":"

    \u4ece\u7269\u7406\u7ed3\u6784\u7684\u89d2\u5ea6\u6765\u770b\uff0c\u6811\u662f\u4e00\u79cd\u57fa\u4e8e\u94fe\u8868\u7684\u6570\u636e\u7ed3\u6784\uff0c\u56e0\u6b64\u5176\u904d\u5386\u65b9\u5f0f\u662f\u901a\u8fc7\u6307\u9488\u9010\u4e2a\u8bbf\u95ee\u8282\u70b9\u3002\u7136\u800c\uff0c\u6811\u662f\u4e00\u79cd\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u8fd9\u4f7f\u5f97\u904d\u5386\u6811\u6bd4\u904d\u5386\u94fe\u8868\u66f4\u52a0\u590d\u6742\uff0c\u9700\u8981\u501f\u52a9\u641c\u7d22\u7b97\u6cd5\u6765\u5b9e\u73b0\u3002

    \u4e8c\u53c9\u6811\u5e38\u89c1\u7684\u904d\u5386\u65b9\u5f0f\u5305\u62ec\u5c42\u5e8f\u904d\u5386\u3001\u524d\u5e8f\u904d\u5386\u3001\u4e2d\u5e8f\u904d\u5386\u548c\u540e\u5e8f\u904d\u5386\u7b49\u3002

    "},{"location":"chapter_tree/binary_tree_traversal/#721","title":"7.2.1. \u00a0 \u5c42\u5e8f\u904d\u5386","text":"

    \u300c\u5c42\u5e8f\u904d\u5386 Level-Order Traversal\u300d\u4ece\u9876\u90e8\u5230\u5e95\u90e8\u9010\u5c42\u904d\u5386\u4e8c\u53c9\u6811\uff0c\u5e76\u5728\u6bcf\u4e00\u5c42\u6309\u7167\u4ece\u5de6\u5230\u53f3\u7684\u987a\u5e8f\u8bbf\u95ee\u8282\u70b9\u3002

    \u5c42\u5e8f\u904d\u5386\u672c\u8d28\u4e0a\u5c5e\u4e8e\u300c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22 Breadth-First Traversal\u300d\uff0c\u5b83\u4f53\u73b0\u4e86\u4e00\u79cd\u201c\u4e00\u5708\u4e00\u5708\u5411\u5916\u6269\u5c55\u201d\u7684\u9010\u5c42\u641c\u7d22\u65b9\u5f0f\u3002

    Fig. \u4e8c\u53c9\u6811\u7684\u5c42\u5e8f\u904d\u5386

    "},{"location":"chapter_tree/binary_tree_traversal/#_1","title":"\u7b97\u6cd5\u5b9e\u73b0","text":"

    \u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u901a\u5e38\u501f\u52a9\u300c\u961f\u5217\u300d\u6765\u5b9e\u73b0\u3002\u961f\u5217\u9075\u5faa\u201c\u5148\u8fdb\u5148\u51fa\u201d\u7684\u89c4\u5219\uff0c\u800c\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u5219\u9075\u5faa\u201c\u9010\u5c42\u63a8\u8fdb\u201d\u7684\u89c4\u5219\uff0c\u4e24\u8005\u80cc\u540e\u7684\u601d\u60f3\u662f\u4e00\u81f4\u7684\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_tree_bfs.java
    /* \u5c42\u5e8f\u904d\u5386 */\nList<Integer> levelOrder(TreeNode root) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nQueue<TreeNode> queue = new LinkedList<>() {{ add(root); }};\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nList<Integer> list = new ArrayList<>();\nwhile (!queue.isEmpty()) {\nTreeNode node = queue.poll(); // \u961f\u5217\u51fa\u961f\nlist.add(node.val);           // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left != null)\nqueue.offer(node.left);   // \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif (node.right != null)\nqueue.offer(node.right);  // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\nreturn list;\n}\n
    binary_tree_bfs.cpp
    /* \u5c42\u5e8f\u904d\u5386 */\nvector<int> levelOrder(TreeNode *root) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nqueue<TreeNode *> queue;\nqueue.push(root);\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nvector<int> vec;\nwhile (!queue.empty()) {\nTreeNode *node = queue.front();\nqueue.pop();              // \u961f\u5217\u51fa\u961f\nvec.push_back(node->val); // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node->left != nullptr)\nqueue.push(node->left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif (node->right != nullptr)\nqueue.push(node->right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\nreturn vec;\n}\n
    binary_tree_bfs.py
    def level_order(root: TreeNode | None) -> list[int]:\n\"\"\"\u5c42\u5e8f\u904d\u5386\"\"\"\n# \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nqueue: deque[TreeNode] = deque()\nqueue.append(root)\n# \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nres = []\nwhile queue:\nnode: TreeNode = queue.popleft()  # \u961f\u5217\u51fa\u961f\nres.append(node.val)  # \u4fdd\u5b58\u8282\u70b9\u503c\nif node.left is not None:\nqueue.append(node.left)  # \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif node.right is not None:\nqueue.append(node.right)  # \u53f3\u5b50\u8282\u70b9\u5165\u961f\nreturn res\n
    binary_tree_bfs.go
    /* \u5c42\u5e8f\u904d\u5386 */\nfunc levelOrder(root *TreeNode) []int {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nqueue := list.New()\nqueue.PushBack(root)\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5207\u7247\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nnums := make([]int, 0)\nfor queue.Len() > 0 {\n// \u961f\u5217\u51fa\u961f\nnode := queue.Remove(queue.Front()).(*TreeNode)\n// \u4fdd\u5b58\u8282\u70b9\u503c\nnums = append(nums, node.Val)\nif node.Left != nil {\n// \u5de6\u5b50\u8282\u70b9\u5165\u961f\nqueue.PushBack(node.Left)\n}\nif node.Right != nil {\n// \u53f3\u5b50\u8282\u70b9\u5165\u961f\nqueue.PushBack(node.Right)\n}\n}\nreturn nums\n}\n
    binary_tree_bfs.js
    /* \u5c42\u5e8f\u904d\u5386 */\nfunction levelOrder(root) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nconst queue = [root];\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nconst list = [];\nwhile (queue.length) {\nlet node = queue.shift(); // \u961f\u5217\u51fa\u961f\nlist.push(node.val); // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left) queue.push(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif (node.right) queue.push(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\nreturn list;\n}\n
    binary_tree_bfs.ts
    /* \u5c42\u5e8f\u904d\u5386 */\nfunction levelOrder(root: TreeNode | null): number[] {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nconst queue = [root];\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nconst list: number[] = [];\nwhile (queue.length) {\nlet node = queue.shift() as TreeNode; // \u961f\u5217\u51fa\u961f\nlist.push(node.val); // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left) {\nqueue.push(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n}\nif (node.right) {\nqueue.push(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\n}\nreturn list;\n}\n
    binary_tree_bfs.c
    /* \u5c42\u5e8f\u904d\u5386 */\nint *levelOrder(TreeNode *root, int *size) {\n/* \u8f85\u52a9\u961f\u5217 */\nint front, rear;\nint index, *arr;\nTreeNode *node;\nTreeNode **queue;\n/* \u8f85\u52a9\u961f\u5217 */\nqueue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_NODE_SIZE);\n// \u961f\u5217\u6307\u9488\nfront = 0, rear = 0;\n// \u52a0\u5165\u6839\u8282\u70b9\nqueue[rear++] = root;\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n/* \u8f85\u52a9\u6570\u7ec4 */\narr = (int *)malloc(sizeof(int) * MAX_NODE_SIZE);\n// \u6570\u7ec4\u6307\u9488\nindex = 0;\nwhile (front < rear) {\n// \u961f\u5217\u51fa\u961f\nnode = queue[front++];\n// \u4fdd\u5b58\u8282\u70b9\u503c\narr[index++] = node->val;\nif (node->left != NULL) {\n// \u5de6\u5b50\u8282\u70b9\u5165\u961f\nqueue[rear++] = node->left;\n}\nif (node->right != NULL) {\n// \u53f3\u5b50\u8282\u70b9\u5165\u961f\nqueue[rear++] = node->right;\n}\n}\n// \u66f4\u65b0\u6570\u7ec4\u957f\u5ea6\u7684\u503c\n*size = index;\narr = realloc(arr, sizeof(int) * (*size));\n// \u91ca\u653e\u8f85\u52a9\u6570\u7ec4\u7a7a\u95f4\nfree(queue);\nreturn arr;\n}\n
    binary_tree_bfs.cs
    /* \u5c42\u5e8f\u904d\u5386 */\nList<int> levelOrder(TreeNode root) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nQueue<TreeNode> queue = new();\nqueue.Enqueue(root);\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nList<int> list = new();\nwhile (queue.Count != 0) {\nTreeNode node = queue.Dequeue(); // \u961f\u5217\u51fa\u961f\nlist.Add(node.val);              // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left != null)\nqueue.Enqueue(node.left);    // \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif (node.right != null)\nqueue.Enqueue(node.right);   // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\nreturn list;\n}\n
    binary_tree_bfs.swift
    /* \u5c42\u5e8f\u904d\u5386 */\nfunc levelOrder(root: TreeNode) -> [Int] {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nvar queue: [TreeNode] = [root]\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nvar list: [Int] = []\nwhile !queue.isEmpty {\nlet node = queue.removeFirst() // \u961f\u5217\u51fa\u961f\nlist.append(node.val) // \u4fdd\u5b58\u8282\u70b9\u503c\nif let left = node.left {\nqueue.append(left) // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n}\nif let right = node.right {\nqueue.append(right) // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\n}\nreturn list\n}\n
    binary_tree_bfs.zig
    // \u5c42\u5e8f\u904d\u5386\nfn levelOrder(comptime T: type, mem_allocator: std.mem.Allocator, root: *inc.TreeNode(T)) !std.ArrayList(T) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nconst L = std.TailQueue(*inc.TreeNode(T));\nvar queue = L{};\nvar root_node = try mem_allocator.create(L.Node);\nroot_node.data = root;\nqueue.append(root_node); // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nvar list = std.ArrayList(T).init(std.heap.page_allocator);\nwhile (queue.len > 0) {\nvar queue_node = queue.popFirst().?;    // \u961f\u5217\u51fa\u961f\nvar node = queue_node.data;\ntry list.append(node.val);              // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left != null) {\nvar tmp_node = try mem_allocator.create(L.Node);\ntmp_node.data = node.left.?;\nqueue.append(tmp_node);             // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n}\nif (node.right != null) {\nvar tmp_node = try mem_allocator.create(L.Node);\ntmp_node.data = node.right.?;\nqueue.append(tmp_node);             // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}        }\nreturn list;\n}\n
    binary_tree_bfs.dart
    /* \u5c42\u5e8f\u904d\u5386 */\nList<int> levelOrder(TreeNode? root) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nQueue<TreeNode?> queue = Queue();\nqueue.add(root);\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nList<int> res = [];\nwhile (queue.isNotEmpty) {\nTreeNode? node = queue.removeFirst(); // \u961f\u5217\u51fa\u961f\nres.add(node!.val); // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left != null) queue.add(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif (node.right != null) queue.add(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\nreturn res;\n}\n
    "},{"location":"chapter_tree/binary_tree_traversal/#_2","title":"\u590d\u6742\u5ea6\u5206\u6790","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u6240\u6709\u8282\u70b9\u88ab\u8bbf\u95ee\u4e00\u6b21\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\uff0c\u5176\u4e2d \\(n\\) \u4e3a\u8282\u70b9\u6570\u91cf\u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\uff1a\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u5373\u6ee1\u4e8c\u53c9\u6811\u65f6\uff0c\u904d\u5386\u5230\u6700\u5e95\u5c42\u4e4b\u524d\uff0c\u961f\u5217\u4e2d\u6700\u591a\u540c\u65f6\u5b58\u5728 \\(\\frac{n + 1}{2}\\) \u4e2a\u8282\u70b9\uff0c\u5360\u7528 \\(O(n)\\) \u7a7a\u95f4\u3002

    "},{"location":"chapter_tree/binary_tree_traversal/#722","title":"7.2.2. \u00a0 \u524d\u5e8f\u3001\u4e2d\u5e8f\u3001\u540e\u5e8f\u904d\u5386","text":"

    \u76f8\u5e94\u5730\uff0c\u524d\u5e8f\u3001\u4e2d\u5e8f\u548c\u540e\u5e8f\u904d\u5386\u90fd\u5c5e\u4e8e\u300c\u6df1\u5ea6\u4f18\u5148\u904d\u5386 Depth-First Traversal\u300d\uff0c\u5b83\u4f53\u73b0\u4e86\u4e00\u79cd\u201c\u5148\u8d70\u5230\u5c3d\u5934\uff0c\u518d\u56de\u6eaf\u7ee7\u7eed\u201d\u7684\u904d\u5386\u65b9\u5f0f\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5de6\u4fa7\u662f\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u7684\u793a\u610f\u56fe\uff0c\u53f3\u4e0a\u65b9\u662f\u5bf9\u5e94\u7684\u9012\u5f52\u5b9e\u73b0\u4ee3\u7801\u3002\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u5c31\u50cf\u662f\u7ed5\u7740\u6574\u4e2a\u4e8c\u53c9\u6811\u7684\u5916\u56f4\u201c\u8d70\u201d\u4e00\u5708\uff0c\u5728\u8fd9\u4e2a\u8fc7\u7a0b\u4e2d\uff0c\u5728\u6bcf\u4e2a\u8282\u70b9\u90fd\u4f1a\u9047\u5230\u4e09\u4e2a\u4f4d\u7f6e\uff0c\u5206\u522b\u5bf9\u5e94\u524d\u5e8f\u904d\u5386\u3001\u4e2d\u5e8f\u904d\u5386\u548c\u540e\u5e8f\u904d\u5386\u3002

    Fig. \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u524d\u3001\u4e2d\u3001\u540e\u5e8f\u904d\u5386

    \u4f4d\u7f6e \u542b\u4e49 \u6b64\u5904\u8bbf\u95ee\u8282\u70b9\u65f6\u5bf9\u5e94 \u6a59\u8272\u5706\u5708\u5904 \u521a\u8fdb\u5165\u6b64\u8282\u70b9\uff0c\u5373\u5c06\u8bbf\u95ee\u8be5\u8282\u70b9\u7684\u5de6\u5b50\u6811 \u524d\u5e8f\u904d\u5386 Pre-Order Traversal \u84dd\u8272\u5706\u5708\u5904 \u5df2\u8bbf\u95ee\u5b8c\u5de6\u5b50\u6811\uff0c\u5373\u5c06\u8bbf\u95ee\u53f3\u5b50\u6811 \u4e2d\u5e8f\u904d\u5386 In-Order Traversal \u7d2b\u8272\u5706\u5708\u5904 \u5df2\u8bbf\u95ee\u5b8c\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\uff0c\u5373\u5c06\u8fd4\u56de \u540e\u5e8f\u904d\u5386 Post-Order Traversal"},{"location":"chapter_tree/binary_tree_traversal/#_3","title":"\u7b97\u6cd5\u5b9e\u73b0","text":"JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_tree_dfs.java
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode root) {\nif (root == null)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.add(root.val);\npreOrder(root.left);\npreOrder(root.right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode root) {\nif (root == null)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root.left);\nlist.add(root.val);\ninOrder(root.right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode root) {\nif (root == null)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root.left);\npostOrder(root.right);\nlist.add(root.val);\n}\n
    binary_tree_dfs.cpp
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode *root) {\nif (root == nullptr)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nvec.push_back(root->val);\npreOrder(root->left);\npreOrder(root->right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode *root) {\nif (root == nullptr)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root->left);\nvec.push_back(root->val);\ninOrder(root->right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode *root) {\nif (root == nullptr)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root->left);\npostOrder(root->right);\nvec.push_back(root->val);\n}\n
    binary_tree_dfs.py
    def pre_order(root: TreeNode | None) -> None:\n\"\"\"\u524d\u5e8f\u904d\u5386\"\"\"\nif root is None:\nreturn\n# \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nres.append(root.val)\npre_order(root=root.left)\npre_order(root=root.right)\ndef in_order(root: TreeNode | None) -> None:\n\"\"\"\u4e2d\u5e8f\u904d\u5386\"\"\"\nif root is None:\nreturn\n# \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\nin_order(root=root.left)\nres.append(root.val)\nin_order(root=root.right)\ndef post_order(root: TreeNode | None) -> None:\n\"\"\"\u540e\u5e8f\u904d\u5386\"\"\"\nif root is None:\nreturn\n# \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npost_order(root=root.left)\npost_order(root=root.right)\nres.append(root.val)\n
    binary_tree_dfs.go
    /* \u524d\u5e8f\u904d\u5386 */\nfunc preOrder(node *TreeNode) {\nif node == nil {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nnums = append(nums, node.Val)\npreOrder(node.Left)\npreOrder(node.Right)\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc inOrder(node *TreeNode) {\nif node == nil {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(node.Left)\nnums = append(nums, node.Val)\ninOrder(node.Right)\n}\n/* \u540e\u5e8f\u904d\u5386 */\nfunc postOrder(node *TreeNode) {\nif node == nil {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(node.Left)\npostOrder(node.Right)\nnums = append(nums, node.Val)\n}\n
    binary_tree_dfs.js
    /* \u524d\u5e8f\u904d\u5386 */\nfunction preOrder(root) {\nif (root === null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.push(root.val);\npreOrder(root.left);\npreOrder(root.right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunction inOrder(root) {\nif (root === null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root.left);\nlist.push(root.val);\ninOrder(root.right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nfunction postOrder(root) {\nif (root === null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root.left);\npostOrder(root.right);\nlist.push(root.val);\n}\n
    binary_tree_dfs.ts
    /* \u524d\u5e8f\u904d\u5386 */\nfunction preOrder(root: TreeNode | null): void {\nif (root === null) {\nreturn;\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.push(root.val);\npreOrder(root.left);\npreOrder(root.right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunction inOrder(root: TreeNode | null): void {\nif (root === null) {\nreturn;\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root.left);\nlist.push(root.val);\ninOrder(root.right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nfunction postOrder(root: TreeNode | null): void {\nif (root === null) {\nreturn;\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root.left);\npostOrder(root.right);\nlist.push(root.val);\n}\n
    binary_tree_dfs.c
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode *root, int *size) {\nif (root == NULL)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\narr[(*size)++] = root->val;\npreOrder(root->left, size);\npreOrder(root->right, size);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode *root, int *size) {\nif (root == NULL)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root->left, size);\narr[(*size)++] = root->val;\ninOrder(root->right, size);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode *root, int *size) {\nif (root == NULL)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root->left, size);\npostOrder(root->right, size);\narr[(*size)++] = root->val;\n}\n
    binary_tree_dfs.cs
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode? root) {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.Add(root.val);\npreOrder(root.left);\npreOrder(root.right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode? root) {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root.left);\nlist.Add(root.val);\ninOrder(root.right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode? root) {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root.left);\npostOrder(root.right);\nlist.Add(root.val);\n}\n
    binary_tree_dfs.swift
    /* \u524d\u5e8f\u904d\u5386 */\nfunc preOrder(root: TreeNode?) {\nguard let root = root else {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.append(root.val)\npreOrder(root: root.left)\npreOrder(root: root.right)\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc inOrder(root: TreeNode?) {\nguard let root = root else {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root: root.left)\nlist.append(root.val)\ninOrder(root: root.right)\n}\n/* \u540e\u5e8f\u904d\u5386 */\nfunc postOrder(root: TreeNode?) {\nguard let root = root else {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root: root.left)\npostOrder(root: root.right)\nlist.append(root.val)\n}\n
    binary_tree_dfs.zig
    // \u524d\u5e8f\u904d\u5386\nfn preOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\ntry list.append(root.?.val);\ntry preOrder(T, root.?.left);\ntry preOrder(T, root.?.right);\n}\n// \u4e2d\u5e8f\u904d\u5386\nfn inOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ntry inOrder(T, root.?.left);\ntry list.append(root.?.val);\ntry inOrder(T, root.?.right);\n}\n// \u540e\u5e8f\u904d\u5386\nfn postOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\ntry postOrder(T, root.?.left);\ntry postOrder(T, root.?.right);\ntry list.append(root.?.val);\n}\n
    binary_tree_dfs.dart
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode? node) {\nif (node == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.add(node.val);\npreOrder(node.left);\npreOrder(node.right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode? node) {\nif (node == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(node.left);\nlist.add(node.val);\ninOrder(node.right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode? node) {\nif (node == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(node.left);\npostOrder(node.right);\nlist.add(node.val);\n}\n

    Note

    \u6211\u4eec\u4e5f\u53ef\u4ee5\u4ec5\u57fa\u4e8e\u5faa\u73af\u5b9e\u73b0\u524d\u3001\u4e2d\u3001\u540e\u5e8f\u904d\u5386\uff0c\u6709\u5174\u8da3\u7684\u540c\u5b66\u53ef\u4ee5\u81ea\u884c\u5b9e\u73b0\u3002

    \u9012\u5f52\u8fc7\u7a0b\u53ef\u5206\u4e3a\u201c\u9012\u201d\u548c\u201c\u5f52\u201d\u4e24\u4e2a\u76f8\u53cd\u7684\u90e8\u5206\u3002\u201c\u9012\u201d\u8868\u793a\u5f00\u542f\u65b0\u65b9\u6cd5\uff0c\u7a0b\u5e8f\u5728\u6b64\u8fc7\u7a0b\u4e2d\u8bbf\u95ee\u4e0b\u4e00\u4e2a\u8282\u70b9\uff1b\u201c\u5f52\u201d\u8868\u793a\u51fd\u6570\u8fd4\u56de\uff0c\u4ee3\u8868\u8be5\u8282\u70b9\u5df2\u7ecf\u8bbf\u95ee\u5b8c\u6bd5\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u4e3a\u524d\u5e8f\u904d\u5386\u4e8c\u53c9\u6811\u7684\u9012\u5f52\u8fc7\u7a0b\u3002

    <1><2><3><4><5><6><7><8><9><10><11>

    "},{"location":"chapter_tree/binary_tree_traversal/#_4","title":"\u590d\u6742\u5ea6\u5206\u6790","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u6240\u6709\u8282\u70b9\u88ab\u8bbf\u95ee\u4e00\u6b21\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\uff0c\u5176\u4e2d \\(n\\) \u4e3a\u8282\u70b9\u6570\u91cf\u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\uff1a\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u5373\u6811\u9000\u5316\u4e3a\u94fe\u8868\u65f6\uff0c\u9012\u5f52\u6df1\u5ea6\u8fbe\u5230 \\(n\\) \uff0c\u7cfb\u7edf\u5360\u7528 \\(O(n)\\) \u6808\u5e27\u7a7a\u95f4\u3002

    "},{"location":"chapter_tree/summary/","title":"7.6. \u00a0 \u5c0f\u7ed3","text":"
    • \u4e8c\u53c9\u6811\u662f\u4e00\u79cd\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u4f53\u73b0\u201c\u4e00\u5206\u4e3a\u4e8c\u201d\u7684\u5206\u6cbb\u903b\u8f91\u3002\u6bcf\u4e2a\u4e8c\u53c9\u6811\u8282\u70b9\u5305\u542b\u4e00\u4e2a\u503c\u4ee5\u53ca\u4e24\u4e2a\u6307\u9488\uff0c\u5206\u522b\u6307\u5411\u5176\u5de6\u5b50\u8282\u70b9\u548c\u53f3\u5b50\u8282\u70b9\u3002
    • \u5bf9\u4e8e\u4e8c\u53c9\u6811\u4e2d\u7684\u67d0\u4e2a\u8282\u70b9\uff0c\u5176\u5de6\uff08\u53f3\uff09\u5b50\u8282\u70b9\u53ca\u5176\u4ee5\u4e0b\u5f62\u6210\u7684\u6811\u88ab\u79f0\u4e3a\u8be5\u8282\u70b9\u7684\u5de6\uff08\u53f3\uff09\u5b50\u6811\u3002
    • \u4e8c\u53c9\u6811\u7684\u76f8\u5173\u672f\u8bed\u5305\u62ec\u6839\u8282\u70b9\u3001\u53f6\u8282\u70b9\u3001\u5c42\u3001\u5ea6\u3001\u8fb9\u3001\u9ad8\u5ea6\u548c\u6df1\u5ea6\u7b49\u3002
    • \u4e8c\u53c9\u6811\u7684\u521d\u59cb\u5316\u3001\u8282\u70b9\u63d2\u5165\u548c\u8282\u70b9\u5220\u9664\u64cd\u4f5c\u4e0e\u94fe\u8868\u64cd\u4f5c\u65b9\u6cd5\u7c7b\u4f3c\u3002
    • \u5e38\u89c1\u7684\u4e8c\u53c9\u6811\u7c7b\u578b\u6709\u5b8c\u7f8e\u4e8c\u53c9\u6811\u3001\u5b8c\u5168\u4e8c\u53c9\u6811\u3001\u6ee1\u4e8c\u53c9\u6811\u548c\u5e73\u8861\u4e8c\u53c9\u6811\u3002\u5b8c\u7f8e\u4e8c\u53c9\u6811\u662f\u6700\u7406\u60f3\u7684\u72b6\u6001\uff0c\u800c\u94fe\u8868\u662f\u9000\u5316\u540e\u7684\u6700\u5dee\u72b6\u6001\u3002
    • \u4e8c\u53c9\u6811\u53ef\u4ee5\u7528\u6570\u7ec4\u8868\u793a\uff0c\u65b9\u6cd5\u662f\u5c06\u8282\u70b9\u503c\u548c\u7a7a\u4f4d\u6309\u5c42\u5e8f\u904d\u5386\u987a\u5e8f\u6392\u5217\uff0c\u5e76\u6839\u636e\u7236\u8282\u70b9\u4e0e\u5b50\u8282\u70b9\u4e4b\u95f4\u7684\u7d22\u5f15\u6620\u5c04\u5173\u7cfb\u6765\u5b9e\u73b0\u6307\u9488\u3002
    • \u4e8c\u53c9\u6811\u7684\u5c42\u5e8f\u904d\u5386\u662f\u4e00\u79cd\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22\u65b9\u6cd5\uff0c\u5b83\u4f53\u73b0\u4e86\u201c\u4e00\u5708\u4e00\u5708\u5411\u5916\u201d\u7684\u5206\u5c42\u904d\u5386\u65b9\u5f0f\uff0c\u901a\u5e38\u901a\u8fc7\u961f\u5217\u6765\u5b9e\u73b0\u3002
    • \u524d\u5e8f\u3001\u4e2d\u5e8f\u3001\u540e\u5e8f\u904d\u5386\u7686\u5c5e\u4e8e\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\uff0c\u5b83\u4eec\u4f53\u73b0\u4e86\u201c\u8d70\u5230\u5c3d\u5934\uff0c\u518d\u56de\u5934\u7ee7\u7eed\u201d\u7684\u56de\u6eaf\u904d\u5386\u65b9\u5f0f\uff0c\u901a\u5e38\u4f7f\u7528\u9012\u5f52\u6765\u5b9e\u73b0\u3002
    • \u4e8c\u53c9\u641c\u7d22\u6811\u662f\u4e00\u79cd\u9ad8\u6548\u7684\u5143\u7d20\u67e5\u627e\u6570\u636e\u7ed3\u6784\uff0c\u5176\u67e5\u627e\u3001\u63d2\u5165\u548c\u5220\u9664\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(\\log n)\\) \u3002\u5f53\u4e8c\u53c9\u641c\u7d22\u6811\u9000\u5316\u4e3a\u94fe\u8868\u65f6\uff0c\u5404\u9879\u65f6\u95f4\u590d\u6742\u5ea6\u4f1a\u52a3\u5316\u81f3 \\(O(n)\\) \u3002
    • AVL \u6811\uff0c\u4e5f\u79f0\u4e3a\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811\uff0c\u5b83\u901a\u8fc7\u65cb\u8f6c\u64cd\u4f5c\uff0c\u786e\u4fdd\u5728\u4e0d\u65ad\u63d2\u5165\u548c\u5220\u9664\u8282\u70b9\u540e\uff0c\u6811\u4ecd\u7136\u4fdd\u6301\u5e73\u8861\u3002
    • AVL \u6811\u7684\u65cb\u8f6c\u64cd\u4f5c\u5305\u62ec\u53f3\u65cb\u3001\u5de6\u65cb\u3001\u5148\u53f3\u65cb\u518d\u5de6\u65cb\u3001\u5148\u5de6\u65cb\u518d\u53f3\u65cb\u3002\u5728\u63d2\u5165\u6216\u5220\u9664\u8282\u70b9\u540e\uff0cAVL \u6811\u4f1a\u4ece\u5e95\u5411\u9876\u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\u3002
    "},{"location":"chapter_tree/summary/#761-q-a","title":"7.6.1. \u00a0 Q & A","text":"

    \u5bf9\u4e8e\u53ea\u6709\u4e00\u4e2a\u8282\u70b9\u7684\u4e8c\u53c9\u6811\uff0c\u6811\u7684\u9ad8\u5ea6\u548c\u6839\u8282\u70b9\u7684\u6df1\u5ea6\u90fd\u662f \\(0\\) \u5417\uff1f

    \u662f\u7684\uff0c\u56e0\u4e3a\u9ad8\u5ea6\u548c\u6df1\u5ea6\u901a\u5e38\u5b9a\u4e49\u4e3a\u201c\u8d70\u8fc7\u8fb9\u7684\u6570\u91cf\u201d\u3002

    \u4e8c\u53c9\u6811\u4e2d\u7684\u63d2\u5165\u4e0e\u5220\u9664\u4e00\u822c\u90fd\u662f\u7531\u4e00\u5957\u64cd\u4f5c\u914d\u5408\u5b8c\u6210\u7684\uff0c\u8fd9\u91cc\u7684\u201c\u4e00\u5957\u64cd\u4f5c\u201d\u6307\u4ec0\u4e48\u5462\uff1f\u53ef\u4ee5\u7406\u89e3\u4e3a\u8d44\u6e90\u7684\u5b50\u8282\u70b9\u7684\u8d44\u6e90\u91ca\u653e\u5417\uff1f

    \u62ff\u4e8c\u53c9\u641c\u7d22\u6811\u6765\u4e3e\u4f8b\uff0c\u5220\u9664\u8282\u70b9\u64cd\u4f5c\u8981\u5206\u4e3a\u4e09\u79cd\u60c5\u51b5\u5904\u7406\uff0c\u5176\u4e2d\u6bcf\u79cd\u60c5\u51b5\u90fd\u9700\u8981\u8fdb\u884c\u591a\u4e2a\u6b65\u9aa4\u7684\u8282\u70b9\u64cd\u4f5c\u3002

    \u4e3a\u4ec0\u4e48 DFS \u904d\u5386\u4e8c\u53c9\u6811\u6709\u524d\u3001\u4e2d\u3001\u540e\u4e09\u79cd\u987a\u5e8f\uff0c\u5206\u522b\u6709\u4ec0\u4e48\u7528\u5462\uff1f

    DFS \u7684\u524d\u3001\u4e2d\u3001\u540e\u5e8f\u904d\u5386\u548c\u8bbf\u95ee\u6570\u7ec4\u7684\u987a\u5e8f\u7c7b\u4f3c\uff0c\u662f\u904d\u5386\u4e8c\u53c9\u6811\u7684\u57fa\u672c\u65b9\u6cd5\uff0c\u5229\u7528\u8fd9\u4e09\u79cd\u904d\u5386\u65b9\u6cd5\uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u5230\u4e00\u4e2a\u7279\u5b9a\u987a\u5e8f\u7684\u904d\u5386\u7ed3\u679c\u3002\u4f8b\u5982\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\uff0c\u7531\u4e8e\u7ed3\u70b9\u5927\u5c0f\u6ee1\u8db3 \u5de6\u5b50\u7ed3\u70b9\u503c < \u6839\u7ed3\u70b9\u503c < \u53f3\u5b50\u7ed3\u70b9\u503c \uff0c\u56e0\u6b64\u6211\u4eec\u53ea\u8981\u6309\u7167 \u5de6->\u6839->\u53f3 \u7684\u4f18\u5148\u7ea7\u904d\u5386\u6811\uff0c\u5c31\u53ef\u4ee5\u83b7\u5f97\u6709\u5e8f\u7684\u8282\u70b9\u5e8f\u5217\u3002

    \u53f3\u65cb\u64cd\u4f5c\u662f\u5904\u7406\u5931\u8861\u8282\u70b9 node , child , grand_child \u4e4b\u95f4\u7684\u5173\u7cfb\uff0c\u90a3 node \u7684\u7236\u8282\u70b9\u548c node \u539f\u6765\u7684\u8fde\u63a5\u4e0d\u9700\u8981\u7ef4\u62a4\u5417\uff1f\u53f3\u65cb\u64cd\u4f5c\u540e\u5c82\u4e0d\u662f\u65ad\u6389\u4e86\uff1f

    \u6211\u4eec\u9700\u8981\u4ece\u9012\u5f52\u7684\u89c6\u89d2\u6765\u770b\u8fd9\u4e2a\u95ee\u9898\u3002\u53f3\u65cb\u64cd\u4f5c right_rotate(root) \u4f20\u5165\u7684\u662f\u5b50\u6811\u7684\u6839\u8282\u70b9\uff0c\u6700\u7ec8 return child \u8fd4\u56de\u65cb\u8f6c\u4e4b\u540e\u7684\u5b50\u6811\u7684\u6839\u8282\u70b9\u3002\u5b50\u6811\u7684\u6839\u8282\u70b9\u548c\u5176\u7236\u8282\u70b9\u7684\u8fde\u63a5\u662f\u5728\u8be5\u51fd\u6570\u8fd4\u56de\u540e\u5b8c\u6210\u7684\uff0c\u4e0d\u5c5e\u4e8e\u53f3\u65cb\u64cd\u4f5c\u7684\u7ef4\u62a4\u8303\u56f4\u3002

    \u5728 C++ \u4e2d\uff0c\u51fd\u6570\u88ab\u5212\u5206\u5230 private \u548c public \u4e2d\uff0c\u8fd9\u65b9\u9762\u6709\u4ec0\u4e48\u8003\u91cf\u5417\uff1f\u4e3a\u4ec0\u4e48\u8981\u5c06 height() \u51fd\u6570\u548c updateHeight() \u51fd\u6570\u5206\u522b\u653e\u5728 public \u548c private \u4e2d\u5462\uff1f

    \u4e3b\u8981\u770b\u65b9\u6cd5\u7684\u4f7f\u7528\u8303\u56f4\uff0c\u5982\u679c\u65b9\u6cd5\u53ea\u5728\u7c7b\u5185\u90e8\u4f7f\u7528\uff0c\u90a3\u4e48\u5c31\u8bbe\u8ba1\u4e3a private \u3002\u4f8b\u5982\uff0c\u7528\u6237\u5355\u72ec\u8c03\u7528 updateHeight() \u662f\u6ca1\u6709\u610f\u4e49\u7684\uff0c\u5b83\u53ea\u662f\u63d2\u5165\u3001\u5220\u9664\u64cd\u4f5c\u4e2d\u7684\u4e00\u6b65\u3002\u800c height() \u662f\u8bbf\u95ee\u7ed3\u70b9\u9ad8\u5ea6\uff0c\u7c7b\u4f3c\u4e8e vector.size() \uff0c\u56e0\u6b64\u8bbe\u7f6e\u6210 public \u4ee5\u4fbf\u4f7f\u7528\u3002

    \u8bf7\u95ee\u5982\u4f55\u4ece\u4e00\u7ec4\u8f93\u5165\u6570\u636e\u6784\u5efa\u4e00\u4e2a\u4e8c\u53c9\u641c\u7d22\u6811\uff1f\u6839\u8282\u70b9\u7684\u9009\u62e9\u662f\u4e0d\u662f\u5f88\u91cd\u8981\uff1f

    \u662f\u7684\uff0c\u6784\u5efa\u6811\u7684\u65b9\u6cd5\u662f build_tree() \uff0c\u5df2\u5728\u6e90\u4ee3\u7801\u4e2d\u7ed9\u51fa\u3002\u81f3\u4e8e\u6839\u8282\u70b9\u7684\u9009\u62e9\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u5c06\u8f93\u5165\u6570\u636e\u6392\u5e8f\uff0c\u7136\u540e\u7528\u4e2d\u70b9\u5143\u7d20\u4f5c\u4e3a\u6839\u8282\u70b9\uff0c\u518d\u9012\u5f52\u5730\u6784\u5efa\u5de6\u53f3\u5b50\u6811\u3002\u8fd9\u6837\u505a\u53ef\u4ee5\u6700\u5927\u7a0b\u5ea6\u4fdd\u8bc1\u6811\u7684\u5e73\u8861\u6027\u3002

    "}]} \ No newline at end of file +{"config":{"lang":["ja"],"separator":"[\\s\\-\uff0c\u3002]+","pipeline":["stemmer"]},"docs":[{"location":"","title":"Home","text":"\u300a Hello \u7b97\u6cd5 \u300b

    \u52a8\u753b\u56fe\u89e3\u3001\u4e00\u952e\u8fd0\u884c\u7684\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u6559\u7a0b

    \u63a8\u8350\u8bed

    Quote

    \u201c\u4e00\u672c\u901a\u4fd7\u6613\u61c2\u7684\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u5165\u95e8\u4e66\uff0c\u5f15\u5bfc\u8bfb\u8005\u624b\u8111\u5e76\u7528\u5730\u5b66\u4e60\uff0c\u5f3a\u70c8\u63a8\u8350\u7b97\u6cd5\u521d\u5b66\u8005\u9605\u8bfb\u3002\u201d

    \u2014\u2014 \u9093\u4fca\u8f89\uff0c\u6e05\u534e\u5927\u5b66\u8ba1\u7b97\u673a\u7cfb\u6559\u6388

    Quote

    \u201c\u5982\u679c\u6211\u5f53\u5e74\u5b66\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u65f6\u5019\u6709\u300aHello \u7b97\u6cd5\u300b\uff0c\u5b66\u8d77\u6765\u5e94\u8be5\u4f1a\u7b80\u5355 10 \u500d\uff01\u201d

    \u2014\u2014 \u674e\u6c90\uff0c\u4e9a\u9a6c\u900a\u8d44\u6df1\u9996\u5e2d\u79d1\u5b66\u5bb6

    \u5168\u4e66\u52a8\u753b\u56fe\u89e3

    \u5185\u5bb9\u6e05\u6670\u6613\u61c2\u3001\u5b66\u4e60\u66f2\u7ebf\u5e73\u6ed1\u7535\u8111\u3001\u5e73\u677f\u3001\u624b\u673a\u5168\u7ec8\u7aef\u9605\u8bfb

    \"A picture is worth a thousand words.\"

    \u201c\u4e00\u56fe\u80dc\u5343\u8a00\u201d

    \u4ee3\u7801\u4e00\u952e\u8fd0\u884c

    \u63d0\u4f9b\u5404\u4e2a\u7b97\u6cd5\u4e0e\u6570\u636e\u7ed3\u6784\u7684\u7b80\u6d01\u5b9e\u73b0\u4e0e\u6d4b\u8bd5\u6837\u4f8b\uff0c\u7686\u53ef\u76f4\u63a5\u8fd0\u884c\u652f\u6301 Java, C++, Python, Go, JS, TS, C#, Swift, Zig \u7b49\u8bed\u8a00

    \"Talk is cheap. Show me the code.\"

    \u201c\u5c11\u5439\u725b\uff0c\u770b\u4ee3\u7801\u201d

    \u53ef\u8ba8\u8bba\u4e0e\u63d0\u95ee

    \u9f13\u52b1\u5c0f\u4f19\u4f34\u4eec\u4e92\u5e2e\u4e92\u52a9\u3001\u5171\u540c\u6210\u957f\u63d0\u95ee\u4e0e\u8bc4\u8bba\u4e00\u822c\u80fd\u5728\u4e24\u65e5\u5185\u5f97\u5230\u56de\u590d

    \u201c\u8ffd\u98ce\u8d76\u6708\u83ab\u505c\u7559\uff0c\u5e73\u829c\u5c3d\u5904\u662f\u6625\u5c71\u201d

    \u4e00\u8d77\u52a0\u6cb9\uff01

    \u5e8f

    \u4e24\u5e74\u524d\uff0c\u6211\u5728\u529b\u6263\u4e0a\u5206\u4eab\u4e86\u300a\u5251\u6307 Offer\u300b\u7cfb\u5217\u9898\u89e3\uff0c\u53d7\u5230\u4e86\u8bb8\u591a\u670b\u53cb\u7684\u559c\u7231\u4e0e\u652f\u6301\u3002\u5728\u6b64\u671f\u95f4\uff0c\u6211\u56de\u7b54\u4e86\u4f17\u591a\u8bfb\u8005\u7684\u8bc4\u8bba\u95ee\u9898\uff0c\u5176\u4e2d\u6700\u5e38\u89c1\u7684\u4e00\u4e2a\u95ee\u9898\u662f\u201c\u5982\u4f55\u5165\u95e8\u5b66\u4e60\u7b97\u6cd5\u201d\u3002\u6211\u9010\u6e10\u4e5f\u5bf9\u8fd9\u4e2a\u95ee\u9898\u4ea7\u751f\u4e86\u6d53\u539a\u7684\u5174\u8da3\u3002

    \u4e24\u773c\u4e00\u62b9\u9ed1\u5730\u5237\u9898\u4f3c\u4e4e\u662f\u6700\u53d7\u6b22\u8fce\u7684\u65b9\u6cd5\uff0c\u7b80\u5355\u76f4\u63a5\u4e14\u6709\u6548\u3002\u7136\u800c\uff0c\u5237\u9898\u5c31\u5982\u540c\u73a9\u201c\u626b\u96f7\u201d\u6e38\u620f\uff0c\u81ea\u5b66\u80fd\u529b\u5f3a\u7684\u540c\u5b66\u80fd\u591f\u987a\u5229\u5730\u5c06\u5730\u96f7\u9010\u4e2a\u6392\u6389\uff0c\u800c\u57fa\u7840\u4e0d\u8db3\u7684\u540c\u5b66\u5f88\u53ef\u80fd\u88ab\u70b8\u7684\u6ee1\u5934\u662f\u5305\uff0c\u5e76\u5728\u632b\u6298\u4e2d\u6b65\u6b65\u9000\u7f29\u3002\u901a\u8bfb\u6559\u6750\u4e66\u7c4d\u4e5f\u662f\u4e00\u79cd\u5e38\u89c1\u505a\u6cd5\uff0c\u4f46\u5bf9\u4e8e\u9762\u5411\u6c42\u804c\u7684\u540c\u5b66\u6765\u8bf4\uff0c\u6bd5\u4e1a\u5b63\u3001\u6295\u9012\u7b80\u5386\u3001\u51c6\u5907\u7b14\u8bd5\u9762\u8bd5\u5df2\u7ecf\u5360\u636e\u4e86\u5927\u90e8\u5206\u7cbe\u529b\uff0c\u539a\u91cd\u7684\u4e66\u7c4d\u5f80\u5f80\u53d8\u6210\u4e86\u4e00\u9879\u8270\u5de8\u7684\u6311\u6218\u3002

    \u5982\u679c\u4f60\u4e5f\u9762\u4e34\u7c7b\u4f3c\u7684\u56f0\u6270\uff0c\u90a3\u4e48\u5f88\u5e78\u8fd0\u8fd9\u672c\u4e66\u627e\u5230\u4e86\u4f60\u3002\u672c\u4e66\u662f\u6211\u5bf9\u6b64\u95ee\u9898\u7684\u7ed9\u51fa\u7684\u7b54\u6848\uff0c\u867d\u7136\u4e0d\u4e00\u5b9a\u6b63\u786e\uff0c\u4f46\u81f3\u5c11\u662f\u4e00\u6b21\u79ef\u6781\u7684\u5c1d\u8bd5\u3002\u8fd9\u672c\u4e66\u867d\u7136\u4e0d\u8db3\u4ee5\u8ba9\u4f60\u76f4\u63a5\u62ff\u5230 Offer \uff0c\u4f46\u4f1a\u5f15\u5bfc\u4f60\u63a2\u7d22\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u201c\u77e5\u8bc6\u5730\u56fe\u201d\uff0c\u5e26\u4f60\u4e86\u89e3\u4e0d\u540c\u201c\u5730\u96f7\u201d\u7684\u5f62\u72b6\u5927\u5c0f\u548c\u5206\u5e03\u4f4d\u7f6e\uff0c\u8ba9\u4f60\u638c\u63e1\u5404\u79cd\u201c\u6392\u96f7\u65b9\u6cd5\u201d\u3002\u6709\u4e86\u8fd9\u4e9b\u672c\u9886\uff0c\u76f8\u4fe1\u4f60\u53ef\u4ee5\u66f4\u52a0\u81ea\u5982\u5730\u5e94\u5bf9\u5237\u9898\u548c\u9605\u8bfb\u6587\u732e\uff0c\u9010\u6b65\u6784\u5efa\u8d77\u5b8c\u6574\u7684\u77e5\u8bc6\u4f53\u7cfb\u3002

    \u4f5c\u8005\u7b80\u4ecb

    \u9773\u5b87\u680b (Krahets)\uff0c\u5927\u5382\u9ad8\u7ea7\u7b97\u6cd5\u5de5\u7a0b\u5e08\uff0c\u4e0a\u6d77\u4ea4\u901a\u5927\u5b66\u7855\u58eb\u3002\u529b\u6263\uff08LeetCode\uff09\u5168\u7f51\u9605\u8bfb\u91cf\u6700\u9ad8\u535a\u4e3b\uff0c\u5176 LeetBook\u300a\u56fe\u89e3\u7b97\u6cd5\u6570\u636e\u7ed3\u6784\u300b\u5df2\u88ab\u8ba2\u9605 24 \u4e07\u672c\u3002

    \u81f4\u8c22

    \u672c\u4e66\u5728\u5f00\u6e90\u793e\u533a\u4f17\u591a\u8d21\u732e\u8005\u7684\u5171\u540c\u52aa\u529b\u4e0b\u4e0d\u65ad\u6210\u957f\u3002\u611f\u8c22\u6bcf\u4e00\u4f4d\u6295\u5165\u65f6\u95f4\u4e0e\u7cbe\u529b\u7684\u64b0\u7a3f\u4eba\uff0c\u662f\u4ed6\u4eec\u65e0\u79c1\u5949\u732e\u4f7f\u8fd9\u672c\u4e66\u8d8a\u53d8\u8d8a\u597d\uff0c\u4ed6\u4eec\u662f\uff08\u6309\u7167 GitHub \u81ea\u52a8\u751f\u6210\u7684\u987a\u5e8f\u6392\u5217\uff09\uff1a

    \u672c\u4e66\u7684\u4ee3\u7801\u5ba1\u9605\u5de5\u4f5c\u7531 Gonglja, gvenusleo, justin\u2010tse, krahets, nuomi1, Reanon, sjinzh \u5b8c\u6210\uff08\u6309\u7167\u9996\u5b57\u6bcd\u987a\u5e8f\u6392\u5217\uff09\u3002\u611f\u8c22\u4ed6\u4eec\u4ed8\u51fa\u7684\u65f6\u95f4\u4e0e\u7cbe\u529b\uff0c\u6b63\u662f\u4ed6\u4eec\u786e\u4fdd\u4e86\u5404\u8bed\u8a00\u4ee3\u7801\u7684\u89c4\u8303\u4e0e\u7edf\u4e00\u3002

    GongljaC / C++ gvenusleoDart hpstoryC# justin-tseJS / TS krahetsJava / Python nuomi1Swift ReanonGo / C sjinzhRust / Zig"},{"location":"chapter_appendix/contribution/","title":"14.2. \u00a0 \u4e00\u8d77\u53c2\u4e0e\u521b\u4f5c","text":"

    \u5f00\u6e90\u7684\u9b45\u529b

    \u7eb8\u8d28\u4e66\u7c4d\u7684\u4e24\u6b21\u5370\u5237\u7684\u95f4\u9694\u65f6\u95f4\u5f80\u5f80\u9700\u8981\u6570\u5e74\uff0c\u5185\u5bb9\u66f4\u65b0\u975e\u5e38\u4e0d\u65b9\u4fbf\u3002\u4f46\u5728\u672c\u5f00\u6e90\u4e66\u4e2d\uff0c\u5185\u5bb9\u66f4\u8fed\u7684\u65f6\u95f4\u88ab\u7f29\u77ed\u81f3\u6570\u65e5\u751a\u81f3\u51e0\u4e2a\u5c0f\u65f6\u3002

    \u7531\u4e8e\u4f5c\u8005\u80fd\u529b\u6709\u9650\uff0c\u4e66\u4e2d\u96be\u514d\u5b58\u5728\u4e00\u4e9b\u9057\u6f0f\u548c\u9519\u8bef\uff0c\u8bf7\u60a8\u8c05\u89e3\u3002\u5982\u679c\u60a8\u53d1\u73b0\u4e86\u7b14\u8bef\u3001\u5931\u6548\u94fe\u63a5\u3001\u5185\u5bb9\u7f3a\u5931\u3001\u6587\u5b57\u6b67\u4e49\u3001\u89e3\u91ca\u4e0d\u6e05\u6670\u6216\u884c\u6587\u7ed3\u6784\u4e0d\u5408\u7406\u7b49\u95ee\u9898\uff0c\u8bf7\u534f\u52a9\u6211\u4eec\u8fdb\u884c\u4fee\u6b63\uff0c\u4ee5\u5e2e\u52a9\u5176\u4ed6\u8bfb\u8005\u83b7\u5f97\u66f4\u4f18\u8d28\u7684\u5b66\u4e60\u8d44\u6e90\u3002\u6240\u6709\u64b0\u7a3f\u4eba\u5c06\u5728\u4ed3\u5e93\u548c\u7f51\u7ad9\u4e3b\u9875\u4e0a\u5c55\u793a\uff0c\u4ee5\u611f\u8c22\u4ed6\u4eec\u5bf9\u5f00\u6e90\u793e\u533a\u7684\u65e0\u79c1\u5949\u732e\uff01

    "},{"location":"chapter_appendix/contribution/#1421","title":"14.2.1. \u00a0 \u5185\u5bb9\u5fae\u8c03","text":"

    \u5728\u6bcf\u4e2a\u9875\u9762\u7684\u53f3\u4e0a\u89d2\u6709\u4e00\u4e2a\u300c\u7f16\u8f91\u300d\u56fe\u6807\uff0c\u60a8\u53ef\u4ee5\u6309\u7167\u4ee5\u4e0b\u6b65\u9aa4\u4fee\u6539\u6587\u672c\u6216\u4ee3\u7801\uff1a

    1. \u70b9\u51fb\u7f16\u8f91\u6309\u94ae\uff0c\u5982\u679c\u9047\u5230\u201c\u9700\u8981 Fork \u6b64\u4ed3\u5e93\u201d\u7684\u63d0\u793a\uff0c\u8bf7\u540c\u610f\u8be5\u64cd\u4f5c\uff1b
    2. \u4fee\u6539 Markdown \u6e90\u6587\u4ef6\u5185\u5bb9\uff0c\u5e76\u786e\u4fdd\u5185\u5bb9\u6b63\u786e\uff0c\u540c\u65f6\u5c3d\u91cf\u4fdd\u6301\u6392\u7248\u683c\u5f0f\u7684\u7edf\u4e00\uff1b
    3. \u5728\u9875\u9762\u5e95\u90e8\u586b\u5199\u4fee\u6539\u8bf4\u660e\uff0c\u7136\u540e\u70b9\u51fb\u201cPropose file change\u201d\u6309\u94ae\uff1b\u9875\u9762\u8df3\u8f6c\u540e\uff0c\u70b9\u51fb\u201cCreate pull request\u201d\u6309\u94ae\u5373\u53ef\u53d1\u8d77\u62c9\u53d6\u8bf7\u6c42\u3002

    Fig. \u9875\u9762\u7f16\u8f91\u6309\u952e

    \u7531\u4e8e\u56fe\u7247\u65e0\u6cd5\u76f4\u63a5\u4fee\u6539\uff0c\u56e0\u6b64\u9700\u8981\u901a\u8fc7\u65b0\u5efa Issue \u6216\u8bc4\u8bba\u7559\u8a00\u6765\u63cf\u8ff0\u56fe\u7247\u95ee\u9898\uff0c\u6211\u4eec\u4f1a\u5c3d\u5feb\u91cd\u65b0\u7ed8\u5236\u5e76\u66ff\u6362\u56fe\u7247\u3002

    "},{"location":"chapter_appendix/contribution/#1422","title":"14.2.2. \u00a0 \u5185\u5bb9\u521b\u4f5c","text":"

    \u5982\u679c\u60a8\u6709\u5174\u8da3\u53c2\u4e0e\u6b64\u5f00\u6e90\u9879\u76ee\uff0c\u5305\u62ec\u5c06\u4ee3\u7801\u7ffb\u8bd1\u6210\u5176\u4ed6\u7f16\u7a0b\u8bed\u8a00\u3001\u6269\u5c55\u6587\u7ae0\u5185\u5bb9\u7b49\uff0c\u90a3\u4e48\u9700\u8981\u5b9e\u65bd Pull Request \u5de5\u4f5c\u6d41\u7a0b\uff1a

    1. \u767b\u5f55 GitHub \uff0c\u5c06\u672c\u4ed3\u5e93 Fork \u5230\u4e2a\u4eba\u8d26\u53f7\u4e0b\uff1b
    2. \u8fdb\u5165\u60a8\u7684 Fork \u4ed3\u5e93\u7f51\u9875\uff0c\u4f7f\u7528 git clone \u547d\u4ee4\u5c06\u4ed3\u5e93\u514b\u9686\u81f3\u672c\u5730\uff1b
    3. \u5728\u672c\u5730\u8fdb\u884c\u5185\u5bb9\u521b\u4f5c\uff0c\u5e76\u901a\u8fc7\u8fd0\u884c\u6d4b\u8bd5\u4ee5\u9a8c\u8bc1\u4ee3\u7801\u7684\u6b63\u786e\u6027\uff1b
    4. \u5c06\u672c\u5730\u6240\u505a\u66f4\u6539 Commit \uff0c\u7136\u540e Push \u81f3\u8fdc\u7a0b\u4ed3\u5e93\uff1b
    5. \u5237\u65b0\u4ed3\u5e93\u7f51\u9875\uff0c\u70b9\u51fb\u201cCreate pull request\u201d\u6309\u94ae\u5373\u53ef\u53d1\u8d77\u62c9\u53d6\u8bf7\u6c42\uff1b
    "},{"location":"chapter_appendix/contribution/#1423-docker","title":"14.2.3. \u00a0 Docker \u90e8\u7f72","text":"

    \u6211\u4eec\u53ef\u4ee5\u901a\u8fc7 Docker \u6765\u90e8\u7f72\u672c\u9879\u76ee\u3002\u6267\u884c\u4ee5\u4e0b\u811a\u672c\uff0c\u7a0d\u7b49\u7247\u523b\u540e\uff0c\u5373\u53ef\u4f7f\u7528\u6d4f\u89c8\u5668\u6253\u5f00 http://localhost:8000 \u6765\u8bbf\u95ee\u672c\u9879\u76ee\u3002

    git clone https://github.com/krahets/hello-algo.git\ncd hello-algo\ndocker-compose up -d\n

    \u4f7f\u7528\u4ee5\u4e0b\u547d\u4ee4\u5373\u53ef\u5220\u9664\u90e8\u7f72\u3002

    docker-compose down\n
    "},{"location":"chapter_appendix/installation/","title":"14.1. \u00a0 \u7f16\u7a0b\u73af\u5883\u5b89\u88c5","text":""},{"location":"chapter_appendix/installation/#1411-vscode","title":"14.1.1. \u00a0 VSCode","text":"

    \u672c\u4e66\u63a8\u8350\u4f7f\u7528\u5f00\u6e90\u8f7b\u91cf\u7684 VSCode \u4f5c\u4e3a\u672c\u5730 IDE \uff0c\u4e0b\u8f7d\u5e76\u5b89\u88c5 VSCode \u3002

    "},{"location":"chapter_appendix/installation/#1412-java","title":"14.1.2. \u00a0 Java \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 OpenJDK\uff08\u7248\u672c\u9700\u6ee1\u8db3 > JDK 9\uff09\u3002
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 java \uff0c\u5b89\u88c5 Extension Pack for Java \u3002
    "},{"location":"chapter_appendix/installation/#1413-cc","title":"14.1.3. \u00a0 C/C++ \u73af\u5883","text":"
    1. Windows \u7cfb\u7edf\u9700\u8981\u5b89\u88c5 MinGW\uff08\u914d\u7f6e\u6559\u7a0b\uff09\uff0cMacOS \u81ea\u5e26 Clang \u65e0\u9700\u5b89\u88c5\u3002
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 c++ \uff0c\u5b89\u88c5 C/C++ Extension Pack \u3002
    3. \uff08\u53ef\u9009\uff09\u6253\u5f00 Settings \u9875\u9762\uff0c\u641c\u7d22 Clang_format_fallback Style \u4ee3\u7801\u683c\u5f0f\u5316\u9009\u9879\uff0c\u8bbe\u7f6e\u4e3a { BasedOnStyle: Microsoft, BreakBeforeBraces: Attach } \u3002
    "},{"location":"chapter_appendix/installation/#1414-python","title":"14.1.4. \u00a0 Python \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Miniconda3 \u3002
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 python \uff0c\u5b89\u88c5 Python Extension Pack \u3002
    3. \uff08\u53ef\u9009\uff09\u5728\u547d\u4ee4\u884c\u8f93\u5165 pip install black \uff0c\u5b89\u88c5\u4ee3\u7801\u683c\u5f0f\u5316\u5de5\u5177\u3002
    "},{"location":"chapter_appendix/installation/#1415-go","title":"14.1.5. \u00a0 Go \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 go \u3002
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 go \uff0c\u5b89\u88c5 Go \u3002
    3. \u5feb\u6377\u952e Ctrl + Shift + P \u547c\u51fa\u547d\u4ee4\u680f\uff0c\u8f93\u5165 go \uff0c\u9009\u62e9 Go: Install/Update Tools \uff0c\u5168\u90e8\u52fe\u9009\u5e76\u5b89\u88c5\u5373\u53ef\u3002
    "},{"location":"chapter_appendix/installation/#1416-javascript","title":"14.1.6. \u00a0 JavaScript \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 node.js \u3002
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 javascript \uff0c\u5b89\u88c5 JavaScript (ES6) code snippets \u3002
    3. \uff08\u53ef\u9009\uff09\u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 Prettier \uff0c\u5b89\u88c5\u4ee3\u7801\u683c\u5f0f\u5316\u5de5\u5177\u3002
    "},{"location":"chapter_appendix/installation/#1417-c","title":"14.1.7. \u00a0 C# \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 .Net 6.0 \uff1b
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 c# \uff0c\u5b89\u88c5 c# \u3002
    "},{"location":"chapter_appendix/installation/#1418-swift","title":"14.1.8. \u00a0 Swift \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Swift\uff1b
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 swift \uff0c\u5b89\u88c5 Swift for Visual Studio Code\u3002
    "},{"location":"chapter_appendix/installation/#1419-rust","title":"14.1.9. \u00a0 Rust \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Rust\uff1b
    2. \u5728 VSCode \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 rust \uff0c\u5b89\u88c5 rust-analyzer\u3002
    "},{"location":"chapter_array_and_linkedlist/","title":"4. \u00a0 \u6570\u7ec4\u4e0e\u94fe\u8868","text":""},{"location":"chapter_array_and_linkedlist/array/","title":"4.1. \u00a0 \u6570\u7ec4","text":"

    \u300c\u6570\u7ec4 Array\u300d\u662f\u4e00\u79cd\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u5176\u5c06\u76f8\u540c\u7c7b\u578b\u5143\u7d20\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\u3002\u6211\u4eec\u5c06\u5143\u7d20\u5728\u6570\u7ec4\u4e2d\u7684\u4f4d\u7f6e\u79f0\u4e3a\u5143\u7d20\u7684\u300c\u7d22\u5f15 Index\u300d\u3002

    Fig. \u6570\u7ec4\u5b9a\u4e49\u4e0e\u5b58\u50a8\u65b9\u5f0f

    \u6570\u7ec4\u521d\u59cb\u5316\u3002\u901a\u5e38\u6709\u65e0\u521d\u59cb\u503c\u548c\u7ed9\u5b9a\u521d\u59cb\u503c\u4e24\u79cd\u65b9\u5f0f\uff0c\u6211\u4eec\u53ef\u6839\u636e\u9700\u6c42\u9009\u62e9\u5408\u9002\u7684\u65b9\u6cd5\u3002\u5728\u672a\u7ed9\u5b9a\u521d\u59cb\u503c\u7684\u60c5\u51b5\u4e0b\uff0c\u6570\u7ec4\u7684\u6240\u6709\u5143\u7d20\u901a\u5e38\u4f1a\u88ab\u521d\u59cb\u5316\u4e3a\u9ed8\u8ba4\u503c \\(0\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n
    array.cpp
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\n// \u5b58\u50a8\u5728\u6808\u4e0a\nint arr[5];\nint nums[5] { 1, 3, 2, 5, 4 };\n// \u5b58\u50a8\u5728\u5806\u4e0a\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n
    array.py
    # \u521d\u59cb\u5316\u6570\u7ec4\narr: List[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: List[int] = [1, 3, 2, 5, 4]  \n
    array.go
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nvar arr [5]int\n// \u5728 Go \u4e2d\uff0c\u6307\u5b9a\u957f\u5ea6\u65f6\uff08[5]int\uff09\u4e3a\u6570\u7ec4\uff0c\u4e0d\u6307\u5b9a\u957f\u5ea6\u65f6\uff08[]int\uff09\u4e3a\u5207\u7247\n// \u7531\u4e8e Go \u7684\u6570\u7ec4\u88ab\u8bbe\u8ba1\u4e3a\u5728\u7f16\u8bd1\u671f\u786e\u5b9a\u957f\u5ea6\uff0c\u56e0\u6b64\u53ea\u80fd\u4f7f\u7528\u5e38\u91cf\u6765\u6307\u5b9a\u957f\u5ea6\n// \u4e3a\u4e86\u65b9\u4fbf\u5b9e\u73b0\u6269\u5bb9 extend() \u65b9\u6cd5\uff0c\u4ee5\u4e0b\u5c06\u5207\u7247\uff08Slice\uff09\u770b\u4f5c\u6570\u7ec4\uff08Array\uff09\nnums := []int{1, 3, 2, 5, 4}\n
    array.js
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n
    array.ts
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n
    array.c
    int arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n
    array.cs
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n
    array.swift
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n
    array.zig
    // \u521d\u59cb\u5316\u6570\u7ec4\nvar arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }\nvar nums = [_]i32{ 1, 3, 2, 5, 4 };\n
    array.dart
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nList<int> arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList<int> nums = [1, 3, 2, 5, 4];\n
    "},{"location":"chapter_array_and_linkedlist/array/#411","title":"4.1.1. \u00a0 \u6570\u7ec4\u4f18\u70b9","text":"

    \u5728\u6570\u7ec4\u4e2d\u8bbf\u95ee\u5143\u7d20\u975e\u5e38\u9ad8\u6548\u3002\u7531\u4e8e\u6570\u7ec4\u5143\u7d20\u88ab\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\uff0c\u56e0\u6b64\u8ba1\u7b97\u6570\u7ec4\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\u975e\u5e38\u5bb9\u6613\u3002\u7ed9\u5b9a\u6570\u7ec4\u9996\u4e2a\u5143\u7d20\u7684\u5730\u5740\u548c\u67d0\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4ee5\u4e0b\u516c\u5f0f\u8ba1\u7b97\u5f97\u5230\u8be5\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\uff0c\u4ece\u800c\u76f4\u63a5\u8bbf\u95ee\u6b64\u5143\u7d20\u3002

    Fig. \u6570\u7ec4\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\u8ba1\u7b97 

    # \u5143\u7d20\u5185\u5b58\u5730\u5740 = \u6570\u7ec4\u5185\u5b58\u5730\u5740 + \u5143\u7d20\u957f\u5ea6 * \u5143\u7d20\u7d22\u5f15\nelementAddr = firtstElementAddr + elementLength * elementIndex\n

    \u4e3a\u4ec0\u4e48\u6570\u7ec4\u5143\u7d20\u7684\u7d22\u5f15\u8981\u4ece \\(0\\) \u5f00\u59cb\u7f16\u53f7\u5462\uff1f

    \u89c2\u5bdf\u4e0a\u56fe\uff0c\u6211\u4eec\u53d1\u73b0\u6570\u7ec4\u9996\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\u4e3a \\(0\\) \uff0c\u8fd9\u4f3c\u4e4e\u6709\u4e9b\u53cd\u76f4\u89c9\uff0c\u56e0\u4e3a\u4ece \\(1\\) \u5f00\u59cb\u8ba1\u6570\u4f1a\u66f4\u81ea\u7136\u3002

    \u7136\u800c\uff0c\u4ece\u5730\u5740\u8ba1\u7b97\u516c\u5f0f\u7684\u89d2\u5ea6\u770b\uff0c\u7d22\u5f15\u672c\u8d28\u4e0a\u8868\u793a\u7684\u662f\u5185\u5b58\u5730\u5740\u7684\u504f\u79fb\u91cf\u3002\u9996\u4e2a\u5143\u7d20\u7684\u5730\u5740\u504f\u79fb\u91cf\u662f \\(0\\) \uff0c\u56e0\u6b64\u7d22\u5f15\u4e3a \\(0\\) \u4e5f\u662f\u5408\u7406\u7684\u3002

    \u8bbf\u95ee\u5143\u7d20\u7684\u9ad8\u6548\u6027\u5e26\u6765\u4e86\u8bf8\u591a\u4fbf\u5229\u3002\u4f8b\u5982\uff0c\u6211\u4eec\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u968f\u673a\u83b7\u53d6\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u4e00\u4e2a\u5143\u7d20\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nint randomAccess(int[] nums) {\n// \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nint randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nint randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    array.cpp
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n// \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nint randomIndex = rand() % size;\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nint randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    array.py
    def random_access(nums: list[int]) -> int:\n\"\"\"\u968f\u673a\u8bbf\u95ee\u5143\u7d20\"\"\"\n# \u5728\u533a\u95f4 [0, len(nums)-1] \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nrandom_index = random.randint(0, len(nums) - 1)\n# \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nrandom_num = nums[random_index]\nreturn random_num\n
    array.go
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nfunc randomAccess(nums []int) (randomNum int) {\n// \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nrandomIndex := rand.Intn(len(nums))\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nrandomNum = nums[randomIndex]\nreturn\n}\n
    array.js
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nfunction randomAccess(nums) {\n// \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nconst random_index = Math.floor(Math.random() * nums.length);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nconst random_num = nums[random_index];\nreturn random_num;\n}\n
    array.ts
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nfunction randomAccess(nums: number[]): number {\n// \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nconst random_index = Math.floor(Math.random() * nums.length);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nconst random_num = nums[random_index];\nreturn random_num;\n}\n
    array.c
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n// \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nint randomIndex = rand() % size;\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nint randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    array.cs
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nint randomAccess(int[] nums) {\nRandom random = new();\n// \u5728\u533a\u95f4 [0, nums.Length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nint randomIndex = random.Next(nums.Length);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nint randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    array.swift
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nfunc randomAccess(nums: [Int]) -> Int {\n// \u5728\u533a\u95f4 [0, nums.count) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nlet randomIndex = nums.indices.randomElement()!\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nlet randomNum = nums[randomIndex]\nreturn randomNum\n}\n
    array.zig
    // \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20\nfn randomAccess(nums: []i32) i32 {\n// \u5728\u533a\u95f4 [0, nums.len) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6574\u6570\nvar randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nvar randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    array.dart
    /* \u968f\u673a\u8fd4\u56de\u4e00\u4e2a\u6570\u7ec4\u5143\u7d20 */\nint randomAccess(List nums) {\n// \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\nint randomIndex = Random().nextInt(nums.length);\n// \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\nint randomNum = nums[randomIndex];\nreturn randomNum;\n}\n
    "},{"location":"chapter_array_and_linkedlist/array/#412","title":"4.1.2. \u00a0 \u6570\u7ec4\u7f3a\u70b9","text":"

    \u6570\u7ec4\u5728\u521d\u59cb\u5316\u540e\u957f\u5ea6\u4e0d\u53ef\u53d8\u3002\u7531\u4e8e\u7cfb\u7edf\u65e0\u6cd5\u4fdd\u8bc1\u6570\u7ec4\u4e4b\u540e\u7684\u5185\u5b58\u7a7a\u95f4\u662f\u53ef\u7528\u7684\uff0c\u56e0\u6b64\u6570\u7ec4\u957f\u5ea6\u65e0\u6cd5\u6269\u5c55\u3002\u800c\u82e5\u5e0c\u671b\u6269\u5bb9\u6570\u7ec4\uff0c\u5219\u9700\u65b0\u5efa\u4e00\u4e2a\u6570\u7ec4\uff0c\u7136\u540e\u628a\u539f\u6570\u7ec4\u5143\u7d20\u4f9d\u6b21\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\uff0c\u5728\u6570\u7ec4\u5f88\u5927\u7684\u60c5\u51b5\u4e0b\uff0c\u8fd9\u662f\u975e\u5e38\u8017\u65f6\u7684\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nint[] extend(int[] nums, int enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nint[] res = new int[nums.length + enlarge];\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (int i = 0; i < nums.length; i++) {\nres[i] = nums[i];\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.cpp
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nint *extend(int *nums, int size, int enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nint *res = new int[size + enlarge];\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (int i = 0; i < size; i++) {\nres[i] = nums[i];\n}\n// \u91ca\u653e\u5185\u5b58\ndelete[] nums;\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.py
    def extend(nums: list[int], enlarge: int) -> list[int]:\n\"\"\"\u6269\u5c55\u6570\u7ec4\u957f\u5ea6\"\"\"\n# \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nres = [0] * (len(nums) + enlarge)\n# \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor i in range(len(nums)):\nres[i] = nums[i]\n# \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res\n
    array.go
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfunc extend(nums []int, enlarge int) []int {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nres := make([]int, len(nums)+enlarge)\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor i, num := range nums {\nres[i] = num\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res\n}\n
    array.js
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\n// \u8bf7\u6ce8\u610f\uff0cJavaScript \u7684 Array \u662f\u52a8\u6001\u6570\u7ec4\uff0c\u53ef\u4ee5\u76f4\u63a5\u6269\u5c55\n// \u4e3a\u4e86\u65b9\u4fbf\u5b66\u4e60\uff0c\u672c\u51fd\u6570\u5c06 Array \u770b\u4f5c\u662f\u957f\u5ea6\u4e0d\u53ef\u53d8\u7684\u6570\u7ec4\nfunction extend(nums, enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nconst res = new Array(nums.length + enlarge).fill(0);\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (let i = 0; i < nums.length; i++) {\nres[i] = nums[i];\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.ts
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\n// \u8bf7\u6ce8\u610f\uff0cTypeScript \u7684 Array \u662f\u52a8\u6001\u6570\u7ec4\uff0c\u53ef\u4ee5\u76f4\u63a5\u6269\u5c55\n// \u4e3a\u4e86\u65b9\u4fbf\u5b66\u4e60\uff0c\u672c\u51fd\u6570\u5c06 Array \u770b\u4f5c\u662f\u957f\u5ea6\u4e0d\u53ef\u53d8\u7684\u6570\u7ec4\nfunction extend(nums: number[], enlarge: number): number[] {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nconst res = new Array(nums.length + enlarge).fill(0);\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (let i = 0; i < nums.length; i++) {\nres[i] = nums[i];\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.c
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nint *extend(int *nums, int size, int enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nint *res = (int *)malloc(sizeof(int) * (size + enlarge));\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (int i = 0; i < size; i++) {\nres[i] = nums[i];\n}\n// \u521d\u59cb\u5316\u6269\u5c55\u540e\u7684\u7a7a\u95f4\nfor (int i = size; i < size + enlarge; i++) {\nres[i] = 0;\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.cs
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nint[] extend(int[] nums, int enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nint[] res = new int[nums.Length + enlarge];\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (int i = 0; i < nums.Length; i++) {\nres[i] = nums[i];\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.swift
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfunc extend(nums: [Int], enlarge: Int) -> [Int] {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nvar res = Array(repeating: 0, count: nums.count + enlarge)\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor i in nums.indices {\nres[i] = nums[i]\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res\n}\n
    array.zig
    // \u6269\u5c55\u6570\u7ec4\u957f\u5ea6\nfn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nvar res = try mem_allocator.alloc(i32, nums.len + enlarge);\n@memset(res, 0);\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nstd.mem.copy(i32, res, nums);\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n
    array.dart
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nList extend(List nums, int enlarge) {\n// \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\nList<int> res = List.filled(nums.length + enlarge, 0);\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (var i = 0; i < nums.length; i++) {\nres[i] = nums[i];\n}\n// \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\nreturn res;\n}\n

    \u6570\u7ec4\u4e2d\u63d2\u5165\u6216\u5220\u9664\u5143\u7d20\u6548\u7387\u4f4e\u4e0b\u3002\u5982\u679c\u6211\u4eec\u60f3\u8981\u5728\u6570\u7ec4\u4e2d\u95f4\u63d2\u5165\u4e00\u4e2a\u5143\u7d20\uff0c\u7531\u4e8e\u6570\u7ec4\u5143\u7d20\u5728\u5185\u5b58\u4e2d\u662f\u201c\u7d27\u6328\u7740\u7684\u201d\uff0c\u5b83\u4eec\u4e4b\u95f4\u6ca1\u6709\u7a7a\u95f4\u518d\u653e\u4efb\u4f55\u6570\u636e\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u4e0d\u5f97\u4e0d\u5c06\u6b64\u7d22\u5f15\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u7136\u540e\u518d\u628a\u5143\u7d20\u8d4b\u503c\u7ed9\u8be5\u7d22\u5f15\u3002

    Fig. \u6570\u7ec4\u63d2\u5165\u5143\u7d20

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nvoid insert(int[] nums, int num, int index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int i = nums.length - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.cpp
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nvoid insert(int *nums, int size, int num, int index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int i = size - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.py
    def insert(nums: list[int], num: int, index: int) -> None:\n\"\"\"\u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num\"\"\"\n# \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor i in range(len(nums) - 1, index, -1):\nnums[i] = nums[i - 1]\n# \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num\n
    array.go
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfunc insert(nums []int, num int, index int) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor i := len(nums) - 1; i > index; i-- {\nnums[i] = nums[i-1]\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num\n}\n
    array.js
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfunction insert(nums, num, index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (let i = nums.length - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.ts
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfunction insert(nums: number[], num: number, index: number): void {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (let i = nums.length - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.c
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nvoid insert(int *nums, int size, int num, int index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int i = size - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.cs
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nvoid insert(int[] nums, int num, int index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int i = nums.Length - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.swift
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfunc insert(nums: inout [Int], num: Int, index: Int) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor i in sequence(first: nums.count - 1, next: { $0 > index + 1 ? $0 - 1 : nil }) {\nnums[i] = nums[i - 1]\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num\n}\n
    array.zig
    // \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num\nfn insert(nums: []i32, num: i32, index: usize) void {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nvar i = nums.len - 1;\nwhile (i > index) : (i -= 1) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nvoid insert(List nums, int num, int index) {\n// \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (var i = nums.length - 1; i > index; i--) {\nnums[i] = nums[i - 1];\n}\n// \u5c06 num \u8d4b\u7ed9 index \u5904\u5143\u7d20\nnums[index] = num;\n}\n

    \u5220\u9664\u5143\u7d20\u4e5f\u7c7b\u4f3c\uff0c\u5982\u679c\u6211\u4eec\u60f3\u8981\u5220\u9664\u7d22\u5f15 \\(i\\) \u5904\u7684\u5143\u7d20\uff0c\u5219\u9700\u8981\u628a\u7d22\u5f15 \\(i\\) \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u5220\u9664\u5143\u7d20\u540e\uff0c\u539f\u5148\u672b\u5c3e\u7684\u5143\u7d20\u53d8\u5f97\u201c\u65e0\u610f\u4e49\u201d\u4e86\uff0c\u6211\u4eec\u65e0\u9700\u7279\u610f\u53bb\u4fee\u6539\u5b83\u3002

    Fig. \u6570\u7ec4\u5220\u9664\u5143\u7d20

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nvoid remove(int[] nums, int index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int i = index; i < nums.length - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.cpp
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nvoid remove(int *nums, int size, int index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int i = index; i < size - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.py
    def remove(nums: list[int], index: int) -> None:\n\"\"\"\u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20\"\"\"\n# \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor i in range(index, len(nums) - 1):\nnums[i] = nums[i + 1]\n
    array.go
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nfunc remove(nums []int, index int) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor i := index; i < len(nums)-1; i++ {\nnums[i] = nums[i+1]\n}\n}\n
    array.js
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nfunction remove(nums, index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (let i = index; i < nums.length - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.ts
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nfunction remove(nums: number[], index: number): void {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (let i = index; i < nums.length - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.c
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\n// \u6ce8\u610f\uff1astdio.h \u5360\u7528\u4e86 remove \u5173\u952e\u8bcd\nvoid removeItem(int *nums, int size, int index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int i = index; i < size - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.cs
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nvoid remove(int[] nums, int index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int i = index; i < nums.Length - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.swift
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nfunc remove(nums: inout [Int], index: Int) {\nlet count = nums.count\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor i in sequence(first: index, next: { $0 < count - 1 - 1 ? $0 + 1 : nil }) {\nnums[i] = nums[i + 1]\n}\n}\n
    array.zig
    // \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20\nfn remove(nums: []i32, index: usize) void {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nvar i = index;\nwhile (i < nums.len - 1) : (i += 1) {\nnums[i] = nums[i + 1];\n}\n}\n
    array.dart
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u5143\u7d20 */\nvoid remove(List nums, int index) {\n// \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (var i = index; i < nums.length - 1; i++) {\nnums[i] = nums[i + 1];\n}\n}\n

    \u603b\u7ed3\u6765\u770b\uff0c\u6570\u7ec4\u7684\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u6709\u4ee5\u4e0b\u7f3a\u70b9\uff1a

    • \u65f6\u95f4\u590d\u6742\u5ea6\u9ad8\uff1a\u6570\u7ec4\u7684\u63d2\u5165\u548c\u5220\u9664\u7684\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(n)\\) \uff0c\u5176\u4e2d \\(n\\) \u4e3a\u6570\u7ec4\u957f\u5ea6\u3002
    • \u4e22\u5931\u5143\u7d20\uff1a\u7531\u4e8e\u6570\u7ec4\u7684\u957f\u5ea6\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u5728\u63d2\u5165\u5143\u7d20\u540e\uff0c\u8d85\u51fa\u6570\u7ec4\u957f\u5ea6\u8303\u56f4\u7684\u5143\u7d20\u4f1a\u4e22\u5931\u3002
    • \u5185\u5b58\u6d6a\u8d39\uff1a\u6211\u4eec\u53ef\u4ee5\u521d\u59cb\u5316\u4e00\u4e2a\u6bd4\u8f83\u957f\u7684\u6570\u7ec4\uff0c\u53ea\u7528\u524d\u9762\u4e00\u90e8\u5206\uff0c\u8fd9\u6837\u5728\u63d2\u5165\u6570\u636e\u65f6\uff0c\u4e22\u5931\u7684\u672b\u5c3e\u5143\u7d20\u90fd\u662f\u6211\u4eec\u4e0d\u5173\u5fc3\u7684\uff0c\u4f46\u8fd9\u6837\u505a\u540c\u65f6\u4e5f\u4f1a\u9020\u6210\u5185\u5b58\u7a7a\u95f4\u7684\u6d6a\u8d39\u3002
    "},{"location":"chapter_array_and_linkedlist/array/#413","title":"4.1.3. \u00a0 \u6570\u7ec4\u5e38\u7528\u64cd\u4f5c","text":"

    \u6570\u7ec4\u904d\u5386\u3002\u4ee5\u4e0b\u4ecb\u7ecd\u4e24\u79cd\u5e38\u7528\u7684\u904d\u5386\u65b9\u6cd5\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int[] nums) {\nint count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (int i = 0; i < nums.length; i++) {\ncount++;\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor (int num : nums) {\ncount++;\n}\n}\n
    array.cpp
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\nint count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (int i = 0; i < size; i++) {\ncount++;\n}\n}\n
    array.py
    def traverse(nums: list[int]) -> None:\n\"\"\"\u904d\u5386\u6570\u7ec4\"\"\"\ncount = 0\n# \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor i in range(len(nums)):\ncount += 1\n# \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor num in nums:\ncount += 1\n# \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\nfor i, num in enumerate(nums):\ncount += 1\n
    array.go
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums []int) {\ncount := 0\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor i := 0; i < len(nums); i++ {\ncount++\n}\ncount = 0\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor range nums {\ncount++\n}\n}\n
    array.js
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums) {\nlet count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (let i = 0; i < nums.length; i++) {\ncount++;\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor (let num of nums) {\ncount += 1;\n}\n}\n
    array.ts
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums: number[]): void {\nlet count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (let i = 0; i < nums.length; i++) {\ncount++;\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor (let num of nums) {\ncount += 1;\n}\n}\n
    array.c
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\nint count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (int i = 0; i < size; i++) {\ncount++;\n}\n}\n
    array.cs
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int[] nums) {\nint count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (int i = 0; i < nums.Length; i++) {\ncount++;\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nforeach (int num in nums) {\ncount++;\n}\n}\n
    array.swift
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums: [Int]) {\nvar count = 0\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor _ in nums.indices {\ncount += 1\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor _ in nums {\ncount += 1\n}\n}\n
    array.zig
    // \u904d\u5386\u6570\u7ec4\nfn traverse(nums: []i32) void {\nvar count: i32 = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nvar i: i32 = 0;\nwhile (i < nums.len) : (i += 1) {\ncount += 1;\n}\ncount = 0;\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor (nums) |_| {\ncount += 1;\n}\n}\n
    array.dart
    /* \u904d\u5386\u6570\u7ec4\u5143\u7d20 */\nvoid traverse(List nums) {\nvar count = 0;\n// \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\nfor (var i = 0; i < nums.length; i++) {\ncount++;\n}\n// \u76f4\u63a5\u904d\u5386\u6570\u7ec4\nfor (var num in nums) {\ncount++;\n}\n// \u901a\u8fc7 forEach \u65b9\u6cd5\u904d\u5386\u6570\u7ec4\nnums.forEach((element) {\ncount++;\n});\n}\n

    \u6570\u7ec4\u67e5\u627e\u3002\u901a\u8fc7\u904d\u5386\u6570\u7ec4\uff0c\u67e5\u627e\u6570\u7ec4\u5185\u7684\u6307\u5b9a\u5143\u7d20\uff0c\u5e76\u8f93\u51fa\u5bf9\u5e94\u7d22\u5f15\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array.java
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int[] nums, int target) {\nfor (int i = 0; i < nums.length; i++) {\nif (nums[i] == target)\nreturn i;\n}\nreturn -1;\n}\n
    array.cpp
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\nfor (int i = 0; i < size; i++) {\nif (nums[i] == target)\nreturn i;\n}\nreturn -1;\n}\n
    array.py
    def find(nums: list[int], target: int) -> int:\n\"\"\"\u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\"\"\"\nfor i in range(len(nums)):\nif nums[i] == target:\nreturn i\nreturn -1\n
    array.go
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums []int, target int) (index int) {\nindex = -1\nfor i := 0; i < len(nums); i++ {\nif nums[i] == target {\nindex = i\nbreak\n}\n}\nreturn\n}\n
    array.js
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums, target) {\nfor (let i = 0; i < nums.length; i++) {\nif (nums[i] == target) return i;\n}\nreturn -1;\n}\n
    array.ts
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums: number[], target: number): number {\nfor (let i = 0; i < nums.length; i++) {\nif (nums[i] === target) {\nreturn i;\n}\n}\nreturn -1;\n}\n
    array.c
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\nfor (int i = 0; i < size; i++) {\nif (nums[i] == target)\nreturn i;\n}\nreturn -1;\n}\n
    array.cs
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int[] nums, int target) {\nfor (int i = 0; i < nums.Length; i++) {\nif (nums[i] == target)\nreturn i;\n}\nreturn -1;\n}\n
    array.swift
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums: [Int], target: Int) -> Int {\nfor i in nums.indices {\nif nums[i] == target {\nreturn i\n}\n}\nreturn -1\n}\n
    array.zig
    // \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\nfn find(nums: []i32, target: i32) i32 {\nfor (nums, 0..) |num, i| {\nif (num == target) return @intCast(i);\n}\nreturn -1;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(List nums, int target) {\nfor (var i = 0; i < nums.length; i++) {\nif (nums[i] == target) return i;\n}\nreturn -1;\n}\n
    "},{"location":"chapter_array_and_linkedlist/array/#414","title":"4.1.4. \u00a0 \u6570\u7ec4\u5178\u578b\u5e94\u7528","text":"

    \u968f\u673a\u8bbf\u95ee\u3002\u5982\u679c\u6211\u4eec\u60f3\u8981\u968f\u673a\u62bd\u53d6\u4e00\u4e9b\u6837\u672c\uff0c\u90a3\u4e48\u53ef\u4ee5\u7528\u6570\u7ec4\u5b58\u50a8\uff0c\u5e76\u751f\u6210\u4e00\u4e2a\u968f\u673a\u5e8f\u5217\uff0c\u6839\u636e\u7d22\u5f15\u5b9e\u73b0\u6837\u672c\u7684\u968f\u673a\u62bd\u53d6\u3002

    \u4e8c\u5206\u67e5\u627e\u3002\u4f8b\u5982\u524d\u6587\u67e5\u5b57\u5178\u7684\u4f8b\u5b50\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5b57\u5178\u4e2d\u7684\u6240\u6709\u5b57\u6309\u7167\u62fc\u97f3\u987a\u5e8f\u5b58\u50a8\u5728\u6570\u7ec4\u4e2d\uff0c\u7136\u540e\u4f7f\u7528\u4e0e\u65e5\u5e38\u67e5\u7eb8\u8d28\u5b57\u5178\u76f8\u540c\u7684\u201c\u7ffb\u5f00\u4e2d\u95f4\uff0c\u6392\u9664\u4e00\u534a\u201d\u7684\u65b9\u5f0f\uff0c\u6765\u5b9e\u73b0\u4e00\u4e2a\u67e5\u7535\u5b50\u5b57\u5178\u7684\u7b97\u6cd5\u3002

    \u6df1\u5ea6\u5b66\u4e60\u3002\u795e\u7ecf\u7f51\u7edc\u4e2d\u5927\u91cf\u4f7f\u7528\u4e86\u5411\u91cf\u3001\u77e9\u9635\u3001\u5f20\u91cf\u4e4b\u95f4\u7684\u7ebf\u6027\u4ee3\u6570\u8fd0\u7b97\uff0c\u8fd9\u4e9b\u6570\u636e\u90fd\u662f\u4ee5\u6570\u7ec4\u7684\u5f62\u5f0f\u6784\u5efa\u7684\u3002\u6570\u7ec4\u662f\u795e\u7ecf\u7f51\u7edc\u7f16\u7a0b\u4e2d\u6700\u5e38\u4f7f\u7528\u7684\u6570\u636e\u7ed3\u6784\u3002

    "},{"location":"chapter_array_and_linkedlist/linked_list/","title":"4.2. \u00a0 \u94fe\u8868","text":"

    \u5185\u5b58\u7a7a\u95f4\u662f\u6240\u6709\u7a0b\u5e8f\u7684\u516c\u5171\u8d44\u6e90\uff0c\u6392\u9664\u5df2\u88ab\u5360\u7528\u7684\u5185\u5b58\u7a7a\u95f4\uff0c\u7a7a\u95f2\u5185\u5b58\u7a7a\u95f4\u901a\u5e38\u6563\u843d\u5728\u5185\u5b58\u5404\u5904\u3002\u5728\u4e0a\u4e00\u8282\u4e2d\uff0c\u6211\u4eec\u63d0\u5230\u5b58\u50a8\u6570\u7ec4\u7684\u5185\u5b58\u7a7a\u95f4\u5fc5\u987b\u662f\u8fde\u7eed\u7684\uff0c\u800c\u5f53\u6211\u4eec\u9700\u8981\u7533\u8bf7\u4e00\u4e2a\u975e\u5e38\u5927\u7684\u6570\u7ec4\u65f6\uff0c\u7a7a\u95f2\u5185\u5b58\u4e2d\u53ef\u80fd\u6ca1\u6709\u8fd9\u4e48\u5927\u7684\u8fde\u7eed\u7a7a\u95f4\u3002\u4e0e\u6570\u7ec4\u76f8\u6bd4\uff0c\u94fe\u8868\u66f4\u5177\u7075\u6d3b\u6027\uff0c\u5b83\u53ef\u4ee5\u88ab\u5b58\u50a8\u5728\u975e\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\u3002

    \u300c\u94fe\u8868 Linked List\u300d\u662f\u4e00\u79cd\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u5176\u6bcf\u4e2a\u5143\u7d20\u90fd\u662f\u4e00\u4e2a\u8282\u70b9\u5bf9\u8c61\uff0c\u5404\u4e2a\u8282\u70b9\u4e4b\u95f4\u901a\u8fc7\u6307\u9488\u8fde\u63a5\uff0c\u4ece\u5f53\u524d\u8282\u70b9\u901a\u8fc7\u6307\u9488\u53ef\u4ee5\u8bbf\u95ee\u5230\u4e0b\u4e00\u4e2a\u8282\u70b9\u3002\u7531\u4e8e\u6307\u9488\u8bb0\u5f55\u4e86\u4e0b\u4e2a\u8282\u70b9\u7684\u5185\u5b58\u5730\u5740\uff0c\u56e0\u6b64\u65e0\u9700\u4fdd\u8bc1\u5185\u5b58\u5730\u5740\u7684\u8fde\u7eed\u6027\uff0c\u4ece\u800c\u53ef\u4ee5\u5c06\u5404\u4e2a\u8282\u70b9\u5206\u6563\u5b58\u50a8\u5728\u5185\u5b58\u5404\u5904\u3002

    \u94fe\u8868\u300c\u8282\u70b9 Node\u300d\u5305\u542b\u4e24\u9879\u6570\u636e\uff0c\u4e00\u662f\u8282\u70b9\u300c\u503c Value\u300d\uff0c\u4e8c\u662f\u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u300c\u6307\u9488 Pointer\u300d\uff0c\u6216\u79f0\u300c\u5f15\u7528 Reference\u300d\u3002

    Fig. \u94fe\u8868\u5b9a\u4e49\u4e0e\u5b58\u50a8\u65b9\u5f0f

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nint val;        // \u8282\u70b9\u503c\nListNode next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(int x) { val = x; }  // \u6784\u9020\u51fd\u6570\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\nint val;         // \u8282\u70b9\u503c\nListNode *next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(int x) : val(x), next(nullptr) {}  // \u6784\u9020\u51fd\u6570\n};\n
    class ListNode:\n\"\"\"\u94fe\u8868\u8282\u70b9\u7c7b\"\"\"\ndef __init__(self, val: int):\nself.val: int = val                  # \u8282\u70b9\u503c\nself.next: Optional[ListNode] = None # \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype ListNode struct {\nVal  int       // \u8282\u70b9\u503c\nNext *ListNode // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n}\n// NewListNode \u6784\u9020\u51fd\u6570\uff0c\u521b\u5efa\u4e00\u4e2a\u65b0\u7684\u94fe\u8868\nfunc NewListNode(val int) *ListNode {\nreturn &ListNode{\nVal:  val,\nNext: nil,\n}\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nval;\nnext;\nconstructor(val, next) {\nthis.val = (val === undefined ? 0 : val);       // \u8282\u70b9\u503c\nthis.next = (next === undefined ? null : next); // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n}\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nval: number;\nnext: ListNode | null;\nconstructor(val?: number, next?: ListNode | null) {\nthis.val = val === undefined ? 0 : val;        // \u8282\u70b9\u503c\nthis.next = next === undefined ? null : next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n}\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\nint val;               // \u8282\u70b9\u503c\nstruct ListNode *next; // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n};\ntypedef struct ListNode ListNode;\n/* \u6784\u9020\u51fd\u6570 */\nListNode *newListNode(int val) {\nListNode *node, *next;\nnode = (ListNode *) malloc(sizeof(ListNode));\nnode->val = val;\nnode->next = NULL;\nreturn node;\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode\n{\nint val;         // \u8282\u70b9\u503c\nListNode next;   // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\nListNode(int x) => val = x;  //\u6784\u9020\u51fd\u6570\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nvar val: Int // \u8282\u70b9\u503c\nvar next: ListNode? // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\ninit(x: Int) { // \u6784\u9020\u51fd\u6570\nval = x\n}\n}\n
    // \u94fe\u8868\u8282\u70b9\u7c7b\npub fn ListNode(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nval: T = 0, // \u8282\u70b9\u503c\nnext: ?*Self = null, // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n// \u6784\u9020\u51fd\u6570\npub fn init(self: *Self, x: i32) void {\nself.val = x;\nself.next = null;\n}\n};\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nint val; // \u8282\u70b9\u503c\nListNode? next; // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(this.val, [this.next]); // \u6784\u9020\u51fd\u6570\n}\n

    \u5c3e\u8282\u70b9\u6307\u5411\u4ec0\u4e48\uff1f

    \u6211\u4eec\u5c06\u94fe\u8868\u7684\u6700\u540e\u4e00\u4e2a\u8282\u70b9\u79f0\u4e3a\u300c\u5c3e\u8282\u70b9\u300d\uff0c\u5176\u6307\u5411\u7684\u662f\u201c\u7a7a\u201d\uff0c\u5728 Java, C++, Python \u4e2d\u5206\u522b\u8bb0\u4e3a \\(\\text{null}\\) , \\(\\text{nullptr}\\) , \\(\\text{None}\\) \u3002\u5728\u4e0d\u5f15\u8d77\u6b67\u4e49\u7684\u524d\u63d0\u4e0b\uff0c\u672c\u4e66\u90fd\u4f7f\u7528 \\(\\text{None}\\) \u6765\u8868\u793a\u7a7a\u3002

    \u5982\u4f55\u79f0\u547c\u94fe\u8868\uff1f

    \u5728\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u6570\u7ec4\u6574\u4f53\u5c31\u662f\u4e00\u4e2a\u53d8\u91cf\uff0c\u4f8b\u5982\u6570\u7ec4 nums \uff0c\u5305\u542b\u5404\u4e2a\u5143\u7d20 nums[0] , nums[1] \u7b49\u7b49\u3002\u800c\u94fe\u8868\u662f\u7531\u591a\u4e2a\u8282\u70b9\u5bf9\u8c61\u7ec4\u6210\uff0c\u6211\u4eec\u901a\u5e38\u5c06\u5934\u8282\u70b9\u5f53\u4f5c\u94fe\u8868\u7684\u4ee3\u79f0\uff0c\u4f8b\u5982\u5934\u8282\u70b9 head \u548c\u94fe\u8868 head \u5b9e\u9645\u4e0a\u662f\u540c\u4e49\u7684\u3002

    \u94fe\u8868\u521d\u59cb\u5316\u65b9\u6cd5\u3002\u5efa\u7acb\u94fe\u8868\u5206\u4e3a\u4e24\u6b65\uff0c\u7b2c\u4e00\u6b65\u662f\u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\u5bf9\u8c61\uff0c\u7b2c\u4e8c\u6b65\u662f\u6784\u5efa\u5f15\u7528\u6307\u5411\u5173\u7cfb\u3002\u5b8c\u6210\u540e\uff0c\u5373\u53ef\u4ee5\u4ece\u94fe\u8868\u7684\u5934\u8282\u70b9\uff08\u5373\u9996\u4e2a\u8282\u70b9\uff09\u51fa\u53d1\uff0c\u901a\u8fc7\u6307\u9488 next \u4f9d\u6b21\u8bbf\u95ee\u6240\u6709\u8282\u70b9\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linked_list.java
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.cpp
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nListNode* n0 = new ListNode(1);\nListNode* n1 = new ListNode(3);\nListNode* n2 = new ListNode(2);\nListNode* n3 = new ListNode(5);\nListNode* n4 = new ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    linked_list.py
    # \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4\n# \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n
    linked_list.go
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n
    linked_list.js
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.ts
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nconst n0 = new ListNode(1);\nconst n1 = new ListNode(3);\nconst n2 = new ListNode(2);\nconst n3 = new ListNode(5);\nconst n4 = new ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.c
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    linked_list.cs
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nListNode n0 = new ListNode(1);\nListNode n1 = new ListNode(3);\nListNode n2 = new ListNode(2);\nListNode n3 = new ListNode(5);\nListNode n4 = new ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.swift
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nlet n0 = ListNode(x: 1)\nlet n1 = ListNode(x: 3)\nlet n2 = ListNode(x: 2)\nlet n3 = ListNode(x: 5)\nlet n4 = ListNode(x: 4)\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n
    linked_list.zig
    // \u521d\u59cb\u5316\u94fe\u8868\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9 \nvar n0 = inc.ListNode(i32){.val = 1};\nvar n1 = inc.ListNode(i32){.val = 3};\nvar n2 = inc.ListNode(i32){.val = 2};\nvar n3 = inc.ListNode(i32){.val = 5};\nvar n4 = inc.ListNode(i32){.val = 4};\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = &n1;\nn1.next = &n2;\nn2.next = &n3;\nn3.next = &n4;\n
    linked_list.dart
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\\\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    "},{"location":"chapter_array_and_linkedlist/linked_list/#421","title":"4.2.1. \u00a0 \u94fe\u8868\u4f18\u70b9","text":"

    \u94fe\u8868\u4e2d\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u7684\u64cd\u4f5c\u6548\u7387\u9ad8\u3002\u4f8b\u5982\uff0c\u5982\u679c\u6211\u4eec\u60f3\u5728\u94fe\u8868\u4e2d\u95f4\u7684\u4e24\u4e2a\u8282\u70b9 A , B \u4e4b\u95f4\u63d2\u5165\u4e00\u4e2a\u65b0\u8282\u70b9 P \uff0c\u6211\u4eec\u53ea\u9700\u8981\u6539\u53d8\u4e24\u4e2a\u8282\u70b9\u6307\u9488\u5373\u53ef\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \uff1b\u76f8\u6bd4\u4e4b\u4e0b\uff0c\u6570\u7ec4\u7684\u63d2\u5165\u64cd\u4f5c\u6548\u7387\u8981\u4f4e\u5f97\u591a\u3002

    Fig. \u94fe\u8868\u63d2\u5165\u8282\u70b9

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linked_list.java
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode n0, ListNode P) {\nListNode n1 = n0.next;\nP.next = n1;\nn0.next = P;\n}\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode *n0, ListNode *P) {\nListNode *n1 = n0->next;\nP->next = n1;\nn0->next = P;\n}\n
    linked_list.py
    def insert(n0: ListNode, P: ListNode) -> None:\n\"\"\"\u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P\"\"\"\nn1 = n0.next\nP.next = n1\nn0.next = P\n
    linked_list.go
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunc insertNode(n0 *ListNode, P *ListNode) {\nn1 := n0.Next\nP.Next = n1\nn0.Next = P\n}\n
    linked_list.js
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunction insert(n0, P) {\nconst n1 = n0.next;\nP.next = n1;\nn0.next = P;\n}\n
    linked_list.ts
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunction insert(n0: ListNode, P: ListNode): void {\nconst n1 = n0.next;\nP.next = n1;\nn0.next = P;\n}\n
    linked_list.c
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode *n0, ListNode *P) {\nListNode *n1 = n0->next;\nP->next = n1;\nn0->next = P;\n}\n
    linked_list.cs
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode n0, ListNode P) {\nListNode? n1 = n0.next;\nP.next = n1;\nn0.next = P;\n}\n
    linked_list.swift
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunc insert(n0: ListNode, P: ListNode) {\nlet n1 = n0.next\nP.next = n1\nn0.next = P\n}\n
    linked_list.zig
    // \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P\nfn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {\nvar n1 = n0.?.next;\nP.?.next = n1;\nn0.?.next = P;\n}\n
    linked_list.dart
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode n0, ListNode P) {\nListNode? n1 = n0.next;\nP.next = n1;\nn0.next = P;\n}\n

    \u5728\u94fe\u8868\u4e2d\u5220\u9664\u8282\u70b9\u4e5f\u975e\u5e38\u65b9\u4fbf\uff0c\u53ea\u9700\u6539\u53d8\u4e00\u4e2a\u8282\u70b9\u7684\u6307\u9488\u5373\u53ef\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5c3d\u7ba1\u5728\u5220\u9664\u64cd\u4f5c\u5b8c\u6210\u540e\uff0c\u8282\u70b9 P \u4ecd\u7136\u6307\u5411 n1 \uff0c\u4f46\u5b9e\u9645\u4e0a P \u5df2\u7ecf\u4e0d\u518d\u5c5e\u4e8e\u6b64\u94fe\u8868\uff0c\u56e0\u4e3a\u904d\u5386\u6b64\u94fe\u8868\u65f6\u65e0\u6cd5\u8bbf\u95ee\u5230 P \u3002

    Fig. \u94fe\u8868\u5220\u9664\u8282\u70b9

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linked_list.java
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode n0) {\nif (n0.next == null)\nreturn;\n// n0 -> P -> n1\nListNode P = n0.next;\nListNode n1 = P.next;\nn0.next = n1;\n}\n
    linked_list.cpp
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode *n0) {\nif (n0->next == nullptr)\nreturn;\n// n0 -> P -> n1\nListNode *P = n0->next;\nListNode *n1 = P->next;\nn0->next = n1;\n// \u91ca\u653e\u5185\u5b58\ndelete P;\n}\n
    linked_list.py
    def remove(n0: ListNode) -> None:\n\"\"\"\u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9\"\"\"\nif not n0.next:\nreturn\n# n0 -> P -> n1\nP = n0.next\nn1 = P.next\nn0.next = n1\n
    linked_list.go
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunc removeNode(n0 *ListNode) {\nif n0.Next == nil {\nreturn\n}\n// n0 -> P -> n1\nP := n0.Next\nn1 := P.Next\nn0.Next = n1\n}\n
    linked_list.js
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunction remove(n0) {\nif (!n0.next) return;\n// n0 -> P -> n1\nconst P = n0.next;\nconst n1 = P.next;\nn0.next = n1;\n}\n
    linked_list.ts
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunction remove(n0: ListNode): void {\nif (!n0.next) {\nreturn;\n}\n// n0 -> P -> n1\nconst P = n0.next;\nconst n1 = P.next;\nn0.next = n1;\n}\n
    linked_list.c
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\n// \u6ce8\u610f\uff1astdio.h \u5360\u7528\u4e86 remove \u5173\u952e\u8bcd\nvoid removeNode(ListNode *n0) {\nif (!n0->next)\nreturn;\n// n0 -> P -> n1\nListNode *P = n0->next;\nListNode *n1 = P->next;\nn0->next = n1;\n// \u91ca\u653e\u5185\u5b58\nfree(P);\n}\n
    linked_list.cs
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode n0) {\nif (n0.next == null)\nreturn;\n// n0 -> P -> n1\nListNode P = n0.next;\nListNode? n1 = P.next;\nn0.next = n1;\n}\n
    linked_list.swift
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunc remove(n0: ListNode) {\nif n0.next == nil {\nreturn\n}\n// n0 -> P -> n1\nlet P = n0.next\nlet n1 = P?.next\nn0.next = n1\nP?.next = nil\n}\n
    linked_list.zig
    // \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9\nfn remove(n0: ?*inc.ListNode(i32)) void {\nif (n0.?.next == null) return;\n// n0 -> P -> n1\nvar P = n0.?.next;\nvar n1 = P.?.next;\nn0.?.next = n1;\n}\n
    linked_list.dart
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode n0) {\nif (n0.next == null) return;\n// n0 -> P -> n1\nListNode P = n0.next!;\nListNode? n1 = P.next;\nn0.next = n1;\n}\n
    "},{"location":"chapter_array_and_linkedlist/linked_list/#422","title":"4.2.2. \u00a0 \u94fe\u8868\u7f3a\u70b9","text":"

    \u94fe\u8868\u8bbf\u95ee\u8282\u70b9\u6548\u7387\u8f83\u4f4e\u3002\u5982\u4e0a\u8282\u6240\u8ff0\uff0c\u6570\u7ec4\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u4e0b\u8bbf\u95ee\u4efb\u610f\u5143\u7d20\u3002\u7136\u800c\uff0c\u94fe\u8868\u65e0\u6cd5\u76f4\u63a5\u8bbf\u95ee\u4efb\u610f\u8282\u70b9\uff0c\u8fd9\u662f\u56e0\u4e3a\u7cfb\u7edf\u9700\u8981\u4ece\u5934\u8282\u70b9\u51fa\u53d1\uff0c\u9010\u4e2a\u5411\u540e\u904d\u5386\u76f4\u81f3\u627e\u5230\u76ee\u6807\u8282\u70b9\u3002\u4f8b\u5982\uff0c\u82e5\u8981\u8bbf\u95ee\u94fe\u8868\u7d22\u5f15\u4e3a index\uff08\u5373\u7b2c index + 1 \u4e2a\uff09\u7684\u8282\u70b9\uff0c\u5219\u9700\u8981\u5411\u540e\u904d\u5386 index \u8f6e\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linked_list.java
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode access(ListNode head, int index) {\nfor (int i = 0; i < index; i++) {\nif (head == null)\nreturn null;\nhead = head.next;\n}\nreturn head;\n}\n
    linked_list.cpp
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\nfor (int i = 0; i < index; i++) {\nif (head == nullptr)\nreturn nullptr;\nhead = head->next;\n}\nreturn head;\n}\n
    linked_list.py
    def access(head: ListNode, index: int) -> ListNode | None:\n\"\"\"\u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9\"\"\"\nfor _ in range(index):\nif not head:\nreturn None\nhead = head.next\nreturn head\n
    linked_list.go
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunc access(head *ListNode, index int) *ListNode {\nfor i := 0; i < index; i++ {\nif head == nil {\nreturn nil\n}\nhead = head.Next\n}\nreturn head\n}\n
    linked_list.js
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunction access(head, index) {\nfor (let i = 0; i < index; i++) {\nif (!head) {\nreturn null;\n}\nhead = head.next;\n}\nreturn head;\n}\n
    linked_list.ts
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunction access(head: ListNode | null, index: number): ListNode | null {\nfor (let i = 0; i < index; i++) {\nif (!head) {\nreturn null;\n}\nhead = head.next;\n}\nreturn head;\n}\n
    linked_list.c
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\nwhile (head && head->next && index) {\nhead = head->next;\nindex--;\n}\nreturn head;\n}\n
    linked_list.cs
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? access(ListNode head, int index) {\nfor (int i = 0; i < index; i++) {\nif (head == null)\nreturn null;\nhead = head.next;\n}\nreturn head;\n}\n
    linked_list.swift
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunc access(head: ListNode, index: Int) -> ListNode? {\nvar head: ListNode? = head\nfor _ in 0 ..< index {\nif head == nil {\nreturn nil\n}\nhead = head?.next\n}\nreturn head\n}\n
    linked_list.zig
    // \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9\nfn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {\nvar head = node;\nvar i: i32 = 0;\nwhile (i < index) : (i += 1) {\nhead = head.?.next;\nif (head == null) return null;\n}\nreturn head;\n}\n
    linked_list.dart
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? access(ListNode? head, int index) {\nfor (var i = 0; i < index; i++) {\nif (head == null) return null;\nhead = head.next;\n}\nreturn head;\n}\n

    \u94fe\u8868\u7684\u5185\u5b58\u5360\u7528\u8f83\u5927\u3002\u94fe\u8868\u4ee5\u8282\u70b9\u4e3a\u5355\u4f4d\uff0c\u6bcf\u4e2a\u8282\u70b9\u9664\u4e86\u4fdd\u5b58\u503c\u4e4b\u5916\uff0c\u8fd8\u9700\u989d\u5916\u4fdd\u5b58\u6307\u9488\uff08\u5f15\u7528\uff09\u3002\u8fd9\u610f\u5473\u7740\u5728\u76f8\u540c\u6570\u636e\u91cf\u7684\u60c5\u51b5\u4e0b\uff0c\u94fe\u8868\u6bd4\u6570\u7ec4\u9700\u8981\u5360\u7528\u66f4\u591a\u7684\u5185\u5b58\u7a7a\u95f4\u3002

    "},{"location":"chapter_array_and_linkedlist/linked_list/#423","title":"4.2.3. \u00a0 \u94fe\u8868\u5e38\u7528\u64cd\u4f5c","text":"

    \u904d\u5386\u94fe\u8868\u67e5\u627e\u3002\u904d\u5386\u94fe\u8868\uff0c\u67e5\u627e\u94fe\u8868\u5185\u503c\u4e3a target \u7684\u8282\u70b9\uff0c\u8f93\u51fa\u8282\u70b9\u5728\u94fe\u8868\u4e2d\u7684\u7d22\u5f15\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linked_list.java
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode head, int target) {\nint index = 0;\nwhile (head != null) {\nif (head.val == target)\nreturn index;\nhead = head.next;\nindex++;\n}\nreturn -1;\n}\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode *head, int target) {\nint index = 0;\nwhile (head != nullptr) {\nif (head->val == target)\nreturn index;\nhead = head->next;\nindex++;\n}\nreturn -1;\n}\n
    linked_list.py
    def find(head: ListNode, target: int) -> int:\n\"\"\"\u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9\"\"\"\nindex = 0\nwhile head:\nif head.val == target:\nreturn index\nhead = head.next\nindex += 1\nreturn -1\n
    linked_list.go
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunc findNode(head *ListNode, target int) int {\nindex := 0\nfor head != nil {\nif head.Val == target {\nreturn index\n}\nhead = head.Next\nindex++\n}\nreturn -1\n}\n
    linked_list.js
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunction find(head, target) {\nlet index = 0;\nwhile (head !== null) {\nif (head.val === target) {\nreturn index;\n}\nhead = head.next;\nindex += 1;\n}\nreturn -1;\n}\n
    linked_list.ts
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunction find(head: ListNode | null, target: number): number {\nlet index = 0;\nwhile (head !== null) {\nif (head.val === target) {\nreturn index;\n}\nhead = head.next;\nindex += 1;\n}\nreturn -1;\n}\n
    linked_list.c
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode *head, int target) {\nint index = 0;\nwhile (head) {\nif (head->val == target)\nreturn index;\nhead = head->next;\nindex++;\n}\nreturn -1;\n}\n
    linked_list.cs
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode head, int target) {\nint index = 0;\nwhile (head != null) {\nif (head.val == target)\nreturn index;\nhead = head.next;\nindex++;\n}\nreturn -1;\n}\n
    linked_list.swift
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunc find(head: ListNode, target: Int) -> Int {\nvar head: ListNode? = head\nvar index = 0\nwhile head != nil {\nif head?.val == target {\nreturn index\n}\nhead = head?.next\nindex += 1\n}\nreturn -1\n}\n
    linked_list.zig
    // \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9\nfn find(node: ?*inc.ListNode(i32), target: i32) i32 {\nvar head = node;\nvar index: i32 = 0;\nwhile (head != null) {\nif (head.?.val == target) return index;\nhead = head.?.next;\nindex += 1;\n}\nreturn -1;\n}\n
    linked_list.dart
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode? head, int target) {\nint index = 0;\nwhile (head != null) {\nif (head.val == target) {\nreturn index;\n}\nhead = head.next;\nindex++;\n}\nreturn -1;\n}\n
    "},{"location":"chapter_array_and_linkedlist/linked_list/#424","title":"4.2.4. \u00a0 \u5e38\u89c1\u94fe\u8868\u7c7b\u578b","text":"

    \u5355\u5411\u94fe\u8868\u3002\u5373\u4e0a\u8ff0\u4ecb\u7ecd\u7684\u666e\u901a\u94fe\u8868\u3002\u5355\u5411\u94fe\u8868\u7684\u8282\u70b9\u5305\u542b\u503c\u548c\u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\u4e24\u9879\u6570\u636e\u3002\u6211\u4eec\u5c06\u9996\u4e2a\u8282\u70b9\u79f0\u4e3a\u5934\u8282\u70b9\uff0c\u5c06\u6700\u540e\u4e00\u4e2a\u8282\u70b9\u6210\u4e3a\u5c3e\u8282\u70b9\uff0c\u5c3e\u8282\u70b9\u6307\u5411\u7a7a \\(\\text{None}\\) \u3002

    \u73af\u5f62\u94fe\u8868\u3002\u5982\u679c\u6211\u4eec\u4ee4\u5355\u5411\u94fe\u8868\u7684\u5c3e\u8282\u70b9\u6307\u5411\u5934\u8282\u70b9\uff08\u5373\u9996\u5c3e\u76f8\u63a5\uff09\uff0c\u5219\u5f97\u5230\u4e00\u4e2a\u73af\u5f62\u94fe\u8868\u3002\u5728\u73af\u5f62\u94fe\u8868\u4e2d\uff0c\u4efb\u610f\u8282\u70b9\u90fd\u53ef\u4ee5\u89c6\u4f5c\u5934\u8282\u70b9\u3002

    \u53cc\u5411\u94fe\u8868\u3002\u4e0e\u5355\u5411\u94fe\u8868\u76f8\u6bd4\uff0c\u53cc\u5411\u94fe\u8868\u8bb0\u5f55\u4e86\u4e24\u4e2a\u65b9\u5411\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\u3002\u53cc\u5411\u94fe\u8868\u7684\u8282\u70b9\u5b9a\u4e49\u540c\u65f6\u5305\u542b\u6307\u5411\u540e\u7ee7\u8282\u70b9\uff08\u4e0b\u4e00\u8282\u70b9\uff09\u548c\u524d\u9a71\u8282\u70b9\uff08\u4e0a\u4e00\u8282\u70b9\uff09\u7684\u6307\u9488\u3002\u76f8\u8f83\u4e8e\u5355\u5411\u94fe\u8868\uff0c\u53cc\u5411\u94fe\u8868\u66f4\u5177\u7075\u6d3b\u6027\uff0c\u53ef\u4ee5\u671d\u4e24\u4e2a\u65b9\u5411\u904d\u5386\u94fe\u8868\uff0c\u4f46\u76f8\u5e94\u5730\u4e5f\u9700\u8981\u5360\u7528\u66f4\u591a\u7684\u5185\u5b58\u7a7a\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nint val;        // \u8282\u70b9\u503c\nListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(int x) { val = x; }  // \u6784\u9020\u51fd\u6570\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\nint val;         // \u8282\u70b9\u503c\nListNode *next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode *prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // \u6784\u9020\u51fd\u6570\n};\n
    class ListNode:\n\"\"\"\u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\"\"\"\ndef __init__(self, val: int):\nself.val: int = val                   # \u8282\u70b9\u503c\nself.next: Optional[ListNode] = None  # \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nself.prev: Optional[ListNode] = None  # \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype DoublyListNode struct {\nVal  int             // \u8282\u70b9\u503c\nNext *DoublyListNode // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nPrev *DoublyListNode // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n}\n// NewDoublyListNode \u521d\u59cb\u5316\nfunc NewDoublyListNode(val int) *DoublyListNode {\nreturn &DoublyListNode{\nVal:  val,\nNext: nil,\nPrev: nil,\n}\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nval;\nnext;\nprev;\nconstructor(val, next, prev) {\nthis.val = val  ===  undefined ? 0 : val;        // \u8282\u70b9\u503c\nthis.next = next  ===  undefined ? null : next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nthis.prev = prev  ===  undefined ? null : prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n}\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nval: number;\nnext: ListNode | null;\nprev: ListNode | null;\nconstructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\nthis.val = val  ===  undefined ? 0 : val;        // \u8282\u70b9\u503c\nthis.next = next  ===  undefined ? null : next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nthis.prev = prev  ===  undefined ? null : prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n}\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\nint val;               // \u8282\u70b9\u503c\nstruct ListNode *next; // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nstruct ListNode *prev; // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n};\ntypedef struct ListNode ListNode;\n/* \u6784\u9020\u51fd\u6570 */\nListNode *newListNode(int val) {\nListNode *node, *next;\nnode = (ListNode *) malloc(sizeof(ListNode));\nnode->val = val;\nnode->next = NULL;\nnode->prev = NULL;\nreturn node;\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nint val;        // \u8282\u70b9\u503c\nListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(int x) => val = x;  // \u6784\u9020\u51fd\u6570\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nvar val: Int // \u8282\u70b9\u503c\nvar next: ListNode? // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nvar prev: ListNode? // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\ninit(x: Int) { // \u6784\u9020\u51fd\u6570\nval = x\n}\n}\n
    // \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\npub fn ListNode(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nval: T = 0, // \u8282\u70b9\u503c\nnext: ?*Self = null, // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nprev: ?*Self = null, // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\n// \u6784\u9020\u51fd\u6570\npub fn init(self: *Self, x: i32) void {\nself.val = x;\nself.next = null;\nself.prev = null;\n}\n};\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\nint val;        // \u8282\u70b9\u503c\nListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\nListNode(this.val, [this.next, this.prev]);  // \u6784\u9020\u51fd\u6570\n}\n

    Fig. \u5e38\u89c1\u94fe\u8868\u79cd\u7c7b

    "},{"location":"chapter_array_and_linkedlist/list/","title":"4.3. \u00a0 \u5217\u8868","text":"

    \u6570\u7ec4\u957f\u5ea6\u4e0d\u53ef\u53d8\u5bfc\u81f4\u5b9e\u7528\u6027\u964d\u4f4e\u3002\u5728\u8bb8\u591a\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u4e8b\u5148\u65e0\u6cd5\u786e\u5b9a\u9700\u8981\u5b58\u50a8\u591a\u5c11\u6570\u636e\uff0c\u8fd9\u4f7f\u6570\u7ec4\u957f\u5ea6\u7684\u9009\u62e9\u53d8\u5f97\u56f0\u96be\u3002\u82e5\u957f\u5ea6\u8fc7\u5c0f\uff0c\u9700\u8981\u5728\u6301\u7eed\u6dfb\u52a0\u6570\u636e\u65f6\u9891\u7e41\u6269\u5bb9\u6570\u7ec4\uff1b\u82e5\u957f\u5ea6\u8fc7\u5927\uff0c\u5219\u4f1a\u9020\u6210\u5185\u5b58\u7a7a\u95f4\u7684\u6d6a\u8d39\u3002

    \u4e3a\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u51fa\u73b0\u4e86\u4e00\u79cd\u88ab\u79f0\u4e3a\u300c\u52a8\u6001\u6570\u7ec4 Dynamic Array\u300d\u7684\u6570\u636e\u7ed3\u6784\uff0c\u5373\u957f\u5ea6\u53ef\u53d8\u7684\u6570\u7ec4\uff0c\u4e5f\u5e38\u88ab\u79f0\u4e3a\u300c\u5217\u8868 List\u300d\u3002\u5217\u8868\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\uff0c\u7ee7\u627f\u4e86\u6570\u7ec4\u7684\u4f18\u70b9\uff0c\u5e76\u4e14\u53ef\u4ee5\u5728\u7a0b\u5e8f\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u52a8\u6001\u6269\u5bb9\u3002\u5728\u5217\u8868\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u81ea\u7531\u6dfb\u52a0\u5143\u7d20\uff0c\u800c\u65e0\u9700\u62c5\u5fc3\u8d85\u8fc7\u5bb9\u91cf\u9650\u5236\u3002

    "},{"location":"chapter_array_and_linkedlist/list/#431","title":"4.3.1. \u00a0 \u5217\u8868\u5e38\u7528\u64cd\u4f5c","text":"

    \u521d\u59cb\u5316\u5217\u8868\u3002\u901a\u5e38\u6211\u4eec\u4f1a\u4f7f\u7528\u201c\u65e0\u521d\u59cb\u503c\u201d\u548c\u201c\u6709\u521d\u59cb\u503c\u201d\u7684\u4e24\u79cd\u521d\u59cb\u5316\u65b9\u6cd5\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<Integer> list1 = new ArrayList<>();\n// \u6709\u521d\u59cb\u503c\uff08\u6ce8\u610f\u6570\u7ec4\u7684\u5143\u7d20\u7c7b\u578b\u9700\u4e3a int[] \u7684\u5305\u88c5\u7c7b Integer[]\uff09\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList<Integer> list = new ArrayList<>(Arrays.asList(numbers));\n
    list.cpp
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u9700\u6ce8\u610f\uff0cC++ \u4e2d vector \u5373\u662f\u672c\u6587\u63cf\u8ff0\u7684 list\n// \u65e0\u521d\u59cb\u503c\nvector<int> list1;\n// \u6709\u521d\u59cb\u503c\nvector<int> list = { 1, 3, 2, 5, 4 };\n
    list.py
    # \u521d\u59cb\u5316\u5217\u8868\n# \u65e0\u521d\u59cb\u503c\nlist1: List[int] = []\n# \u6709\u521d\u59cb\u503c\nlist: List[int] = [1, 3, 2, 5, 4]\n
    list_test.go
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nlist1 := []int\n// \u6709\u521d\u59cb\u503c\nlist := []int{1, 3, 2, 5, 4}\n
    list.js
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nconst list1 = [];\n// \u6709\u521d\u59cb\u503c\nconst list = [1, 3, 2, 5, 4];\n
    list.ts
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nconst list1: number[] = [];\n// \u6709\u521d\u59cb\u503c\nconst list: number[] = [1, 3, 2, 5, 4];\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<int> list1 = new ();\n// \u6709\u521d\u59cb\u503c\nint[] numbers = new int[] { 1, 3, 2, 5, 4 };\nList<int> list = numbers.ToList();\n
    list.swift
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nlet list1: [Int] = []\n// \u6709\u521d\u59cb\u503c\nvar list = [1, 3, 2, 5, 4]\n
    list.zig
    // \u521d\u59cb\u5316\u5217\u8868\nvar list = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer list.deinit();\ntry list.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });\n
    list.dart
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<int> list1 = [];\n// \u6709\u521d\u59cb\u503c\nList<int> list = [1, 3, 2, 5, 4];\n

    \u8bbf\u95ee\u4e0e\u66f4\u65b0\u5143\u7d20\u3002\u7531\u4e8e\u5217\u8868\u7684\u5e95\u5c42\u6570\u636e\u7ed3\u6784\u662f\u6570\u7ec4\uff0c\u56e0\u6b64\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u8bbf\u95ee\u548c\u66f4\u65b0\u5143\u7d20\uff0c\u6548\u7387\u5f88\u9ad8\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = list.get(1);  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist.set(1, 0);  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.cpp
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = list[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.py
    # \u8bbf\u95ee\u5143\u7d20\nnum: int = list[1]  # \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n# \u66f4\u65b0\u5143\u7d20\nlist[1] = 0    # \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list_test.go
    /* \u8bbf\u95ee\u5143\u7d20 */\nnum := list[1]  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0     // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.js
    /* \u8bbf\u95ee\u5143\u7d20 */\nconst num = list[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.ts
    /* \u8bbf\u95ee\u5143\u7d20 */\nconst num: number = list[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = list[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.swift
    /* \u8bbf\u95ee\u5143\u7d20 */\nlet num = list[1] // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0 // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.zig
    // \u8bbf\u95ee\u5143\u7d20\nvar num = list.items[1]; // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n// \u66f4\u65b0\u5143\u7d20\nlist.items[1] = 0; // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0  \n
    list.dart
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = list[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nlist[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n

    \u5728\u5217\u8868\u4e2d\u6dfb\u52a0\u3001\u63d2\u5165\u3001\u5220\u9664\u5143\u7d20\u3002\u76f8\u8f83\u4e8e\u6570\u7ec4\uff0c\u5217\u8868\u53ef\u4ee5\u81ea\u7531\u5730\u6dfb\u52a0\u4e0e\u5220\u9664\u5143\u7d20\u3002\u5728\u5217\u8868\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \uff0c\u4f46\u63d2\u5165\u548c\u5220\u9664\u5143\u7d20\u7684\u6548\u7387\u4ecd\u4e0e\u6570\u7ec4\u76f8\u540c\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(N)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.clear();\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.add(1);\nlist.add(3);\nlist.add(2);\nlist.add(5);\nlist.add(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.add(3, 6);  // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n/* \u5220\u9664\u5143\u7d20 */\nlist.remove(3);  // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list.cpp
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.clear();\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.push_back(1);\nlist.push_back(3);\nlist.push_back(2);\nlist.push_back(5);\nlist.push_back(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.insert(list.begin() + 3, 6);  // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n/* \u5220\u9664\u5143\u7d20 */\nlist.erase(list.begin() + 3);      // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list.py
    # \u6e05\u7a7a\u5217\u8868\nlist.clear()\n# \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\nlist.append(1)\nlist.append(3)\nlist.append(2)\nlist.append(5)\nlist.append(4)\n# \u4e2d\u95f4\u63d2\u5165\u5143\u7d20\nlist.insert(3, 6)  # \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n# \u5220\u9664\u5143\u7d20\nlist.pop(3)        # \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list_test.go
    /* \u6e05\u7a7a\u5217\u8868 */\nlist = nil\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist = append(list, 1)\nlist = append(list, 3)\nlist = append(list, 2)\nlist = append(list, 5)\nlist = append(list, 4)\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist = append(list[:3], append([]int{6}, list[3:]...)...) // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n/* \u5220\u9664\u5143\u7d20 */\nlist = append(list[:3], list[4:]...) // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list.js
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.length = 0;\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.push(1);\nlist.push(3);\nlist.push(2);\nlist.push(5);\nlist.push(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.splice(3, 0, 6);\n/* \u5220\u9664\u5143\u7d20 */\nlist.splice(3, 1);\n
    list.ts
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.length = 0;\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.push(1);\nlist.push(3);\nlist.push(2);\nlist.push(5);\nlist.push(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.splice(3, 0, 6);\n/* \u5220\u9664\u5143\u7d20 */\nlist.splice(3, 1);\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.Clear();\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.Add(1);\nlist.Add(3);\nlist.Add(2);\nlist.Add(5);\nlist.Add(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.Insert(3, 6);\n/* \u5220\u9664\u5143\u7d20 */\nlist.RemoveAt(3);\n
    list.swift
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.removeAll()\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.append(1)\nlist.append(3)\nlist.append(2)\nlist.append(5)\nlist.append(4)\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.insert(6, at: 3) // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n/* \u5220\u9664\u5143\u7d20 */\nlist.remove(at: 3) // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list.zig
    // \u6e05\u7a7a\u5217\u8868\nlist.clearRetainingCapacity();\n// \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\ntry list.append(1);\ntry list.append(3);\ntry list.append(2);\ntry list.append(5);\ntry list.append(4);\n// \u4e2d\u95f4\u63d2\u5165\u5143\u7d20\ntry list.insert(3, 6); // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n// \u5220\u9664\u5143\u7d20\n_ = list.orderedRemove(3); // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n
    list.dart
    /* \u6e05\u7a7a\u5217\u8868 */\nlist.clear();\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nlist.add(1);\nlist.add(3);\nlist.add(2);\nlist.add(5);\nlist.add(4);\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nlist.insert(3, 6); // \u5728\u7d22\u5f15 3 \u5904\u63d2\u5165\u6570\u5b57 6\n/* \u5220\u9664\u5143\u7d20 */\nlist.removeAt(3); // \u5220\u9664\u7d22\u5f15 3 \u5904\u7684\u5143\u7d20\n

    \u904d\u5386\u5217\u8868\u3002\u4e0e\u6570\u7ec4\u4e00\u6837\uff0c\u5217\u8868\u53ef\u4ee5\u6839\u636e\u7d22\u5f15\u904d\u5386\uff0c\u4e5f\u53ef\u4ee5\u76f4\u63a5\u904d\u5386\u5404\u5143\u7d20\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < list.size(); i++) {\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (int n : list) {\ncount++;\n}\n
    list.cpp
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < list.size(); i++) {\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (int n : list) {\ncount++;\n}\n
    list.py
    # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\ncount = 0\nfor i in range(len(list)):\ncount += 1\n# \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\ncount = 0\nfor n in list:\ncount += 1\n
    list_test.go
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\ncount := 0\nfor i := 0; i < len(list); i++ {\ncount++\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0\nfor range list {\ncount++\n}\n
    list.js
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nlet count = 0;\nfor (let i = 0; i < list.length; i++) {\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (const n of list) {\ncount++;\n}\n
    list.ts
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nlet count = 0;\nfor (let i = 0; i < list.length; i++) {\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (const n of list) {\ncount++;\n}\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < list.Count(); i++)\n{\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nforeach (int n in list)\n{\ncount++;\n}\n
    list.swift
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nvar count = 0\nfor _ in list.indices {\ncount += 1\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0\nfor _ in list {\ncount += 1\n}\n
    list.zig
    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\nvar count: i32 = 0;\nvar i: i32 = 0;\nwhile (i < list.items.len) : (i += 1) {\ncount += 1;\n}\n// \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\ncount = 0;\nfor (list.items) |_| {\ncount += 1;\n}\n
    list.dart
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < list.length; i++) {\ncount++;\n}\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (int n in list) {\ncount++;\n}\n

    \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\u3002\u7ed9\u5b9a\u4e00\u4e2a\u65b0\u5217\u8868 list1 \uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u8be5\u5217\u8868\u62fc\u63a5\u5230\u539f\u5217\u8868\u7684\u5c3e\u90e8\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<Integer> list1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nlist.addAll(list1);  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.cpp
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nvector<int> list1 = { 6, 8, 7, 10, 9 };\n// \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\nlist.insert(list.end(), list1.begin(), list1.end());\n
    list.py
    # \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\nlist1: List[int] = [6, 8, 7, 10, 9]\nlist += list1  # \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list_test.go
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nlist1 := []int{6, 8, 7, 10, 9}\nlist = append(list, list1...)  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.js
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nconst list1 = [6, 8, 7, 10, 9];\nlist.push(...list1);  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.ts
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nconst list1: number[] = [6, 8, 7, 10, 9];\nlist.push(...list1);  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<int> list1 = new() { 6, 8, 7, 10, 9 };\nlist.AddRange(list1);  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.swift
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nlet list1 = [6, 8, 7, 10, 9]\nlist.append(contentsOf: list1) // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.zig
    // \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\nvar list1 = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer list1.deinit();\ntry list1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });\ntry list.insertSlice(list.items.len, list1.items); // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n
    list.dart
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<int> list1 = [6, 8, 7, 10, 9];\nlist.addAll(list1);  // \u5c06\u5217\u8868 list1 \u62fc\u63a5\u5230 list \u4e4b\u540e\n

    \u6392\u5e8f\u5217\u8868\u3002\u6392\u5e8f\u4e5f\u662f\u5e38\u7528\u7684\u65b9\u6cd5\u4e4b\u4e00\u3002\u5b8c\u6210\u5217\u8868\u6392\u5e8f\u540e\uff0c\u6211\u4eec\u4fbf\u53ef\u4ee5\u4f7f\u7528\u5728\u6570\u7ec4\u7c7b\u7b97\u6cd5\u9898\u4e2d\u7ecf\u5e38\u8003\u5bdf\u7684\u300c\u4e8c\u5206\u67e5\u627e\u300d\u548c\u300c\u53cc\u6307\u9488\u300d\u7b97\u6cd5\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart list.java
    /* \u6392\u5e8f\u5217\u8868 */\nCollections.sort(list);  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.cpp
    /* \u6392\u5e8f\u5217\u8868 */\nsort(list.begin(), list.end());  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.py
    # \u6392\u5e8f\u5217\u8868\nlist.sort()  # \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list_test.go
    /* \u6392\u5e8f\u5217\u8868 */\nsort.Ints(list)  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.js
    /* \u6392\u5e8f\u5217\u8868 */  list.sort((a, b) => a - b);  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.ts
    /* \u6392\u5e8f\u5217\u8868 */\nlist.sort((a, b) => a - b);  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.cs
    /* \u6392\u5e8f\u5217\u8868 */\nlist.Sort(); // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.swift
    /* \u6392\u5e8f\u5217\u8868 */\nlist.sort() // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.zig
    // \u6392\u5e8f\u5217\u8868\nstd.sort.sort(i32, list.items, {}, comptime std.sort.asc(i32));\n
    list.dart
    /* \u6392\u5e8f\u5217\u8868 */\nlist.sort(); // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    "},{"location":"chapter_array_and_linkedlist/list/#432","title":"4.3.2. \u00a0 \u5217\u8868\u5b9e\u73b0 *","text":"

    \u4e3a\u4e86\u5e2e\u52a9\u52a0\u6df1\u5bf9\u5217\u8868\u7684\u7406\u89e3\uff0c\u6211\u4eec\u5728\u6b64\u63d0\u4f9b\u4e00\u4e2a\u7b80\u6613\u7248\u5217\u8868\u5b9e\u73b0\u3002\u9700\u8981\u5173\u6ce8\u4e09\u4e2a\u6838\u5fc3\u70b9\uff1a

    • \u521d\u59cb\u5bb9\u91cf\uff1a\u9009\u53d6\u4e00\u4e2a\u5408\u7406\u7684\u6570\u7ec4\u521d\u59cb\u5bb9\u91cf\u3002\u5728\u672c\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u9009\u62e9 10 \u4f5c\u4e3a\u521d\u59cb\u5bb9\u91cf\u3002
    • \u6570\u91cf\u8bb0\u5f55\uff1a\u58f0\u660e\u4e00\u4e2a\u53d8\u91cf size\uff0c\u7528\u4e8e\u8bb0\u5f55\u5217\u8868\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff0c\u5e76\u968f\u7740\u5143\u7d20\u63d2\u5165\u548c\u5220\u9664\u5b9e\u65f6\u66f4\u65b0\u3002\u6839\u636e\u6b64\u53d8\u91cf\uff0c\u6211\u4eec\u53ef\u4ee5\u5b9a\u4f4d\u5217\u8868\u5c3e\u90e8\uff0c\u4ee5\u53ca\u5224\u65ad\u662f\u5426\u9700\u8981\u6269\u5bb9\u3002
    • \u6269\u5bb9\u673a\u5236\uff1a\u63d2\u5165\u5143\u7d20\u65f6\u53ef\u80fd\u8d85\u51fa\u5217\u8868\u5bb9\u91cf\uff0c\u6b64\u65f6\u9700\u8981\u6269\u5bb9\u5217\u8868\u3002\u6269\u5bb9\u65b9\u6cd5\u662f\u6839\u636e\u6269\u5bb9\u500d\u6570\u521b\u5efa\u4e00\u4e2a\u66f4\u5927\u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u5f53\u524d\u6570\u7ec4\u7684\u6240\u6709\u5143\u7d20\u4f9d\u6b21\u79fb\u52a8\u81f3\u65b0\u6570\u7ec4\u3002\u5728\u672c\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u89c4\u5b9a\u6bcf\u6b21\u5c06\u6570\u7ec4\u6269\u5bb9\u81f3\u4e4b\u524d\u7684 2 \u500d\u3002

    \u672c\u793a\u4f8b\u65e8\u5728\u5e2e\u52a9\u8bfb\u8005\u76f4\u89c2\u7406\u89e3\u5217\u8868\u7684\u5de5\u4f5c\u673a\u5236\u3002\u5b9e\u9645\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u5217\u8868\u5b9e\u73b0\u66f4\u52a0\u6807\u51c6\u548c\u590d\u6742\uff0c\u5404\u4e2a\u53c2\u6570\u7684\u8bbe\u5b9a\u4e5f\u975e\u5e38\u6709\u8003\u7a76\uff0c\u4f8b\u5982\u521d\u59cb\u5bb9\u91cf\u3001\u6269\u5bb9\u500d\u6570\u7b49\u3002\u611f\u5174\u8da3\u7684\u8bfb\u8005\u53ef\u4ee5\u67e5\u9605\u6e90\u7801\u8fdb\u884c\u5b66\u4e60\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_list.java
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nprivate int[] nums; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nprivate int capacity = 10; // \u5217\u8868\u5bb9\u91cf\nprivate int size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nprivate int extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\npublic MyList() {\nnums = new int[capacity];\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\npublic int size() {\nreturn size;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\npublic int capacity() {\nreturn capacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\npublic int get(int index) {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 || index >= size)\nthrow new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\nreturn nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\npublic void set(int index, int num) {\nif (index < 0 || index >= size)\nthrow new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\nnums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\npublic void add(int num) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (size == capacity())\nextendCapacity();\nnums[size] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nsize++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\npublic void insert(int index, int num) {\nif (index < 0 || index >= size)\nthrow new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (size == capacity())\nextendCapacity();\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int j = size - 1; j >= index; j--) {\nnums[j + 1] = nums[j];\n}\nnums[index] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nsize++;\n}\n/* \u5220\u9664\u5143\u7d20 */\npublic int remove(int index) {\nif (index < 0 || index >= size)\nthrow new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\nint num = nums[index];\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int j = index; j < size - 1; j++) {\nnums[j] = nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nsize--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\npublic void extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nnums = Arrays.copyOf(nums, capacity() * extendRatio);\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\ncapacity = nums.length;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\npublic int[] toArray() {\nint size = size();\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] nums = new int[size];\nfor (int i = 0; i < size; i++) {\nnums[i] = get(i);\n}\nreturn nums;\n}\n}\n
    my_list.cpp
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nprivate:\nint *nums;             // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nint numsCapacity = 10; // \u5217\u8868\u5bb9\u91cf\nint numsSize = 0;      // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nint extendRatio = 2;   // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nMyList() {\nnums = new int[numsCapacity];\n}\n/* \u6790\u6784\u65b9\u6cd5 */\n~MyList() {\ndelete[] nums;\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\nint size() {\nreturn numsSize;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nint capacity() {\nreturn numsCapacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\nint get(int index) {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 || index >= size())\nthrow out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\nreturn nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nvoid set(int index, int num) {\nif (index < 0 || index >= size())\nthrow out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\nnums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nvoid add(int num) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (size() == capacity())\nextendCapacity();\nnums[size()] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nvoid insert(int index, int num) {\nif (index < 0 || index >= size())\nthrow out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (size() == capacity())\nextendCapacity();\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int j = size() - 1; j >= index; j--) {\nnums[j + 1] = nums[j];\n}\nnums[index] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize++;\n}\n/* \u5220\u9664\u5143\u7d20 */\nint remove(int index) {\nif (index < 0 || index >= size())\nthrow out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\nint num = nums[index];\n// \u7d22\u5f15 i \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int j = index; j < size() - 1; j++) {\nnums[j] = nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\nvoid extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\nint newCapacity = capacity() * extendRatio;\nint *tmp = nums;\nnums = new int[newCapacity];\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nfor (int i = 0; i < size(); i++) {\nnums[i] = tmp[i];\n}\n// \u91ca\u653e\u5185\u5b58\ndelete[] tmp;\nnumsCapacity = newCapacity;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Vector \u7528\u4e8e\u6253\u5370 */\nvector<int> toVector() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvector<int> vec(size());\nfor (int i = 0; i < size(); i++) {\nvec[i] = nums[i];\n}\nreturn vec;\n}\n};\n
    my_list.py
    class MyList:\n\"\"\"\u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__capacity: int = 10  # \u5217\u8868\u5bb9\u91cf\nself.__nums: list[int] = [0] * self.__capacity  # \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nself.__size: int = 0  # \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nself.__extend_ratio: int = 2  # \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\"\"\"\nreturn self.__size\ndef capacity(self) -> int:\n\"\"\"\u83b7\u53d6\u5217\u8868\u5bb9\u91cf\"\"\"\nreturn self.__capacity\ndef get(self, index: int) -> int:\n\"\"\"\u8bbf\u95ee\u5143\u7d20\"\"\"\n# \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif index < 0 or index >= self.__size:\nraise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\nreturn self.__nums[index]\ndef set(self, num: int, index: int) -> None:\n\"\"\"\u66f4\u65b0\u5143\u7d20\"\"\"\nif index < 0 or index >= self.__size:\nraise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\nself.__nums[index] = num\ndef add(self, num: int) -> None:\n\"\"\"\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\"\"\"\n# \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif self.size() == self.capacity():\nself.extend_capacity()\nself.__nums[self.__size] = num\nself.__size += 1\ndef insert(self, num: int, index: int) -> None:\n\"\"\"\u4e2d\u95f4\u63d2\u5165\u5143\u7d20\"\"\"\nif index < 0 or index >= self.__size:\nraise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n# \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif self.__size == self.capacity():\nself.extend_capacity()\n# \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor j in range(self.__size - 1, index - 1, -1):\nself.__nums[j + 1] = self.__nums[j]\nself.__nums[index] = num\n# \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nself.__size += 1\ndef remove(self, index: int) -> int:\n\"\"\"\u5220\u9664\u5143\u7d20\"\"\"\nif index < 0 or index >= self.__size:\nraise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\nnum = self.__nums[index]\n# \u7d22\u5f15 i \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor j in range(index, self.__size - 1):\nself.__nums[j] = self.__nums[j + 1]\n# \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nself.__size -= 1\n# \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num\ndef extend_capacity(self) -> None:\n\"\"\"\u5217\u8868\u6269\u5bb9\"\"\"\n# \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 __extend_ratio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nself.__nums = self.__nums + [0] * self.capacity() * (self.__extend_ratio - 1)\n# \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nself.__capacity = len(self.__nums)\ndef to_array(self) -> list[int]:\n\"\"\"\u8fd4\u56de\u6709\u6548\u957f\u5ea6\u7684\u5217\u8868\"\"\"\nreturn self.__nums[: self.__size]\n
    my_list.go
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\ntype myList struct {\nnumsCapacity int\nnums         []int\nnumsSize     int\nextendRatio  int\n}\n/* \u6784\u9020\u51fd\u6570 */\nfunc newMyList() *myList {\nreturn &myList{\nnumsCapacity: 10,              // \u5217\u8868\u5bb9\u91cf\nnums:         make([]int, 10), // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nnumsSize:     0,               // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nextendRatio:  2,               // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n}\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\nfunc (l *myList) size() int {\nreturn l.numsSize\n}\n/*  \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nfunc (l *myList) capacity() int {\nreturn l.numsCapacity\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\nfunc (l *myList) get(index int) int {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif index < 0 || index >= l.numsSize {\npanic(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nreturn l.nums[index]\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nfunc (l *myList) set(num, index int) {\nif index < 0 || index >= l.numsSize {\npanic(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nl.nums[index] = num\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nfunc (l *myList) add(num int) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif l.numsSize == l.numsCapacity {\nl.extendCapacity()\n}\nl.nums[l.numsSize] = num\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nl.numsSize++\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nfunc (l *myList) insert(num, index int) {\nif index < 0 || index >= l.numsSize {\npanic(\"\u7d22\u5f15\u8d8a\u754c\")\n}\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif l.numsSize == l.numsCapacity {\nl.extendCapacity()\n}\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor j := l.numsSize - 1; j >= index; j-- {\nl.nums[j+1] = l.nums[j]\n}\nl.nums[index] = num\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nl.numsSize++\n}\n/* \u5220\u9664\u5143\u7d20 */\nfunc (l *myList) remove(index int) int {\nif index < 0 || index >= l.numsSize {\npanic(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nnum := l.nums[index]\n// \u7d22\u5f15 i \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor j := index; j < l.numsSize-1; j++ {\nl.nums[j] = l.nums[j+1]\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nl.numsSize--\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num\n}\n/* \u5217\u8868\u6269\u5bb9 */\nfunc (l *myList) extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nl.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...)\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nl.numsCapacity = len(l.nums)\n}\n/* \u8fd4\u56de\u6709\u6548\u957f\u5ea6\u7684\u5217\u8868 */\nfunc (l *myList) toArray() []int {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nreturn l.nums[:l.numsSize]\n}\n
    my_list.js
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\n#nums = new Array(); // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n#capacity = 10; // \u5217\u8868\u5bb9\u91cf\n#size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n#extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor() {\nthis.#nums = new Array(this.#capacity);\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\nsize() {\nreturn this.#size;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\ncapacity() {\nreturn this.#capacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\nget(index) {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nreturn this.#nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nset(index, num) {\nif (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nthis.#nums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nadd(num) {\n// \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\nif (this.#size === this.#capacity) {\nthis.extendCapacity();\n}\n// \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\nthis.#nums[this.#size] = num;\nthis.#size++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\ninsert(index, num) {\nif (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (this.#size === this.#capacity) {\nthis.extendCapacity();\n}\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (let j = this.#size - 1; j >= index; j--) {\nthis.#nums[j + 1] = this.#nums[j];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nthis.#nums[index] = num;\nthis.#size++;\n}\n/* \u5220\u9664\u5143\u7d20 */\nremove(index) {\nif (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nlet num = this.#nums[index];\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (let j = index; j < this.#size - 1; j++) {\nthis.#nums[j] = this.#nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nthis.#size--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\nextendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nthis.#nums = this.#nums.concat(\nnew Array(this.capacity() * (this.#extendRatio - 1))\n);\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nthis.#capacity = this.#nums.length;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\ntoArray() {\nlet size = this.size();\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst nums = new Array(size);\nfor (let i = 0; i < size; i++) {\nnums[i] = this.get(i);\n}\nreturn nums;\n}\n}\n
    my_list.ts
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nprivate nums: Array<number>; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nprivate _capacity: number = 10; // \u5217\u8868\u5bb9\u91cf\nprivate _size: number = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nprivate extendRatio: number = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor() {\nthis.nums = new Array(this._capacity);\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\npublic size(): number {\nreturn this._size;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\npublic capacity(): number {\nreturn this._capacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\npublic get(index: number): number {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nreturn this.nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\npublic set(index: number, num: number): void {\nif (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nthis.nums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\npublic add(num: number): void {\n// \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\nif (this._size === this._capacity) this.extendCapacity();\n// \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\nthis.nums[this._size] = num;\nthis._size++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\npublic insert(index: number, num: number): void {\nif (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (this._size === this._capacity) {\nthis.extendCapacity();\n}\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (let j = this._size - 1; j >= index; j--) {\nthis.nums[j + 1] = this.nums[j];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nthis.nums[index] = num;\nthis._size++;\n}\n/* \u5220\u9664\u5143\u7d20 */\npublic remove(index: number): number {\nif (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\nlet num = this.nums[index];\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (let j = index; j < this._size - 1; j++) {\nthis.nums[j] = this.nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nthis._size--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\npublic extendCapacity(): void {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nthis.nums = this.nums.concat(\nnew Array(this.capacity() * (this.extendRatio - 1))\n);\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nthis._capacity = this.nums.length;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\npublic toArray(): number[] {\nlet size = this.size();\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst nums = new Array(size);\nfor (let i = 0; i < size; i++) {\nnums[i] = this.get(i);\n}\nreturn nums;\n}\n}\n
    my_list.c
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nstruct myList {\nint *nums;       // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nint capacity;    // \u5217\u8868\u5bb9\u91cf\nint size;        // \u5217\u8868\u5927\u5c0f\nint extendRatio; // \u5217\u8868\u6bcf\u6b21\u6269\u5bb9\u7684\u500d\u6570\n};\ntypedef struct myList myList;\n/* \u6784\u9020\u51fd\u6570 */\nmyList *newMyList() {\nmyList *list = malloc(sizeof(myList));\nlist->capacity = 10;\nlist->nums = malloc(sizeof(int) * list->capacity);\nlist->size = 0;\nlist->extendRatio = 2;\nreturn list;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delMyList(myList *list) {\nfree(list->nums);\nfree(list);\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6 */\nint size(myList *list) {\nreturn list->size;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nint capacity(myList *list) {\nreturn list->capacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\nint get(myList *list, int index) {\nassert(index >= 0 && index < list->size);\nreturn list->nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nvoid set(myList *list, int index, int num) {\nassert(index >= 0 && index < list->size);\nlist->nums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nvoid add(myList *list, int num) {\nif (size(list) == capacity(list)) {\nextendCapacity(list); // \u6269\u5bb9\n}\nlist->nums[size(list)] = num;\nlist->size++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nvoid insert(myList *list, int index, int num) {\nassert(index >= 0 && index < size(list));\nfor (int i = size(list); i > index; --i) {\nlist->nums[i] = list->nums[i - 1];\n}\nlist->nums[index] = num;\nlist->size++;\n}\n/* \u5220\u9664\u5143\u7d20 */\n// \u6ce8\u610f\uff1astdio.h \u5360\u7528\u4e86 remove \u5173\u952e\u8bcd\nint removeNum(myList *list, int index) {\nassert(index >= 0 && index < size(list));\nint num = list->nums[index];\nfor (int i = index; i < size(list) - 1; i++) {\nlist->nums[i] = list->nums[i + 1];\n}\nlist->size--;\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\nvoid extendCapacity(myList *list) {\n// \u5148\u5206\u914d\u7a7a\u95f4\nint newCapacity = capacity(list) * list->extendRatio;\nint *extend = (int *)malloc(sizeof(int) * newCapacity);\nint *temp = list->nums;\n// \u62f7\u8d1d\u65e7\u6570\u636e\u5230\u65b0\u6570\u636e\nfor (int i = 0; i < size(list); i++)\nextend[i] = list->nums[i];\n// \u91ca\u653e\u65e7\u6570\u636e\nfree(temp);\n// \u66f4\u65b0\u65b0\u6570\u636e\nlist->nums = extend;\nlist->capacity = newCapacity;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Array \u7528\u4e8e\u6253\u5370 */\nint *toArray(myList *list) {\nreturn list->nums;\n}\n
    my_list.cs
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nprivate int[] nums;           // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nprivate int numsCapacity = 10;    // \u5217\u8868\u5bb9\u91cf\nprivate int numsSize = 0;         // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nprivate int extendRatio = 2;  // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\npublic MyList() {\nnums = new int[numsCapacity];\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\npublic int size() {\nreturn numsSize;\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\npublic int capacity() {\nreturn numsCapacity;\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\npublic int get(int index) {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 || index >= numsSize)\nthrow new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\nreturn nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\npublic void set(int index, int num) {\nif (index < 0 || index >= numsSize)\nthrow new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\nnums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\npublic void add(int num) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (numsSize == numsCapacity)\nextendCapacity();\nnums[numsSize] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\npublic void insert(int index, int num) {\nif (index < 0 || index >= numsSize)\nthrow new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (numsSize == numsCapacity)\nextendCapacity();\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (int j = numsSize - 1; j >= index; j--) {\nnums[j + 1] = nums[j];\n}\nnums[index] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize++;\n}\n/* \u5220\u9664\u5143\u7d20 */\npublic int remove(int index) {\nif (index < 0 || index >= numsSize)\nthrow new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\nint num = nums[index];\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (int j = index; j < numsSize - 1; j++) {\nnums[j] = nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nnumsSize--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\npublic void extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a numsCapacity * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nSystem.Array.Resize(ref nums, numsCapacity * extendRatio);\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nnumsCapacity = nums.Length;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\npublic int[] toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] nums = new int[numsSize];\nfor (int i = 0; i < numsSize; i++) {\nnums[i] = get(i);\n}\nreturn nums;\n}\n}\n
    my_list.swift
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nprivate var nums: [Int] // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nprivate var _capacity = 10 // \u5217\u8868\u5bb9\u91cf\nprivate var _size = 0 // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nprivate let extendRatio = 2 // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\ninit() {\nnums = Array(repeating: 0, count: _capacity)\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\nfunc size() -> Int {\n_size\n}\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nfunc capacity() -> Int {\n_capacity\n}\n/* \u8bbf\u95ee\u5143\u7d20 */\nfunc get(index: Int) -> Int {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u9519\u8bef\uff0c\u4e0b\u540c\nif index < 0 || index >= _size {\nfatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nreturn nums[index]\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nfunc set(index: Int, num: Int) {\nif index < 0 || index >= _size {\nfatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nnums[index] = num\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nfunc add(num: Int) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif _size == _capacity {\nextendCapacity()\n}\nnums[_size] = num\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size += 1\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nfunc insert(index: Int, num: Int) {\nif index < 0 || index >= _size {\nfatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n}\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif _size == _capacity {\nextendCapacity()\n}\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor j in sequence(first: _size - 1, next: { $0 >= index + 1 ? $0 - 1 : nil }) {\nnums[j + 1] = nums[j]\n}\nnums[index] = num\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size += 1\n}\n/* \u5220\u9664\u5143\u7d20 */\n@discardableResult\nfunc remove(index: Int) -> Int {\nif index < 0 || index >= _size {\nfatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n}\nlet num = nums[index]\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor j in index ..< (_size - 1) {\nnums[j] = nums[j + 1]\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size -= 1\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num\n}\n/* \u5217\u8868\u6269\u5bb9 */\nfunc extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nnums = nums + Array(repeating: 0, count: _capacity * (extendRatio - 1))\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n_capacity = nums.count\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\nfunc toArray() -> [Int] {\nvar nums = Array(repeating: 0, count: _size)\nfor i in 0 ..< _size {\nnums[i] = get(index: i)\n}\nreturn nums\n}\n}\n
    my_list.zig
    // \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0\nfn MyList(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nnums: []T = undefined,                        // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nnumsCapacity: usize = 10,                     // \u5217\u8868\u5bb9\u91cf\nnumSize: usize = 0,                           // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nextendRatio: usize = 2,                       // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\nmem_arena: ?std.heap.ArenaAllocator = null,\nmem_allocator: std.mem.Allocator = undefined, // \u5185\u5b58\u5206\u914d\u5668\n// \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u5217\u8868\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator) !void {\nif (self.mem_arena == null) {\nself.mem_arena = std.heap.ArenaAllocator.init(allocator);\nself.mem_allocator = self.mem_arena.?.allocator();\n}\nself.nums = try self.mem_allocator.alloc(T, self.numsCapacity);\n@memset(self.nums, @as(T, 0));\n}\n// \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.mem_arena == null) return;\nself.mem_arena.?.deinit();\n}\n// \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\npub fn size(self: *Self) usize {\nreturn self.numSize;\n}\n// \u83b7\u53d6\u5217\u8868\u5bb9\u91cf\npub fn capacity(self: *Self) usize {\nreturn self.numsCapacity;\n}\n// \u8bbf\u95ee\u5143\u7d20\npub fn get(self: *Self, index: usize) T {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\nreturn self.nums[index];\n}  // \u66f4\u65b0\u5143\u7d20\npub fn set(self: *Self, index: usize, num: T) void {\n// \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\nif (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\nself.nums[index] = num;\n}  // \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\npub fn add(self: *Self, num: T) !void {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (self.size() == self.capacity()) try self.extendCapacity();\nself.nums[self.size()] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nself.numSize += 1;\n}  // \u4e2d\u95f4\u63d2\u5165\u5143\u7d20\npub fn insert(self: *Self, index: usize, num: T) !void {\nif (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (self.size() == self.capacity()) try self.extendCapacity();\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nvar j = self.size() - 1;\nwhile (j >= index) : (j -= 1) {\nself.nums[j + 1] = self.nums[j];\n}\nself.nums[index] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nself.numSize += 1;\n}\n// \u5220\u9664\u5143\u7d20\npub fn remove(self: *Self, index: usize) T {\nif (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\nvar num = self.nums[index];\n// \u7d22\u5f15 i \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nvar j = index;\nwhile (j < self.size() - 1) : (j += 1) {\nself.nums[j] = self.nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\nself.numSize -= 1;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n// \u5217\u8868\u6269\u5bb9\npub fn extendCapacity(self: *Self) !void {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nvar newCapacity = self.capacity() * self.extendRatio;\nvar extend = try self.mem_allocator.alloc(T, newCapacity);\n@memset(extend, @as(T, 0));\n// \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\nstd.mem.copy(T, extend, self.nums);\nself.nums = extend;\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\nself.numsCapacity = newCapacity;\n}\n// \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\npub fn toArray(self: *Self) ![]T {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvar nums = try self.mem_allocator.alloc(T, self.size());\n@memset(nums, @as(T, 0));\nfor (nums, 0..) |*num, i| {\nnum.* = self.get(i);\n}\nreturn nums;\n}\n};\n}\n
    my_list.dart
    /* \u5217\u8868\u7c7b\u7b80\u6613\u5b9e\u73b0 */\nclass MyList {\nlate List<int> _nums; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\nint _capacity = 10; // \u5217\u8868\u5bb9\u91cf\nint _size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\nint _extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n/* \u6784\u9020\u65b9\u6cd5 */\nMyList() {\n_nums = List.filled(_capacity, 0);\n}\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5373\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\nint size() => _size;\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nint capacity() => _capacity;\n/* \u8bbf\u95ee\u5143\u7d20 */\nint get(int index) {\nif (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\nreturn _nums[index];\n}\n/* \u66f4\u65b0\u5143\u7d20 */\nvoid set(int index, int num) {\nif (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n_nums[index] = num;\n}\n/* \u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nvoid add(int num) {\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (_size == _capacity) extendCapacity();\n_nums[_size] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size++;\n}\n/* \u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nvoid insert(int index, int num) {\nif (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n// \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\nif (_size == _capacity) extendCapacity();\n// \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfor (var j = _size - 1; j >= index; j--) {\n_nums[j + 1] = _nums[j];\n}\n_nums[index] = num;\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size++;\n}\n/* \u5220\u9664\u5143\u7d20 */\nint remove(int index) {\nif (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\nint num = _nums[index];\n// \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\nfor (var j = index; j < _size - 1; j++) {\n_nums[j] = _nums[j + 1];\n}\n// \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n_size--;\n// \u8fd4\u56de\u88ab\u5220\u9664\u5143\u7d20\nreturn num;\n}\n/* \u5217\u8868\u6269\u5bb9 */\nvoid extendCapacity() {\n// \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 _extendRatio \u500d\u7684\u65b0\u6570\u7ec4\nfinal _newNums = List.filled(_capacity * _extendRatio, 0);\n// \u5c06\u539f\u6570\u7ec4\u62f7\u8d1d\u5230\u65b0\u6570\u7ec4\nList.copyRange(_newNums, 0, _nums);\n// \u66f4\u65b0 _nums \u7684\u5f15\u7528\n_nums = _newNums;\n// \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n_capacity = _nums.length;\n}\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\nList<int> toArray() {\nList<int> nums = [];\nfor (var i = 0; i < _size; i++) {\nnums.add(get(i));\n}\nreturn nums;\n}\n}\n
    "},{"location":"chapter_array_and_linkedlist/summary/","title":"4.4. \u00a0 \u5c0f\u7ed3","text":"
    • \u6570\u7ec4\u548c\u94fe\u8868\u662f\u4e24\u79cd\u57fa\u672c\u6570\u636e\u7ed3\u6784\uff0c\u5206\u522b\u4ee3\u8868\u6570\u636e\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u7684\u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u548c\u79bb\u6563\u7a7a\u95f4\u5b58\u50a8\u65b9\u5f0f\u3002\u4e24\u8005\u7684\u4f18\u7f3a\u70b9\u5448\u73b0\u51fa\u4e92\u8865\u7684\u7279\u6027\u3002
    • \u6570\u7ec4\u652f\u6301\u968f\u673a\u8bbf\u95ee\u3001\u5360\u7528\u5185\u5b58\u8f83\u5c11\uff1b\u4f46\u63d2\u5165\u548c\u5220\u9664\u5143\u7d20\u6548\u7387\u4f4e\uff0c\u4e14\u521d\u59cb\u5316\u540e\u957f\u5ea6\u4e0d\u53ef\u53d8\u3002
    • \u94fe\u8868\u901a\u8fc7\u66f4\u6539\u6307\u9488\u5b9e\u73b0\u9ad8\u6548\u7684\u8282\u70b9\u63d2\u5165\u4e0e\u5220\u9664\uff0c\u4e14\u53ef\u4ee5\u7075\u6d3b\u8c03\u6574\u957f\u5ea6\uff1b\u4f46\u8282\u70b9\u8bbf\u95ee\u6548\u7387\u4f4e\u3001\u5360\u7528\u5185\u5b58\u8f83\u591a\u3002\u5e38\u89c1\u7684\u94fe\u8868\u7c7b\u578b\u5305\u62ec\u5355\u5411\u94fe\u8868\u3001\u5faa\u73af\u94fe\u8868\u3001\u53cc\u5411\u94fe\u8868\u3002
    • \u52a8\u6001\u6570\u7ec4\uff0c\u53c8\u79f0\u5217\u8868\uff0c\u662f\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u4e00\u79cd\u6570\u636e\u7ed3\u6784\u3002\u5b83\u4fdd\u7559\u4e86\u6570\u7ec4\u7684\u4f18\u52bf\uff0c\u540c\u65f6\u53ef\u4ee5\u7075\u6d3b\u8c03\u6574\u957f\u5ea6\u3002\u5217\u8868\u7684\u51fa\u73b0\u6781\u5927\u5730\u63d0\u9ad8\u4e86\u6570\u7ec4\u7684\u6613\u7528\u6027\uff0c\u4f46\u53ef\u80fd\u5bfc\u81f4\u90e8\u5206\u5185\u5b58\u7a7a\u95f4\u6d6a\u8d39\u3002
    • \u4e0b\u8868\u603b\u7ed3\u5e76\u5bf9\u6bd4\u4e86\u6570\u7ec4\u4e0e\u94fe\u8868\u7684\u5404\u9879\u7279\u6027\u4e0e\u64cd\u4f5c\u6548\u7387\u3002
    \u6570\u7ec4 \u94fe\u8868 \u5b58\u50a8\u65b9\u5f0f \u8fde\u7eed\u5185\u5b58\u7a7a\u95f4 \u79bb\u6563\u5185\u5b58\u7a7a\u95f4 \u6570\u636e\u7ed3\u6784\u957f\u5ea6 \u957f\u5ea6\u4e0d\u53ef\u53d8 \u957f\u5ea6\u53ef\u53d8 \u5185\u5b58\u4f7f\u7528\u7387 \u5360\u7528\u5185\u5b58\u5c11\u3001\u7f13\u5b58\u5c40\u90e8\u6027\u597d \u5360\u7528\u5185\u5b58\u591a \u4f18\u52bf\u64cd\u4f5c \u968f\u673a\u8bbf\u95ee \u63d2\u5165\u3001\u5220\u9664 \u8bbf\u95ee\u5143\u7d20 \\(O(1)\\) \\(O(N)\\) \u6dfb\u52a0\u5143\u7d20 \\(O(N)\\) \\(O(1)\\) \u5220\u9664\u5143\u7d20 \\(O(N)\\) \\(O(1)\\)

    \u7f13\u5b58\u5c40\u90e8\u6027

    \u5728\u8ba1\u7b97\u673a\u4e2d\uff0c\u6570\u636e\u8bfb\u5199\u901f\u5ea6\u6392\u5e8f\u662f\u201c\u786c\u76d8 < \u5185\u5b58 < CPU \u7f13\u5b58\u201d\u3002\u5f53\u6211\u4eec\u8bbf\u95ee\u6570\u7ec4\u5143\u7d20\u65f6\uff0c\u8ba1\u7b97\u673a\u4e0d\u4ec5\u4f1a\u52a0\u8f7d\u5b83\uff0c\u8fd8\u4f1a\u7f13\u5b58\u5176\u5468\u56f4\u7684\u5176\u4ed6\u6570\u636e\uff0c\u4ece\u800c\u501f\u52a9\u9ad8\u901f\u7f13\u5b58\u6765\u63d0\u5347\u540e\u7eed\u64cd\u4f5c\u7684\u6267\u884c\u901f\u5ea6\u3002\u94fe\u8868\u5219\u4e0d\u7136\uff0c\u8ba1\u7b97\u673a\u53ea\u80fd\u6328\u4e2a\u5730\u7f13\u5b58\u5404\u4e2a\u8282\u70b9\uff0c\u8fd9\u6837\u7684\u591a\u6b21\u201c\u642c\u8fd0\u201d\u964d\u4f4e\u4e86\u6574\u4f53\u6548\u7387\u3002

    "},{"location":"chapter_array_and_linkedlist/summary/#441-q-a","title":"4.4.1. \u00a0 Q & A","text":"

    \u6570\u7ec4\u5b58\u50a8\u5728\u6808\u4e0a\u548c\u5b58\u50a8\u5728\u5806\u4e0a\uff0c\u5bf9\u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u662f\u5426\u6709\u5f71\u54cd\uff1f

    \u6808\u5185\u5b58\u5206\u914d\u7531\u7f16\u8bd1\u5668\u81ea\u52a8\u5b8c\u6210\uff0c\u800c\u5806\u5185\u5b58\u7531\u7a0b\u5e8f\u5458\u5728\u4ee3\u7801\u4e2d\u5206\u914d\uff08\u6ce8\u610f\uff0c\u8fd9\u91cc\u7684\u6808\u548c\u5806\u548c\u6570\u636e\u7ed3\u6784\u4e2d\u7684\u6808\u548c\u5806\u4e0d\u662f\u540c\u4e00\u6982\u5ff5\uff09\u3002

    1. \u6808\u4e0d\u7075\u6d3b\uff0c\u5206\u914d\u7684\u5185\u5b58\u5927\u5c0f\u4e0d\u53ef\u66f4\u6539\uff1b\u5806\u76f8\u5bf9\u7075\u6d3b\uff0c\u53ef\u4ee5\u52a8\u6001\u5206\u914d\u5185\u5b58\uff1b
    2. \u6808\u662f\u4e00\u5757\u6bd4\u8f83\u5c0f\u7684\u5185\u5b58\uff0c\u5bb9\u6613\u51fa\u73b0\u5185\u5b58\u4e0d\u8db3\uff1b\u5806\u5185\u5b58\u5f88\u5927\uff0c\u4f46\u662f\u7531\u4e8e\u662f\u52a8\u6001\u5206\u914d\uff0c\u5bb9\u6613\u788e\u7247\u5316\uff0c\u7ba1\u7406\u5806\u5185\u5b58\u7684\u96be\u5ea6\u66f4\u5927\u3001\u6210\u672c\u66f4\u9ad8\uff1b
    3. \u8bbf\u95ee\u6808\u6bd4\u8bbf\u95ee\u5806\u66f4\u5feb\uff0c\u56e0\u4e3a\u6808\u5185\u5b58\u8f83\u5c0f\u3001\u5bf9\u7f13\u5b58\u53cb\u597d\uff0c\u5806\u5e27\u5206\u6563\u5728\u5f88\u5927\u7684\u7a7a\u95f4\u5185\uff0c\u4f1a\u51fa\u73b0\u66f4\u591a\u7684\u7f13\u5b58\u672a\u547d\u4e2d\uff1b

    \u4e3a\u4ec0\u4e48\u6570\u7ec4\u4f1a\u5f3a\u8c03\u8981\u6c42\u76f8\u540c\u7c7b\u578b\u7684\u5143\u7d20\uff0c\u800c\u5728\u94fe\u8868\u4e2d\u5374\u6ca1\u6709\u5f3a\u8c03\u540c\u7c7b\u578b\u5462\uff1f

    \u94fe\u8868\u7531\u7ed3\u70b9\u7ec4\u6210\uff0c\u7ed3\u70b9\u4e4b\u95f4\u7531\u6307\u9488\u8fde\u63a5\uff0c\u5404\u4e2a\u7ed3\u70b9\u53ef\u4ee5\u5b58\u50a8\u4e0d\u540c\u7c7b\u578b\u7684\u6570\u636e\uff0c\u4f8b\u5982 int, double, string, object \u7b49\u3002

    \u76f8\u5bf9\u5730\uff0c\u6570\u7ec4\u5143\u7d20\u5219\u5fc5\u987b\u662f\u76f8\u540c\u7c7b\u578b\u7684\uff0c\u8fd9\u6837\u624d\u80fd\u901a\u8fc7\u8ba1\u7b97\u504f\u79fb\u91cf\u6765\u83b7\u53d6\u5bf9\u5e94\u5143\u7d20\u4f4d\u7f6e\u3002\u4f8b\u5982\uff0c\u5982\u679c\u6570\u7ec4\u540c\u65f6\u5305\u542b int \u548c long \u4e24\u79cd\u7c7b\u578b\uff0c\u5355\u4e2a\u5143\u7d20\u5206\u522b\u5360\u7528 4 bytes \u548c 8 bytes \uff0c\u90a3\u4e48\u6b64\u65f6\u5c31\u4e0d\u80fd\u7528\u4ee5\u4e0b\u516c\u5f0f\u8ba1\u7b97\u504f\u79fb\u91cf\u4e86\uff0c\u56e0\u4e3a\u6570\u7ec4\u4e2d\u5305\u542b\u4e86\u4e24\u79cd elementLength \u3002

    // \u5143\u7d20\u5185\u5b58\u5730\u5740 = \u6570\u7ec4\u5185\u5b58\u5730\u5740 + \u5143\u7d20\u957f\u5ea6 * \u5143\u7d20\u7d22\u5f15\nelementAddr = firtstElementAddr + elementLength * elementIndex\n

    \u5220\u9664\u8282\u70b9\u540e\uff0c\u662f\u5426\u9700\u8981\u628a P.next \u8bbe\u4e3a \\(\\text{None}\\) \u5462\uff1f

    \u4e0d\u4fee\u6539 P.next \u4e5f\u53ef\u4ee5\u3002\u4ece\u8be5\u94fe\u8868\u7684\u89d2\u5ea6\u770b\uff0c\u4ece\u5934\u7ed3\u70b9\u904d\u5386\u5230\u5c3e\u7ed3\u70b9\u5df2\u7ecf\u9047\u4e0d\u5230 P \u4e86\u3002\u8fd9\u610f\u5473\u7740\u7ed3\u70b9 P \u5df2\u7ecf\u4ece\u94fe\u8868\u4e2d\u5220\u9664\u4e86\uff0c\u6b64\u65f6\u7ed3\u70b9 P \u6307\u5411\u54ea\u91cc\u90fd\u4e0d\u4f1a\u5bf9\u8fd9\u6761\u94fe\u8868\u4ea7\u751f\u5f71\u54cd\u4e86\u3002

    \u4ece\u5783\u573e\u56de\u6536\u7684\u89d2\u5ea6\u770b\uff0c\u5bf9\u4e8e Java, Python, Go \u7b49\u62e5\u6709\u81ea\u52a8\u5783\u573e\u56de\u6536\u7684\u8bed\u8a00\u6765\u8bf4\uff0c\u8282\u70b9 P \u662f\u5426\u88ab\u56de\u6536\u53d6\u51b3\u4e8e\u662f\u5426\u6709\u4ecd\u5b58\u5728\u6307\u5411\u5b83\u7684\u5f15\u7528\uff0c\u800c\u4e0d\u662f P.next \u7684\u503c\u3002\u5728 C, C++ \u7b49\u8bed\u8a00\u4e2d\uff0c\u6211\u4eec\u9700\u8981\u624b\u52a8\u91ca\u653e\u8282\u70b9\u5185\u5b58\u3002

    \u5728\u94fe\u8868\u4e2d\u63d2\u5165\u548c\u5220\u9664\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(1)\\) \u3002\u4f46\u662f\u589e\u5220\u4e4b\u524d\u90fd\u9700\u8981 \\(O(n)\\) \u67e5\u627e\u5143\u7d20\uff0c\u90a3\u4e3a\u4ec0\u4e48\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u662f \\(O(n)\\) \u5462\uff1f

    \u5982\u679c\u662f\u5148\u67e5\u627e\u5143\u7d20\u3001\u518d\u5220\u9664\u5143\u7d20\uff0c\u786e\u5b9e\u662f \\(O(n)\\) \u3002\u7136\u800c\uff0c\u94fe\u8868\u7684 \\(O(1)\\) \u589e\u5220\u7684\u4f18\u52bf\u53ef\u4ee5\u5728\u5176\u4ed6\u5e94\u7528\u4e0a\u5f97\u5230\u4f53\u73b0\u3002\u4f8b\u5982\uff0c\u53cc\u5411\u961f\u5217\u9002\u5408\u4f7f\u7528\u94fe\u8868\u5b9e\u73b0\uff0c\u6211\u4eec\u7ef4\u62a4\u4e00\u4e2a\u6307\u9488\u53d8\u91cf\u59cb\u7ec8\u6307\u5411\u5934\u7ed3\u70b9\u3001\u5c3e\u7ed3\u70b9\uff0c\u6bcf\u6b21\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u90fd\u662f \\(O(1)\\) \u3002

    \u56fe\u7247\u201c\u94fe\u8868\u5b9a\u4e49\u4e0e\u5b58\u50a8\u65b9\u5f0f\u201d\u4e2d\uff0c\u6d45\u84dd\u8272\u7684\u5b58\u50a8\u7ed3\u70b9\u6307\u9488\u662f\u5360\u7528\u4e00\u5757\u5185\u5b58\u5730\u5740\u5417\uff1f\u8fd8\u662f\u548c\u7ed3\u70b9\u503c\u5404\u5360\u4e00\u534a\u5462\uff1f

    \u6587\u4e2d\u53ea\u662f\u4e00\u4e2a\u793a\u610f\u56fe\uff0c\u53ea\u662f\u5b9a\u6027\u8868\u793a\u3002\u5b9a\u91cf\u7684\u8bdd\u9700\u8981\u6839\u636e\u5177\u4f53\u60c5\u51b5\u5206\u6790\uff1a

    • \u4e0d\u540c\u7c7b\u578b\u7684\u7ed3\u70b9\u503c\u5360\u7528\u7684\u7a7a\u95f4\u662f\u4e0d\u540c\u7684\uff0c\u6bd4\u5982 int, long, double, \u6216\u8005\u662f\u7c7b\u7684\u5b9e\u4f8b\u7b49\u7b49\u3002
    • \u6307\u9488\u53d8\u91cf\u5360\u7528\u7684\u5185\u5b58\u7a7a\u95f4\u5927\u5c0f\u6839\u636e\u6240\u4f7f\u7528\u7684\u64cd\u4f5c\u7cfb\u7edf\u53ca\u7f16\u8bd1\u73af\u5883\u800c\u5b9a\uff0c\u5927\u591a\u4e3a 8 \u5b57\u8282\u6216 4 \u5b57\u8282\u3002

    \u5728\u5217\u8868\u672b\u5c3e\u6dfb\u52a0\u5143\u7d20\u662f\u5426\u65f6\u65f6\u523b\u523b\u90fd\u4e3a \\(O(1)\\) \uff1f

    \u5982\u679c\u6dfb\u52a0\u5143\u7d20\u65f6\u8d85\u51fa\u5217\u8868\u957f\u5ea6\uff0c\u5219\u9700\u8981\u5148\u6269\u5bb9\u5217\u8868\u518d\u6dfb\u52a0\u3002\u7cfb\u7edf\u4f1a\u7533\u8bf7\u4e00\u5757\u65b0\u7684\u5185\u5b58\uff0c\u5e76\u5c06\u539f\u5217\u8868\u7684\u6240\u6709\u5143\u7d20\u642c\u8fd0\u8fc7\u53bb\uff0c\u8fd9\u65f6\u5019\u65f6\u95f4\u590d\u6742\u5ea6\u5c31\u4f1a\u662f \\(O(n)\\) \u3002

    \u201c\u5217\u8868\u7684\u51fa\u73b0\u5927\u5927\u63d0\u5347\u4e86\u6570\u7ec4\u7684\u5b9e\u7528\u6027\uff0c\u4f46\u526f\u4f5c\u7528\u662f\u4f1a\u9020\u6210\u90e8\u5206\u5185\u5b58\u7a7a\u95f4\u6d6a\u8d39\u201d\uff0c\u8fd9\u91cc\u7684\u7a7a\u95f4\u6d6a\u8d39\u662f\u6307\u989d\u5916\u589e\u52a0\u7684\u53d8\u91cf\u5982\u5bb9\u91cf\u3001\u957f\u5ea6\u3001\u6269\u5bb9\u500d\u6570\u6240\u5360\u7684\u5185\u5b58\u5417\uff1f

    \u8fd9\u91cc\u7684\u7a7a\u95f4\u6d6a\u8d39\u4e3b\u8981\u6709\u4e24\u65b9\u9762\u542b\u4e49\uff1a\u4e00\u65b9\u9762\uff0c\u5217\u8868\u90fd\u4f1a\u8bbe\u5b9a\u4e00\u4e2a\u521d\u59cb\u957f\u5ea6\uff0c\u6211\u4eec\u4e0d\u4e00\u5b9a\u9700\u8981\u7528\u8fd9\u4e48\u591a\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u4e3a\u4e86\u9632\u6b62\u9891\u7e41\u6269\u5bb9\uff0c\u6269\u5bb9\u4e00\u822c\u90fd\u4f1a\u4e58\u4ee5\u4e00\u4e2a\u7cfb\u6570\uff0c\u6bd4\u5982 \\(\\times 1.5\\) \u3002\u8fd9\u6837\u4e00\u6765\uff0c\u4e5f\u4f1a\u51fa\u73b0\u5f88\u591a\u7a7a\u4f4d\uff0c\u6211\u4eec\u901a\u5e38\u4e0d\u80fd\u5b8c\u5168\u586b\u6ee1\u5b83\u4eec\u3002

    \u5728 Python \u4e2d\u521d\u59cb\u5316 n = [1, 2, 3] \u540e\uff0c\u8fd9 3 \u4e2a\u5143\u7d20\u7684\u5730\u5740\u662f\u76f8\u8fde\u7684\uff0c\u4f46\u662f\u521d\u59cb\u5316 m = [2, 1, 3] \u4f1a\u53d1\u73b0\u5b83\u4eec\u6bcf\u4e2a\u5143\u7d20\u7684 id \u5e76\u4e0d\u662f\u8fde\u7eed\u7684\uff0c\u800c\u662f\u5206\u522b\u8ddf n \u4e2d\u7684\u76f8\u540c\u3002\u8fd9\u4e9b\u5143\u7d20\u5730\u5740\u4e0d\u8fde\u7eed\uff0c\u90a3\u4e48 m \u8fd8\u662f\u6570\u7ec4\u5417\uff1f

    \u5047\u5982\u628a\u5217\u8868\u5143\u7d20\u6362\u6210\u94fe\u8868\u8282\u70b9 n = [n1, n2, n3, n4, n5] \uff0c\u901a\u5e38\u60c5\u51b5\u4e0b\u8fd9\u4e94\u4e2a\u8282\u70b9\u5bf9\u8c61\u4e5f\u662f\u88ab\u5206\u6563\u5b58\u50a8\u5728\u5185\u5b58\u5404\u5904\u7684\u3002\u7136\u800c\uff0c\u7ed9\u5b9a\u4e00\u4e2a\u5217\u8868\u7d22\u5f15\uff0c\u6211\u4eec\u4ecd\u7136\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u83b7\u53d6\u5230\u8282\u70b9\u5185\u5b58\u5730\u5740\uff0c\u4ece\u800c\u8bbf\u95ee\u5230\u5bf9\u5e94\u7684\u8282\u70b9\u3002\u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u4e2d\u5b58\u50a8\u7684\u662f\u8282\u70b9\u7684\u5f15\u7528\uff0c\u800c\u975e\u8282\u70b9\u672c\u8eab\u3002

    \u4e0e\u8bb8\u591a\u8bed\u8a00\u4e0d\u540c\u7684\u662f\uff0c\u5728 Python \u4e2d\u6570\u5b57\u4e5f\u88ab\u5305\u88c5\u4e3a\u5bf9\u8c61\uff0c\u5217\u8868\u4e2d\u5b58\u50a8\u7684\u4e0d\u662f\u6570\u5b57\u672c\u8eab\uff0c\u800c\u662f\u5bf9\u6570\u5b57\u7684\u5f15\u7528\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u4f1a\u53d1\u73b0\u4e24\u4e2a\u6570\u7ec4\u4e2d\u7684\u76f8\u540c\u6570\u5b57\u62e5\u6709\u540c\u4e00\u4e2a id \uff0c\u5e76\u4e14\u8fd9\u4e9b\u6570\u5b57\u7684\u5185\u5b58\u5730\u5740\u662f\u65e0\u9700\u8fde\u7eed\u7684\u3002

    "},{"location":"chapter_backtracking/","title":"12. \u00a0 \u56de\u6eaf","text":""},{"location":"chapter_backtracking/backtracking_algorithm/","title":"12.1. \u00a0 \u56de\u6eaf\u7b97\u6cd5","text":"

    \u300c\u56de\u6eaf\u7b97\u6cd5 Backtracking Algorithm\u300d\u662f\u4e00\u79cd\u901a\u8fc7\u7a77\u4e3e\u6765\u89e3\u51b3\u95ee\u9898\u7684\u65b9\u6cd5\uff0c\u5b83\u7684\u6838\u5fc3\u601d\u60f3\u662f\u4ece\u4e00\u4e2a\u521d\u59cb\u72b6\u6001\u51fa\u53d1\uff0c\u66b4\u529b\u641c\u7d22\u6240\u6709\u53ef\u80fd\u7684\u89e3\u51b3\u65b9\u6848\uff0c\u5f53\u9047\u5230\u6b63\u786e\u7684\u89e3\u5219\u5c06\u5176\u8bb0\u5f55\uff0c\u76f4\u5230\u627e\u5230\u89e3\u6216\u8005\u5c1d\u8bd5\u4e86\u6240\u6709\u53ef\u80fd\u7684\u9009\u62e9\u90fd\u65e0\u6cd5\u627e\u5230\u89e3\u4e3a\u6b62\u3002

    \u56de\u6eaf\u7b97\u6cd5\u901a\u5e38\u91c7\u7528\u300c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u300d\u6765\u904d\u5386\u89e3\u7a7a\u95f4\u3002\u5728\u4e8c\u53c9\u6811\u7ae0\u8282\u4e2d\uff0c\u6211\u4eec\u63d0\u5230\u524d\u5e8f\u3001\u4e2d\u5e8f\u548c\u540e\u5e8f\u904d\u5386\u90fd\u5c5e\u4e8e\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u3002\u63a5\u4e0b\u6765\u6211\u4eec\u5148\u7528\u524d\u5e8f\u904d\u5386\u6784\u9020\u4e00\u4e2a\u56de\u6eaf\u95ee\u9898\uff0c\u9010\u6b65\u4e86\u89e3\u56de\u6eaf\u7b97\u6cd5\u7684\u5de5\u4f5c\u539f\u7406\u3002

    \u4f8b\u9898\u4e00

    \u7ed9\u5b9a\u4e00\u4e2a\u4e8c\u53c9\u6811\uff0c\u641c\u7d22\u5e76\u8bb0\u5f55\u6240\u6709\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\uff0c\u8fd4\u56de\u8282\u70b9\u5217\u8868\u3002

    \u89e3\u9898\u601d\u8def\uff1a\u524d\u5e8f\u904d\u5386\u8fd9\u9897\u6811\uff0c\u5e76\u5224\u65ad\u5f53\u524d\u8282\u70b9\u7684\u503c\u662f\u5426\u4e3a \\(7\\) \uff0c\u82e5\u662f\u5219\u5c06\u8be5\u8282\u70b9\u7684\u503c\u52a0\u5165\u5230\u7ed3\u679c\u5217\u8868 res \u4e4b\u4e2d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart preorder_traversal_i_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode root) {\nif (root == null) {\nreturn;\n}\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.add(root);\n}\npreOrder(root.left);\npreOrder(root.right);\n}\n
    preorder_traversal_i_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode *root) {\nif (root == nullptr) {\nreturn;\n}\nif (root->val == 7) {\n// \u8bb0\u5f55\u89e3\nres.push_back(root);\n}\npreOrder(root->left);\npreOrder(root->right);\n}\n
    preorder_traversal_i_compact.py
    def pre_order(root: TreeNode) -> None:\n\"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00\"\"\"\nif root is None:\nreturn\nif root.val == 7:\n# \u8bb0\u5f55\u89e3\nres.append(root)\npre_order(root.left)\npre_order(root.right)\n
    preorder_traversal_i_compact.go
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\nif root == nil {\nreturn\n}\nif int(root.Val) == 7 {\n// \u8bb0\u5f55\u89e3\n*res = append(*res, root)\n}\npreOrderI(root.Left, res)\npreOrderI(root.Right, res)\n}\n
    preorder_traversal_i_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunction preOrder(root, res) {\nif (root === null) {\nreturn;\n}\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push(root);\n}\npreOrder(root.left, res);\npreOrder(root.right, res);\n}\n
    preorder_traversal_i_compact.ts
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunction preOrder(root: TreeNode | null, res: TreeNode[]): void {\nif (root === null) {\nreturn;\n}\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push(root);\n}\npreOrder(root.left, res);\npreOrder(root.right, res);\n}\n
    preorder_traversal_i_compact.c
    [class]{}-[func]{preOrder}\n
    preorder_traversal_i_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode root) {\nif (root == null) {\nreturn;\n}\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.Add(root);\n}\npreOrder(root.left);\npreOrder(root.right);\n}\n
    preorder_traversal_i_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunc preOrder(root: TreeNode?) {\nguard let root = root else {\nreturn\n}\nif root.val == 7 {\n// \u8bb0\u5f55\u89e3\nres.append(root)\n}\npreOrder(root: root.left)\npreOrder(root: root.right)\n}\n
    preorder_traversal_i_compact.zig
    [class]{}-[func]{preOrder}\n
    preorder_traversal_i_compact.dart
    [class]{}-[func]{preOrder}\n

    Fig. \u5728\u524d\u5e8f\u904d\u5386\u4e2d\u641c\u7d22\u8282\u70b9

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1211","title":"12.1.1. \u00a0 \u5c1d\u8bd5\u4e0e\u56de\u9000","text":"

    \u4e4b\u6240\u4ee5\u79f0\u4e4b\u4e3a\u56de\u6eaf\u7b97\u6cd5\uff0c\u662f\u56e0\u4e3a\u8be5\u7b97\u6cd5\u5728\u641c\u7d22\u89e3\u7a7a\u95f4\u65f6\u4f1a\u91c7\u7528\u201c\u5c1d\u8bd5\u201d\u4e0e\u201c\u56de\u9000\u201d\u7684\u7b56\u7565\u3002\u5f53\u7b97\u6cd5\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u9047\u5230\u67d0\u4e2a\u72b6\u6001\u65e0\u6cd5\u7ee7\u7eed\u524d\u8fdb\u6216\u65e0\u6cd5\u5f97\u5230\u6ee1\u8db3\u6761\u4ef6\u7684\u89e3\u65f6\uff0c\u5b83\u4f1a\u64a4\u9500\u4e0a\u4e00\u6b65\u7684\u9009\u62e9\uff0c\u9000\u56de\u5230\u4e4b\u524d\u7684\u72b6\u6001\uff0c\u5e76\u5c1d\u8bd5\u5176\u4ed6\u53ef\u80fd\u7684\u9009\u62e9\u3002

    \u5bf9\u4e8e\u4f8b\u9898\u4e00\uff0c\u8bbf\u95ee\u6bcf\u4e2a\u8282\u70b9\u90fd\u4ee3\u8868\u4e00\u6b21\u201c\u5c1d\u8bd5\u201d\uff0c\u800c\u8d8a\u8fc7\u53f6\u7ed3\u70b9\u6216\u8fd4\u56de\u7236\u8282\u70b9\u7684 return \u5219\u8868\u793a\u201c\u56de\u9000\u201d\u3002

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\u56de\u9000\u5e76\u4e0d\u7b49\u4ef7\u4e8e\u51fd\u6570\u8fd4\u56de\u3002\u4e3a\u89e3\u91ca\u8fd9\u4e00\u70b9\uff0c\u6211\u4eec\u5bf9\u4f8b\u9898\u4e00\u7a0d\u4f5c\u62d3\u5c55\u3002

    \u4f8b\u9898\u4e8c

    \u5728\u4e8c\u53c9\u6811\u4e2d\u641c\u7d22\u6240\u6709\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\uff0c\u8fd4\u56de\u6839\u8282\u70b9\u5230\u8fd9\u4e9b\u8282\u70b9\u7684\u8def\u5f84\u3002

    \u89e3\u9898\u601d\u8def\uff1a\u5728\u4f8b\u9898\u4e00\u4ee3\u7801\u7684\u57fa\u7840\u4e0a\uff0c\u6211\u4eec\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u5217\u8868 path \u8bb0\u5f55\u8bbf\u95ee\u8fc7\u7684\u8282\u70b9\u8def\u5f84\u3002\u5f53\u8bbf\u95ee\u5230\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\u65f6\uff0c\u5219\u590d\u5236 path \u5e76\u6dfb\u52a0\u8fdb\u7ed3\u679c\u5217\u8868 res \u3002\u904d\u5386\u5b8c\u6210\u540e\uff0cres \u4e2d\u4fdd\u5b58\u7684\u5c31\u662f\u6240\u6709\u7684\u89e3\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart preorder_traversal_ii_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode root) {\nif (root == null) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.add(root);\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.add(new ArrayList<>(path));\n}\npreOrder(root.left);\npreOrder(root.right);\n// \u56de\u9000\npath.remove(path.size() - 1);\n}\n
    preorder_traversal_ii_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode *root) {\nif (root == nullptr) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push_back(root);\nif (root->val == 7) {\n// \u8bb0\u5f55\u89e3\nres.push_back(path);\n}\npreOrder(root->left);\npreOrder(root->right);\n// \u56de\u9000\npath.pop_back();\n}\n
    preorder_traversal_ii_compact.py
    def pre_order(root: TreeNode) -> None:\n\"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c\"\"\"\nif root is None:\nreturn\n# \u5c1d\u8bd5\npath.append(root)\nif root.val == 7:\n# \u8bb0\u5f55\u89e3\nres.append(list(path))\npre_order(root.left)\npre_order(root.right)\n# \u56de\u9000\npath.pop()\n
    preorder_traversal_ii_compact.go
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\nif root == nil {\nreturn\n}\n// \u5c1d\u8bd5\n*path = append(*path, root)\nif int(root.Val) == 7 {\n// \u8bb0\u5f55\u89e3\n*res = append(*res, *path)\n}\npreOrderII(root.Left, res, path)\npreOrderII(root.Right, res, path)\n// \u56de\u9000\n*path = (*path)[:len(*path)-1]\n}\n
    preorder_traversal_ii_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunction preOrder(root, path, res) {\nif (root === null) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push(root);\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push([...path]);\n}\npreOrder(root.left, path, res);\npreOrder(root.right, path, res);\n// \u56de\u9000\npath.pop();\n}\n
    preorder_traversal_ii_compact.ts
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunction preOrder(\nroot: TreeNode | null,\npath: TreeNode[],\nres: TreeNode[][]\n): void {\nif (root === null) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push(root);\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push([...path]);\n}\npreOrder(root.left, path, res);\npreOrder(root.right, path, res);\n// \u56de\u9000\npath.pop();\n}\n
    preorder_traversal_ii_compact.c
    [class]{}-[func]{preOrder}\n
    preorder_traversal_ii_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode root) {\nif (root == null) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.Add(root);\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.Add(new List<TreeNode>(path));\n}\npreOrder(root.left);\npreOrder(root.right);\n// \u56de\u9000\npath.RemoveAt(path.Count - 1);\n}\n
    preorder_traversal_ii_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunc preOrder(root: TreeNode?) {\nguard let root = root else {\nreturn\n}\n// \u5c1d\u8bd5\npath.append(root)\nif root.val == 7 {\n// \u8bb0\u5f55\u89e3\nres.append(path)\n}\npreOrder(root: root.left)\npreOrder(root: root.right)\n// \u56de\u9000\npath.removeLast()\n}\n
    preorder_traversal_ii_compact.zig
    [class]{}-[func]{preOrder}\n
    preorder_traversal_ii_compact.dart
    [class]{}-[func]{preOrder}\n

    \u5728\u6bcf\u6b21\u201c\u5c1d\u8bd5\u201d\u4e2d\uff0c\u6211\u4eec\u901a\u8fc7\u5c06\u5f53\u524d\u8282\u70b9\u6dfb\u52a0\u8fdb path \u6765\u8bb0\u5f55\u8def\u5f84\uff1b\u800c\u5728\u201c\u56de\u9000\u201d\u524d\uff0c\u6211\u4eec\u9700\u8981\u5c06\u8be5\u8282\u70b9\u4ece path \u4e2d\u5f39\u51fa\uff0c\u4ee5\u6062\u590d\u672c\u6b21\u5c1d\u8bd5\u4e4b\u524d\u7684\u72b6\u6001\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5c1d\u8bd5\u548c\u56de\u9000\u7406\u89e3\u4e3a\u201c\u524d\u8fdb\u201d\u4e0e\u201c\u64a4\u9500\u201d\uff0c\u4e24\u4e2a\u64cd\u4f5c\u662f\u4e92\u4e3a\u76f8\u53cd\u7684\u3002

    <1><2><3><4><5><6><7><8><9><10><11>

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1212","title":"12.1.2. \u00a0 \u526a\u679d","text":"

    \u590d\u6742\u7684\u56de\u6eaf\u95ee\u9898\u901a\u5e38\u5305\u542b\u4e00\u4e2a\u6216\u591a\u4e2a\u7ea6\u675f\u6761\u4ef6\uff0c\u7ea6\u675f\u6761\u4ef6\u901a\u5e38\u53ef\u7528\u4e8e\u201c\u526a\u679d\u201d\u3002

    \u4f8b\u9898\u4e09

    \u5728\u4e8c\u53c9\u6811\u4e2d\u641c\u7d22\u6240\u6709\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\uff0c\u8fd4\u56de\u6839\u8282\u70b9\u5230\u8fd9\u4e9b\u8282\u70b9\u7684\u8def\u5f84\uff0c\u8def\u5f84\u4e2d\u4e0d\u80fd\u5305\u542b\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u3002

    \u89e3\u9898\u601d\u8def\uff1a\u5728\u4f8b\u9898\u4e8c\u7684\u57fa\u7840\u4e0a\u6dfb\u52a0\u526a\u679d\u64cd\u4f5c\uff0c\u5f53\u9047\u5230\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u65f6\uff0c\u5219\u7ec8\u6b62\u7ee7\u7eed\u641c\u7d22\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart preorder_traversal_iii_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode root) {\n// \u526a\u679d\nif (root == null || root.val == 3) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.add(root);\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.add(new ArrayList<>(path));\n}\npreOrder(root.left);\npreOrder(root.right);\n// \u56de\u9000\npath.remove(path.size() - 1);\n}\n
    preorder_traversal_iii_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode *root) {\n// \u526a\u679d\nif (root == nullptr || root->val == 3) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push_back(root);\nif (root->val == 7) {\n// \u8bb0\u5f55\u89e3\nres.push_back(path);\n}\npreOrder(root->left);\npreOrder(root->right);\n// \u56de\u9000\npath.pop_back();\n}\n
    preorder_traversal_iii_compact.py
    def pre_order(root: TreeNode) -> None:\n\"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09\"\"\"\n# \u526a\u679d\nif root is None or root.val == 3:\nreturn\n# \u5c1d\u8bd5\npath.append(root)\nif root.val == 7:\n# \u8bb0\u5f55\u89e3\nres.append(list(path))\npre_order(root.left)\npre_order(root.right)\n# \u56de\u9000\npath.pop()\n
    preorder_traversal_iii_compact.go
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunc preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n// \u526a\u679d\nif root == nil || root.Val == 3 {\nreturn\n}\n// \u5c1d\u8bd5\n*path = append(*path, root)\nif int(root.Val) == 7 {\n// \u8bb0\u5f55\u89e3\n*res = append(*res, *path)\n}\npreOrderIII(root.Left, res, path)\npreOrderIII(root.Right, res, path)\n// \u56de\u9000\n*path = (*path)[:len(*path)-1]\n}\n
    preorder_traversal_iii_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunction preOrder(root, path, res) {\n// \u526a\u679d\nif (root === null || root.val === 3) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push(root);\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push([...path]);\n}\npreOrder(root.left, path, res);\npreOrder(root.right, path, res);\n// \u56de\u9000\npath.pop();\n}\n
    preorder_traversal_iii_compact.ts
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunction preOrder(\nroot: TreeNode | null,\npath: TreeNode[],\nres: TreeNode[][]\n): void {\n// \u526a\u679d\nif (root === null || root.val === 3) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.push(root);\nif (root.val === 7) {\n// \u8bb0\u5f55\u89e3\nres.push([...path]);\n}\npreOrder(root.left, path, res);\npreOrder(root.right, path, res);\n// \u56de\u9000\npath.pop();\n}\n
    preorder_traversal_iii_compact.c
    [class]{}-[func]{preOrder}\n
    preorder_traversal_iii_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode root) {\n// \u526a\u679d\nif (root == null || root.val == 3) {\nreturn;\n}\n// \u5c1d\u8bd5\npath.Add(root);\nif (root.val == 7) {\n// \u8bb0\u5f55\u89e3\nres.Add(new List<TreeNode>(path));\n}\npreOrder(root.left);\npreOrder(root.right);\n// \u56de\u9000\npath.RemoveAt(path.Count - 1);\n}\n
    preorder_traversal_iii_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunc preOrder(root: TreeNode?) {\n// \u526a\u679d\nguard let root = root, root.val != 3 else {\nreturn\n}\n// \u5c1d\u8bd5\npath.append(root)\nif root.val == 7 {\n// \u8bb0\u5f55\u89e3\nres.append(path)\n}\npreOrder(root: root.left)\npreOrder(root: root.right)\n// \u56de\u9000\npath.removeLast()\n}\n
    preorder_traversal_iii_compact.zig
    [class]{}-[func]{preOrder}\n
    preorder_traversal_iii_compact.dart
    [class]{}-[func]{preOrder}\n

    \u526a\u679d\u662f\u4e00\u4e2a\u975e\u5e38\u5f62\u8c61\u7684\u540d\u8bcd\u3002\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u6211\u4eec\u5229\u7528\u7ea6\u675f\u6761\u4ef6\u201c\u526a\u6389\u201d\u4e86\u4e0d\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\u7684\u641c\u7d22\u5206\u652f\uff0c\u907f\u514d\u8bb8\u591a\u65e0\u610f\u4e49\u7684\u5c1d\u8bd5\uff0c\u4ece\u800c\u63d0\u5347\u641c\u7d22\u6548\u7387\u3002

    Fig. \u6839\u636e\u7ea6\u675f\u6761\u4ef6\u526a\u679d

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1213","title":"12.1.3. \u00a0 \u5e38\u7528\u672f\u8bed","text":"

    \u4e3a\u4e86\u66f4\u6e05\u6670\u5730\u5206\u6790\u7b97\u6cd5\u95ee\u9898\uff0c\u6211\u4eec\u603b\u7ed3\u4e00\u4e0b\u56de\u6eaf\u7b97\u6cd5\u4e2d\u5e38\u7528\u672f\u8bed\u7684\u542b\u4e49\uff0c\u5e76\u5bf9\u7167\u4f8b\u9898\u4e09\u7ed9\u51fa\u5bf9\u5e94\u793a\u4f8b\u3002

    \u540d\u8bcd \u5b9a\u4e49 \u4f8b\u9898\u4e09 \u89e3 Solution \u89e3\u662f\u6ee1\u8db3\u95ee\u9898\u7279\u5b9a\u6761\u4ef6\u7684\u7b54\u6848\u3002\u56de\u6eaf\u7b97\u6cd5\u7684\u76ee\u6807\u662f\u627e\u5230\u4e00\u4e2a\u6216\u591a\u4e2a\u6ee1\u8db3\u6761\u4ef6\u7684\u89e3 \u6839\u8282\u70b9\u5230\u8282\u70b9 \\(7\\) \u7684\u6240\u6709\u8def\u5f84\uff0c\u4e14\u8def\u5f84\u4e2d\u4e0d\u5305\u542b\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9 \u72b6\u6001 State \u72b6\u6001\u8868\u793a\u95ee\u9898\u5728\u67d0\u4e00\u65f6\u523b\u7684\u60c5\u51b5\uff0c\u5305\u62ec\u5df2\u7ecf\u505a\u51fa\u7684\u9009\u62e9 \u5f53\u524d\u5df2\u8bbf\u95ee\u7684\u8282\u70b9\u8def\u5f84\uff0c\u5373 path \u8282\u70b9\u5217\u8868 \u7ea6\u675f\u6761\u4ef6 Constraint \u7ea6\u675f\u6761\u4ef6\u662f\u95ee\u9898\u4e2d\u9650\u5236\u89e3\u7684\u53ef\u884c\u6027\u7684\u6761\u4ef6\uff0c\u901a\u5e38\u7528\u4e8e\u526a\u679d \u8981\u6c42\u8def\u5f84\u4e2d\u4e0d\u80fd\u5305\u542b\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9 \u5c1d\u8bd5 Attempt \u5c1d\u8bd5\u662f\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u6839\u636e\u5f53\u524d\u72b6\u6001\u548c\u53ef\u7528\u9009\u62e9\u6765\u63a2\u7d22\u89e3\u7a7a\u95f4\u7684\u8fc7\u7a0b\u3002\u5c1d\u8bd5\u5305\u62ec\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\uff0c\u68c0\u67e5\u662f\u5426\u4e3a\u89e3 \u9012\u5f52\u8bbf\u95ee\u5de6\uff08\u53f3\uff09\u5b50\u8282\u70b9\uff0c\u5c06\u8282\u70b9\u6dfb\u52a0\u8fdb path \uff0c\u5224\u65ad\u8282\u70b9\u7684\u503c\u662f\u5426\u4e3a \\(7\\) \u56de\u9000 Backtracking \u56de\u9000\u6307\u5728\u641c\u7d22\u4e2d\u9047\u5230\u5230\u4e0d\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\u6216\u65e0\u6cd5\u7ee7\u7eed\u641c\u7d22\u7684\u72b6\u6001\u65f6\uff0c\u64a4\u9500\u524d\u9762\u505a\u51fa\u7684\u9009\u62e9\uff0c\u56de\u5230\u4e0a\u4e00\u4e2a\u72b6\u6001 \u5f53\u8d8a\u8fc7\u53f6\u7ed3\u70b9\u3001\u7ed3\u675f\u7ed3\u70b9\u8bbf\u95ee\u3001\u9047\u5230\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u65f6\u7ec8\u6b62\u641c\u7d22\uff0c\u51fd\u6570\u8fd4\u56de \u526a\u679d Pruning \u526a\u679d\u662f\u6839\u636e\u95ee\u9898\u7279\u6027\u548c\u7ea6\u675f\u6761\u4ef6\u907f\u514d\u65e0\u610f\u4e49\u7684\u641c\u7d22\u8def\u5f84\u7684\u65b9\u6cd5\uff0c\u53ef\u63d0\u9ad8\u641c\u7d22\u6548\u7387 \u5f53\u9047\u5230\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u65f6\uff0c\u5219\u7ec8\u6b62\u7ee7\u7eed\u641c\u7d22

    Tip

    \u89e3\u3001\u72b6\u6001\u3001\u7ea6\u675f\u6761\u4ef6\u7b49\u672f\u8bed\u662f\u901a\u7528\u7684\uff0c\u9002\u7528\u4e8e\u56de\u6eaf\u7b97\u6cd5\u3001\u52a8\u6001\u89c4\u5212\u3001\u8d2a\u5fc3\u7b97\u6cd5\u7b49\u3002

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1214","title":"12.1.4. \u00a0 \u6846\u67b6\u4ee3\u7801","text":"

    \u56de\u6eaf\u7b97\u6cd5\u53ef\u7528\u4e8e\u89e3\u51b3\u8bb8\u591a\u641c\u7d22\u95ee\u9898\u3001\u7ea6\u675f\u6ee1\u8db3\u95ee\u9898\u548c\u7ec4\u5408\u4f18\u5316\u95ee\u9898\u3002\u4e3a\u63d0\u5347\u4ee3\u7801\u901a\u7528\u6027\uff0c\u6211\u4eec\u5e0c\u671b\u5c06\u56de\u6eaf\u7b97\u6cd5\u7684\u201c\u5c1d\u8bd5\u3001\u56de\u9000\u3001\u526a\u679d\u201d\u7684\u4e3b\u4f53\u6846\u67b6\u63d0\u70bc\u51fa\u6765\u3002

    \u8bbe state \u4e3a\u95ee\u9898\u7684\u5f53\u524d\u72b6\u6001\uff0cchoices \u8868\u793a\u5f53\u524d\u72b6\u6001\u4e0b\u53ef\u4ee5\u505a\u51fa\u7684\u9009\u62e9\uff0c\u5219\u53ef\u5f97\u5230\u4ee5\u4e0b\u56de\u6eaf\u7b97\u6cd5\u7684\u6846\u67b6\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State state, List<Choice> choices, List<State> res) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (Choice choice : choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State *state, vector<Choice *> &choices, vector<State *> &res) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (Choice choice : choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    def backtrack(state: State, choices: list[choice], res: list[state]) -> None:\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\u6846\u67b6\"\"\"\n# \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif is_solution(state):\n# \u8bb0\u5f55\u89e3\nrecord_solution(state, res)\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nfor choice in choices:\n# \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif is_valid(state, choice):\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmake_choice(state, choice)\nbacktrack(state, choices, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundo_choice(state, choice)\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif isSolution(state) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor _, choice := range choices {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif isValid(state, choice) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice)\nbacktrack(state, choices, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice)\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunction backtrack(state, choices, res) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (let choice of choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunction backtrack(state: State, choices: Choice[], res: State[]): void {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (let choice of choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res, numRes);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < numChoices; i++) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, &choices[i])) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, &choices[i]);\nbacktrack(state, choices, numChoices, res, numRes);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, &choices[i]);\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State state, List<Choice> choices, List<State> res) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nforeach (Choice choice in choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunc backtrack(state: inout State, choices: [Choice], res: inout [State]) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif isSolution(state: state) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state: state, res: &res)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor choice in choices {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif isValid(state: state, choice: choice) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state: &state, choice: choice)\nbacktrack(state: &state, choices: choices, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state: &state, choice: choice)\n}\n}\n}\n
    \n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State state, List<Choice>, List<State> res) {\n// \u5224\u65ad\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (Choice choice in choices) {\n// \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\nbacktrack(state, choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n

    \u4e0b\u9762\uff0c\u6211\u4eec\u5c1d\u8bd5\u57fa\u4e8e\u6b64\u6846\u67b6\u6765\u89e3\u51b3\u4f8b\u9898\u4e09\u3002\u5728\u4f8b\u9898\u4e09\u4e2d\uff0c\u72b6\u6001 state \u662f\u8282\u70b9\u904d\u5386\u8def\u5f84\uff0c\u9009\u62e9 choices \u662f\u5f53\u524d\u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u548c\u53f3\u5b50\u8282\u70b9\uff0c\u7ed3\u679c res \u662f\u8def\u5f84\u5217\u8868\uff0c\u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart preorder_traversal_iii_template.java
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nboolean isSolution(List<TreeNode> state) {\nreturn !state.isEmpty() && state.get(state.size() - 1).val == 7;\n}\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {\nres.add(new ArrayList<>(state));\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nboolean isValid(List<TreeNode> state, TreeNode choice) {\nreturn choice != null && choice.val != 3;\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(List<TreeNode> state, TreeNode choice) {\nstate.add(choice);\n}\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(List<TreeNode> state, TreeNode choice) {\nstate.remove(state.size() - 1);\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nvoid backtrack(List<TreeNode> state, List<TreeNode> choices, List<List<TreeNode>> res) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (TreeNode choice : choices) {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, Arrays.asList(choice.left, choice.right), res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    preorder_traversal_iii_template.cpp
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool isSolution(vector<TreeNode *> &state) {\nreturn !state.empty() && state.back()->val == 7;\n}\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(vector<TreeNode *> &state, vector<vector<TreeNode *>> &res) {\nres.push_back(state);\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nbool isValid(vector<TreeNode *> &state, TreeNode *choice) {\nreturn choice != nullptr && choice->val != 3;\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(vector<TreeNode *> &state, TreeNode *choice) {\nstate.push_back(choice);\n}\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(vector<TreeNode *> &state, TreeNode *choice) {\nstate.pop_back();\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nvoid backtrack(vector<TreeNode *> &state, vector<TreeNode *> &choices, vector<vector<TreeNode *>> &res) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (TreeNode *choice : choices) {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nvector<TreeNode *> nextChoices{choice->left, choice->right};\nbacktrack(state, nextChoices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    preorder_traversal_iii_template.py
    def is_solution(state: list[TreeNode]) -> bool:\n\"\"\"\u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3\"\"\"\nreturn state and state[-1].val == 7\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n\"\"\"\u8bb0\u5f55\u89e3\"\"\"\nres.append(list(state))\ndef is_valid(state: list[TreeNode], choice: TreeNode) -> bool:\n\"\"\"\u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5\"\"\"\nreturn choice is not None and choice.val != 3\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n\"\"\"\u66f4\u65b0\u72b6\u6001\"\"\"\nstate.append(choice)\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n\"\"\"\u6062\u590d\u72b6\u6001\"\"\"\nstate.pop()\ndef backtrack(\nstate: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09\"\"\"\n# \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif is_solution(state):\n# \u8bb0\u5f55\u89e3\nrecord_solution(state, res)\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nfor choice in choices:\n# \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif is_valid(state, choice):\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmake_choice(state, choice)\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, [choice.left, choice.right], res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundo_choice(state, choice)\n
    preorder_traversal_iii_template.go
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunc isSolution(state *[]*TreeNode) bool {\nreturn len(*state) != 0 && (*state)[len(*state)-1].Val == 7\n}\n/* \u8bb0\u5f55\u89e3 */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n*res = append(*res, *state)\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfunc isValid(state *[]*TreeNode, choice *TreeNode) bool {\nreturn choice != nil && choice.Val != 3\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n*state = append(*state, choice)\n}\n/* \u6062\u590d\u72b6\u6001 */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n*state = (*state)[:len(*state)-1]\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunc backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif isSolution(state) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor _, choice := range *choices {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif isValid(state, choice) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\ntemp := make([]*TreeNode, 0)\ntemp = append(temp, choice.Left, choice.Right)\nbacktrackIII(state, &temp, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice)\n}\n}\n}\n
    preorder_traversal_iii_template.js
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunction isSolution(state) {\nreturn state && state[state.length - 1]?.val === 7;\n}\n/* \u8bb0\u5f55\u89e3 */\nfunction recordSolution(state, res) {\nres.push([...state]);\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfunction isValid(state, choice) {\nreturn choice !== null && choice.val !== 3;\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nfunction makeChoice(state, choice) {\nstate.push(choice);\n}\n/* \u6062\u590d\u72b6\u6001 */\nfunction undoChoice(state) {\nstate.pop();\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunction backtrack(state, choices, res) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (const choice of choices) {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, [choice.left, choice.right], res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state);\n}\n}\n}\n
    preorder_traversal_iii_template.ts
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunction isSolution(state: TreeNode[]): boolean {\nreturn state && state[state.length - 1]?.val === 7;\n}\n/* \u8bb0\u5f55\u89e3 */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\nres.push([...state]);\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfunction isValid(state: TreeNode[], choice: TreeNode): boolean {\nreturn choice !== null && choice.val !== 3;\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\nstate.push(choice);\n}\n/* \u6062\u590d\u72b6\u6001 */\nfunction undoChoice(state: TreeNode[]): void {\nstate.pop();\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunction backtrack(\nstate: TreeNode[],\nchoices: TreeNode[],\nres: TreeNode[][]\n): void {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (const choice of choices) {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, [choice.left, choice.right], res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state);\n}\n}\n}\n
    preorder_traversal_iii_template.c
    [class]{}-[func]{isSolution}\n[class]{}-[func]{recordSolution}\n[class]{}-[func]{isValid}\n[class]{}-[func]{makeChoice}\n[class]{}-[func]{undoChoice}\n[class]{}-[func]{backtrack}\n
    preorder_traversal_iii_template.cs
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool isSolution(List<TreeNode> state) {\nreturn state.Count != 0 && state[^1].val == 7;\n}\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {\nres.Add(new List<TreeNode>(state));\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nbool isValid(List<TreeNode> state, TreeNode choice) {\nreturn choice != null && choice.val != 3;\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(List<TreeNode> state, TreeNode choice) {\nstate.Add(choice);\n}\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(List<TreeNode> state, TreeNode choice) {\nstate.RemoveAt(state.Count - 1);\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nvoid backtrack(List<TreeNode> state, List<TreeNode> choices, List<List<TreeNode>> res) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif (isSolution(state)) {\n// \u8bb0\u5f55\u89e3\nrecordSolution(state, res);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nforeach (TreeNode choice in choices) {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif (isValid(state, choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state, choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, new List<TreeNode> { choice.left, choice.right }, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state, choice);\n}\n}\n}\n
    preorder_traversal_iii_template.swift
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunc isSolution(state: [TreeNode]) -> Bool {\n!state.isEmpty && state.last!.val == 7\n}\n/* \u8bb0\u5f55\u89e3 */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\nres.append(state)\n}\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfunc isValid(state: [TreeNode], choice: TreeNode?) -> Bool {\nchoice != nil && choice!.val != 3\n}\n/* \u66f4\u65b0\u72b6\u6001 */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\nstate.append(choice)\n}\n/* \u6062\u590d\u72b6\u6001 */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\nstate.removeLast()\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunc backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {\n// \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\nif isSolution(state: state) {\nrecordSolution(state: state, res: &res)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor choice in choices {\n// \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\nif isValid(state: state, choice: choice) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nmakeChoice(state: &state, choice: choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, choices: [choice.left, choice.right].compactMap { $0 }, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nundoChoice(state: &state, choice: choice)\n}\n}\n}\n
    preorder_traversal_iii_template.zig
    [class]{}-[func]{isSolution}\n[class]{}-[func]{recordSolution}\n[class]{}-[func]{isValid}\n[class]{}-[func]{makeChoice}\n[class]{}-[func]{undoChoice}\n[class]{}-[func]{backtrack}\n
    preorder_traversal_iii_template.dart
    [class]{}-[func]{isSolution}\n[class]{}-[func]{recordSolution}\n[class]{}-[func]{isValid}\n[class]{}-[func]{makeChoice}\n[class]{}-[func]{undoChoice}\n[class]{}-[func]{backtrack}\n

    \u76f8\u8f83\u4e8e\u57fa\u4e8e\u524d\u5e8f\u904d\u5386\u7684\u5b9e\u73b0\u4ee3\u7801\uff0c\u57fa\u4e8e\u56de\u6eaf\u7b97\u6cd5\u6846\u67b6\u7684\u5b9e\u73b0\u4ee3\u7801\u867d\u7136\u663e\u5f97\u5570\u55e6\uff0c\u4f46\u901a\u7528\u6027\u66f4\u597d\u3002\u5b9e\u9645\u4e0a\uff0c\u6240\u6709\u56de\u6eaf\u95ee\u9898\u90fd\u53ef\u4ee5\u5728\u8be5\u6846\u67b6\u4e0b\u89e3\u51b3\u3002\u6211\u4eec\u9700\u8981\u6839\u636e\u5177\u4f53\u95ee\u9898\u6765\u5b9a\u4e49 state \u548c choices \uff0c\u5e76\u5b9e\u73b0\u6846\u67b6\u4e2d\u7684\u5404\u4e2a\u65b9\u6cd5\u3002

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1215","title":"12.1.5. \u00a0 \u4f18\u52bf\u4e0e\u5c40\u9650\u6027","text":"

    \u56de\u6eaf\u7b97\u6cd5\u672c\u8d28\u4e0a\u662f\u4e00\u79cd\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u7b97\u6cd5\uff0c\u5b83\u5c1d\u8bd5\u6240\u6709\u53ef\u80fd\u7684\u89e3\u51b3\u65b9\u6848\u76f4\u5230\u627e\u5230\u6ee1\u8db3\u6761\u4ef6\u7684\u89e3\u3002\u8fd9\u79cd\u65b9\u6cd5\u7684\u4f18\u52bf\u5728\u4e8e\u5b83\u80fd\u591f\u627e\u5230\u6240\u6709\u53ef\u80fd\u7684\u89e3\u51b3\u65b9\u6848\uff0c\u800c\u4e14\u5728\u5408\u7406\u7684\u526a\u679d\u64cd\u4f5c\u4e0b\uff0c\u5177\u6709\u5f88\u9ad8\u7684\u6548\u7387\u3002

    \u7136\u800c\uff0c\u5728\u5904\u7406\u5927\u89c4\u6a21\u6216\u8005\u590d\u6742\u95ee\u9898\u65f6\uff0c\u56de\u6eaf\u7b97\u6cd5\u7684\u8fd0\u884c\u6548\u7387\u53ef\u80fd\u96be\u4ee5\u63a5\u53d7\u3002

    • \u5728\u6700\u574f\u7684\u60c5\u51b5\u4e0b\uff0c\u56de\u6eaf\u7b97\u6cd5\u9700\u8981\u904d\u5386\u89e3\u7a7a\u95f4\u7684\u6240\u6709\u53ef\u80fd\u89e3\uff0c\u6240\u9700\u65f6\u95f4\u5f88\u957f\u3002\u4f8b\u5982\uff0c\u6c42\u89e3 \\(n\\) \u7687\u540e\u95ee\u9898\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u8fbe\u5230 \\(O(n!)\\) \u3002
    • \u5728\u6bcf\u4e00\u6b21\u9012\u5f52\u8c03\u7528\u65f6\uff0c\u90fd\u9700\u8981\u4fdd\u5b58\u5f53\u524d\u7684\u72b6\u6001\uff08\u4f8b\u5982\u9009\u62e9\u8def\u5f84\u3001\u7528\u4e8e\u526a\u679d\u7684\u8f85\u52a9\u53d8\u91cf\u7b49\uff09\uff0c\u5bf9\u4e8e\u6df1\u5ea6\u5f88\u5927\u7684\u9012\u5f52\uff0c\u7a7a\u95f4\u9700\u6c42\u53ef\u80fd\u4f1a\u53d8\u5f97\u975e\u5e38\u5927\u3002

    \u5373\u4fbf\u5982\u6b64\uff0c\u56de\u6eaf\u7b97\u6cd5\u4ecd\u7136\u662f\u67d0\u4e9b\u641c\u7d22\u95ee\u9898\u548c\u7ea6\u675f\u6ee1\u8db3\u95ee\u9898\u7684\u6700\u4f73\u89e3\u51b3\u65b9\u6848\u3002\u5bf9\u4e8e\u8fd9\u4e9b\u95ee\u9898\uff0c\u7531\u4e8e\u65e0\u6cd5\u9884\u6d4b\u54ea\u4e9b\u9009\u62e9\u53ef\u751f\u6210\u6709\u6548\u7684\u89e3\uff0c\u56e0\u6b64\u6211\u4eec\u5fc5\u987b\u5bf9\u6240\u6709\u53ef\u80fd\u7684\u9009\u62e9\u8fdb\u884c\u904d\u5386\u3002\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u5173\u952e\u662f\u5982\u4f55\u8fdb\u884c\u6548\u7387\u4f18\u5316\uff1a

    • \u4e0a\u6587\u4ecb\u7ecd\u8fc7\u7684\u526a\u679d\u662f\u4e00\u79cd\u5e38\u7528\u7684\u4f18\u5316\u65b9\u6cd5\u3002\u5b83\u53ef\u4ee5\u907f\u514d\u641c\u7d22\u90a3\u4e9b\u80af\u5b9a\u4e0d\u4f1a\u4ea7\u751f\u6709\u6548\u89e3\u7684\u8def\u5f84\uff0c\u4ece\u800c\u8282\u7701\u65f6\u95f4\u548c\u7a7a\u95f4\u3002
    • \u53e6\u4e00\u4e2a\u5e38\u7528\u7684\u4f18\u5316\u65b9\u6cd5\u662f\u52a0\u5165\u300c\u542f\u53d1\u5f0f\u641c\u7d22 Heuristic Search\u300d\u7b56\u7565\uff0c\u5b83\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u5f15\u5165\u4e00\u4e9b\u7b56\u7565\u6216\u8005\u4f30\u8ba1\u503c\uff0c\u4ece\u800c\u4f18\u5148\u641c\u7d22\u6700\u6709\u53ef\u80fd\u4ea7\u751f\u6709\u6548\u89e3\u7684\u8def\u5f84\u3002
    "},{"location":"chapter_backtracking/backtracking_algorithm/#1216","title":"12.1.6. \u00a0 \u5178\u578b\u4f8b\u9898","text":"

    \u641c\u7d22\u95ee\u9898\uff1a\u8fd9\u7c7b\u95ee\u9898\u7684\u76ee\u6807\u662f\u627e\u5230\u6ee1\u8db3\u7279\u5b9a\u6761\u4ef6\u7684\u89e3\u51b3\u65b9\u6848\u3002

    • \u5168\u6392\u5217\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u4e2a\u96c6\u5408\uff0c\u6c42\u51fa\u5176\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u7ec4\u5408\u3002
    • \u5b50\u96c6\u548c\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u4e2a\u96c6\u5408\u548c\u4e00\u4e2a\u76ee\u6807\u548c\uff0c\u627e\u5230\u96c6\u5408\u4e2d\u6240\u6709\u548c\u4e3a\u76ee\u6807\u548c\u7684\u5b50\u96c6\u3002
    • \u6c49\u8bfa\u5854\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e09\u4e2a\u67f1\u5b50\u548c\u4e00\u7cfb\u5217\u5927\u5c0f\u4e0d\u540c\u7684\u5706\u76d8\uff0c\u8981\u6c42\u5c06\u6240\u6709\u5706\u76d8\u4ece\u4e00\u4e2a\u67f1\u5b50\u79fb\u52a8\u5230\u53e6\u4e00\u4e2a\u67f1\u5b50\uff0c\u6bcf\u6b21\u53ea\u80fd\u79fb\u52a8\u4e00\u4e2a\u5706\u76d8\uff0c\u4e14\u4e0d\u80fd\u5c06\u5927\u5706\u76d8\u653e\u5728\u5c0f\u5706\u76d8\u4e0a\u3002

    \u7ea6\u675f\u6ee1\u8db3\u95ee\u9898\uff1a\u8fd9\u7c7b\u95ee\u9898\u7684\u76ee\u6807\u662f\u627e\u5230\u6ee1\u8db3\u6240\u6709\u7ea6\u675f\u6761\u4ef6\u7684\u89e3\u3002

    • \\(n\\) \u7687\u540e\uff1a\u5728 \\(n \\times n\\) \u7684\u68cb\u76d8\u4e0a\u653e\u7f6e \\(n\\) \u4e2a\u7687\u540e\uff0c\u4f7f\u5f97\u5b83\u4eec\u4e92\u4e0d\u653b\u51fb\u3002
    • \u6570\u72ec\uff1a\u5728 \\(9 \\times 9\\) \u7684\u7f51\u683c\u4e2d\u586b\u5165\u6570\u5b57 \\(1\\) ~ \\(9\\) \uff0c\u4f7f\u5f97\u6bcf\u884c\u3001\u6bcf\u5217\u548c\u6bcf\u4e2a \\(3 \\times 3\\) \u5b50\u7f51\u683c\u4e2d\u7684\u6570\u5b57\u4e0d\u91cd\u590d\u3002
    • \u56fe\u7740\u8272\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u4e2a\u65e0\u5411\u56fe\uff0c\u7528\u6700\u5c11\u7684\u989c\u8272\u7ed9\u56fe\u7684\u6bcf\u4e2a\u9876\u70b9\u7740\u8272\uff0c\u4f7f\u5f97\u76f8\u90bb\u9876\u70b9\u989c\u8272\u4e0d\u540c\u3002

    \u7ec4\u5408\u4f18\u5316\u95ee\u9898\uff1a\u8fd9\u7c7b\u95ee\u9898\u7684\u76ee\u6807\u662f\u5728\u4e00\u4e2a\u7ec4\u5408\u7a7a\u95f4\u4e2d\u627e\u5230\u6ee1\u8db3\u67d0\u4e9b\u6761\u4ef6\u7684\u6700\u4f18\u89e3\u3002

    • 0-1 \u80cc\u5305\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u7ec4\u7269\u54c1\u548c\u4e00\u4e2a\u80cc\u5305\uff0c\u6bcf\u4e2a\u7269\u54c1\u6709\u4e00\u5b9a\u7684\u4ef7\u503c\u548c\u91cd\u91cf\uff0c\u8981\u6c42\u5728\u80cc\u5305\u5bb9\u91cf\u9650\u5236\u5185\uff0c\u9009\u62e9\u7269\u54c1\u4f7f\u5f97\u603b\u4ef7\u503c\u6700\u5927\u3002
    • \u65c5\u884c\u5546\u95ee\u9898\uff1a\u5728\u4e00\u4e2a\u56fe\u4e2d\uff0c\u4ece\u4e00\u4e2a\u70b9\u51fa\u53d1\uff0c\u8bbf\u95ee\u6240\u6709\u5176\u4ed6\u70b9\u6070\u597d\u4e00\u6b21\u540e\u8fd4\u56de\u8d77\u70b9\uff0c\u6c42\u6700\u77ed\u8def\u5f84\u3002
    • \u6700\u5927\u56e2\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u4e2a\u65e0\u5411\u56fe\uff0c\u627e\u5230\u6700\u5927\u7684\u5b8c\u5168\u5b50\u56fe\uff0c\u5373\u5b50\u56fe\u4e2d\u7684\u4efb\u610f\u4e24\u4e2a\u9876\u70b9\u4e4b\u95f4\u90fd\u6709\u8fb9\u76f8\u8fde\u3002

    \u8bf7\u6ce8\u610f\uff0c\u56de\u6eaf\u7b97\u6cd5\u901a\u5e38\u4e0d\u662f\u89e3\u51b3\u7ec4\u5408\u4f18\u5316\u95ee\u9898\u7684\u6700\u4f18\u65b9\u6cd5\u30020-1 \u80cc\u5305\u95ee\u9898\u901a\u5e38\u4f7f\u7528\u52a8\u6001\u89c4\u5212\u89e3\u51b3\uff1b\u65c5\u884c\u5546\u662f\u4e00\u4e2a NP-Hard \u95ee\u9898\uff0c\u5e38\u7528\u89e3\u51b3\u65b9\u6cd5\u6709\u9057\u4f20\u7b97\u6cd5\u548c\u8681\u7fa4\u7b97\u6cd5\u7b49\uff1b\u6700\u5927\u56e2\u95ee\u9898\u662f\u56fe\u8f6e\u4e2d\u7684\u4e00\u4e2a\u7ecf\u5178 NP-Hard \u95ee\u9898\uff0c\u901a\u5e38\u7528\u8d2a\u5fc3\u7b97\u6cd5\u7b49\u542f\u53d1\u5f0f\u7b97\u6cd5\u6765\u89e3\u51b3\u3002

    "},{"location":"chapter_backtracking/n_queens_problem/","title":"12.4. \u00a0 N \u7687\u540e\u95ee\u9898","text":"

    Question

    \u6839\u636e\u56fd\u9645\u8c61\u68cb\u7684\u89c4\u5219\uff0c\u7687\u540e\u53ef\u4ee5\u653b\u51fb\u4e0e\u4e4b\u5904\u5728\u540c\u4e00\u884c\u6216\u540c\u4e00\u5217\u6216\u540c\u4e00\u659c\u7ebf\u4e0a\u7684\u68cb\u5b50\u3002\u7ed9\u5b9a \\(n\\) \u4e2a\u7687\u540e\u548c\u4e00\u4e2a \\(n \\times n\\) \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5bfb\u627e\u4f7f\u5f97\u6240\u6709\u7687\u540e\u4e4b\u95f4\u65e0\u6cd5\u76f8\u4e92\u653b\u51fb\u7684\u6446\u653e\u65b9\u6848\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5f53 \\(n = 4\\) \u65f6\uff0c\u5171\u53ef\u4ee5\u627e\u5230\u4e24\u4e2a\u89e3\u3002\u4ece\u56de\u6eaf\u7b97\u6cd5\u7684\u89d2\u5ea6\u770b\uff0c\\(n \\times n\\) \u5927\u5c0f\u7684\u68cb\u76d8\u5171\u6709 \\(n^2\\) \u4e2a\u683c\u5b50\uff0c\u7ed9\u51fa\u4e86\u6240\u6709\u7684\u9009\u62e9 choices \u3002\u5728\u9010\u4e2a\u653e\u7f6e\u7687\u540e\u7684\u8fc7\u7a0b\u4e2d\uff0c\u68cb\u76d8\u72b6\u6001\u5728\u4e0d\u65ad\u5730\u53d8\u5316\uff0c\u6bcf\u4e2a\u65f6\u523b\u7684\u68cb\u76d8\u5c31\u662f\u72b6\u6001 state \u3002

    Fig. 4 \u7687\u540e\u95ee\u9898\u7684\u89e3

    \u672c\u9898\u5171\u6709\u4e09\u4e2a\u7ea6\u675f\u6761\u4ef6\uff1a\u591a\u4e2a\u7687\u540e\u4e0d\u80fd\u5728\u540c\u4e00\u884c\u3001\u540c\u4e00\u5217\u548c\u540c\u4e00\u5bf9\u89d2\u7ebf\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u5bf9\u89d2\u7ebf\u5206\u4e3a\u4e3b\u5bf9\u89d2\u7ebf \\ \u548c\u526f\u5bf9\u89d2\u7ebf / \u4e24\u79cd\u3002

    Fig. n \u7687\u540e\u95ee\u9898\u7684\u7ea6\u675f\u6761\u4ef6

    \u7687\u540e\u7684\u6570\u91cf\u548c\u68cb\u76d8\u7684\u884c\u6570\u90fd\u4e3a \\(n\\) \uff0c\u56e0\u6b64\u6211\u4eec\u5bb9\u6613\u5f97\u5230\u7b2c\u4e00\u4e2a\u63a8\u8bba\uff1a\u68cb\u76d8\u6bcf\u884c\u90fd\u5141\u8bb8\u4e14\u53ea\u5141\u8bb8\u653e\u7f6e\u4e00\u4e2a\u7687\u540e\u3002\u8fd9\u610f\u5473\u7740\uff0c\u6211\u4eec\u53ef\u4ee5\u91c7\u53d6\u9010\u884c\u653e\u7f6e\u7b56\u7565\uff1a\u4ece\u7b2c\u4e00\u884c\u5f00\u59cb\uff0c\u5728\u6bcf\u884c\u653e\u7f6e\u4e00\u4e2a\u7687\u540e\uff0c\u76f4\u81f3\u6700\u540e\u4e00\u884c\u7ed3\u675f\u3002\u6b64\u7b56\u7565\u8d77\u5230\u4e86\u526a\u679d\u7684\u4f5c\u7528\uff0c\u5b83\u907f\u514d\u4e86\u540c\u4e00\u884c\u51fa\u73b0\u591a\u4e2a\u7687\u540e\u7684\u6240\u6709\u641c\u7d22\u5206\u652f\u3002

    \u4e0b\u56fe\u5c55\u793a\u4e86 \\(4\\) \u7687\u540e\u95ee\u9898\u7684\u9010\u884c\u653e\u7f6e\u8fc7\u7a0b\u3002\u53d7\u7bc7\u5e45\u9650\u5236\uff0c\u4e0b\u56fe\u4ec5\u5c55\u5f00\u4e86\u7b2c\u4e00\u884c\u7684\u4e00\u4e2a\u641c\u7d22\u5206\u652f\u3002\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u6211\u4eec\u5c06\u4e0d\u6ee1\u8db3\u5217\u7ea6\u675f\u548c\u5bf9\u89d2\u7ebf\u7ea6\u675f\u7684\u65b9\u6848\u90fd\u526a\u679d\u4e86\u3002

    Fig. \u9010\u884c\u653e\u7f6e\u7b56\u7565

    \u4e3a\u4e86\u5b9e\u73b0\u6839\u636e\u5217\u7ea6\u675f\u526a\u679d\uff0c\u6211\u4eec\u53ef\u4ee5\u5229\u7528\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u5e03\u5c14\u578b\u6570\u7ec4 cols \u8bb0\u5f55\u6bcf\u4e00\u5217\u662f\u5426\u6709\u7687\u540e\u3002\u5728\u6bcf\u6b21\u51b3\u5b9a\u653e\u7f6e\u524d\uff0c\u6211\u4eec\u901a\u8fc7 cols \u5c06\u5df2\u6709\u7687\u540e\u7684\u5217\u526a\u679d\uff0c\u5e76\u5728\u56de\u6eaf\u4e2d\u52a8\u6001\u66f4\u65b0 cols \u7684\u72b6\u6001\u3002

    \u90a3\u4e48\uff0c\u5982\u4f55\u5904\u7406\u5bf9\u89d2\u7ebf\u7ea6\u675f\u5462\uff1f\u8bbe\u68cb\u76d8\u4e2d\u67d0\u4e2a\u683c\u5b50\u7684\u884c\u5217\u7d22\u5f15\u4e3a (row, col) \uff0c\u89c2\u5bdf\u77e9\u9635\u7684\u67d0\u6761\u4e3b\u5bf9\u89d2\u7ebf\uff0c\u6211\u4eec\u53d1\u73b0\u8be5\u5bf9\u89d2\u7ebf\u4e0a\u6240\u6709\u683c\u5b50\u7684\u884c\u7d22\u5f15\u51cf\u5217\u7d22\u5f15\u76f8\u7b49\uff0c\u5373 row - col \u4e3a\u6052\u5b9a\u503c\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u82e5\u4e24\u4e2a\u683c\u5b50\u6ee1\u8db3 row1 - col1 == row2 - col2 \uff0c\u5219\u8fd9\u4e24\u4e2a\u683c\u5b50\u4e00\u5b9a\u5904\u5728\u4e00\u6761\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u3002

    \u5229\u7528\u8be5\u6027\u8d28\uff0c\u6211\u4eec\u53ef\u4ee5\u501f\u52a9\u4e00\u4e2a\u6570\u7ec4 diag1 \u6765\u8bb0\u5f55\u6bcf\u6761\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\u3002\u6ce8\u610f\uff0c\\(n\\) \u7ef4\u65b9\u9635 row - col \u7684\u8303\u56f4\u662f \\([-n + 1, n - 1]\\) \uff0c\u56e0\u6b64\u5171\u6709 \\(2n - 1\\) \u6761\u4e3b\u5bf9\u89d2\u7ebf\u3002

    Fig. \u5904\u7406\u5217\u7ea6\u675f\u548c\u5bf9\u89d2\u7ebf\u7ea6\u675f

    \u540c\u7406\uff0c\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u7684\u6240\u6709\u683c\u5b50\u7684 row + col \u662f\u6052\u5b9a\u503c\u3002\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u540c\u6837\u7684\u65b9\u6cd5\uff0c\u501f\u52a9\u6570\u7ec4 diag2 \u6765\u5904\u7406\u6b21\u5bf9\u89d2\u7ebf\u7ea6\u675f\u3002

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u6211\u4eec\u4fbf\u53ef\u4ee5\u5199\u51fa \\(n\\) \u7687\u540e\u7684\u89e3\u9898\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart n_queens.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nvoid backtrack(int row, int n, List<List<String>> state, List<List<List<String>>> res,\nboolean[] cols, boolean[] diags1, boolean[] diags2) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (row == n) {\nList<List<String>> copyState = new ArrayList<>();\nfor (List<String> sRow : state) {\ncopyState.add(new ArrayList<>(sRow));\n}\nres.add(copyState);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor (int col = 0; col < n; col++) {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nint diag1 = row - col + n - 1;\nint diag2 = row + col;\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate.get(row).set(col, \"Q\");\ncols[col] = diags1[diag1] = diags2[diag2] = true;\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2);\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate.get(row).set(col, \"#\");\ncols[col] = diags1[diag1] = diags2[diag2] = false;\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nList<List<List<String>>> nQueens(int n) {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nList<List<String>> state = new ArrayList<>();\nfor (int i = 0; i < n; i++) {\nList<String> row = new ArrayList<>();\nfor (int j = 0; j < n; j++) {\nrow.add(\"#\");\n}\nstate.add(row);\n}\nboolean[] cols = new boolean[n]; // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nboolean[] diags1 = new boolean[2 * n - 1]; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nboolean[] diags2 = new boolean[2 * n - 1]; // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nList<List<List<String>>> res = new ArrayList<>();\nbacktrack(0, n, state, res, cols, diags1, diags2);\nreturn res;\n}\n
    n_queens.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nvoid backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,\nvector<bool> &diags1, vector<bool> &diags2) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (row == n) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor (int col = 0; col < n; col++) {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nint diag1 = row - col + n - 1;\nint diag2 = row + col;\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = \"Q\";\ncols[col] = diags1[diag1] = diags2[diag2] = true;\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2);\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = \"#\";\ncols[col] = diags1[diag1] = diags2[diag2] = false;\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nvector<vector<vector<string>>> nQueens(int n) {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nvector<vector<string>> state(n, vector<string>(n, \"#\"));\nvector<bool> cols(n, false);           // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nvector<bool> diags1(2 * n - 1, false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nvector<bool> diags2(2 * n - 1, false); // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nvector<vector<vector<string>>> res;\nbacktrack(0, n, state, res, cols, diags1, diags2);\nreturn res;\n}\n
    n_queens.py
    def backtrack(\nrow: int,\nn: int,\nstate: list[list[str]],\nres: list[list[list[str]]],\ncols: list[bool],\ndiags1: list[bool],\ndiags2: list[bool],\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e\"\"\"\n# \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif row == n:\nres.append([list(row) for row in state])\nreturn\n# \u904d\u5386\u6240\u6709\u5217\nfor col in range(n):\n# \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\ndiag1 = row - col + n - 1\ndiag2 = row + col\n# \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif not cols[col] and not diags1[diag1] and not diags2[diag2]:\n# \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = \"Q\"\ncols[col] = diags1[diag1] = diags2[diag2] = True\n# \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2)\n# \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = \"#\"\ncols[col] = diags1[diag1] = diags2[diag2] = False\ndef n_queens(n: int) -> list[list[list[str]]]:\n\"\"\"\u6c42\u89e3 N \u7687\u540e\"\"\"\n# \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nstate = [[\"#\" for _ in range(n)] for _ in range(n)]\ncols = [False] * n  # \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\ndiags1 = [False] * (2 * n - 1)  # \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\ndiags2 = [False] * (2 * n - 1)  # \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nres = []\nbacktrack(0, n, state, res, cols, diags1, diags2)\nreturn res\n
    n_queens.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif row == n {\nnewState := make([][]string, len(*state))\nfor i, _ := range newState {\nnewState[i] = make([]string, len((*state)[0]))\ncopy(newState[i], (*state)[i])\n}\n*res = append(*res, newState)\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor col := 0; col < n; col++ {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\ndiag1 := row - col + n - 1\ndiag2 := row + col\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\n(*state)[row][col] = \"Q\"\n(*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row+1, n, state, res, cols, diags1, diags2)\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\n(*state)[row][col] = \"#\"\n(*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n}\n}\n}\n/* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nfunc backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif row == n {\nnewState := make([][]string, len(*state))\nfor i, _ := range newState {\nnewState[i] = make([]string, len((*state)[0]))\ncopy(newState[i], (*state)[i])\n}\n*res = append(*res, newState)\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor col := 0; col < n; col++ {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\ndiag1 := row - col + n - 1\ndiag2 := row + col\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\n(*state)[row][col] = \"Q\"\n(*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row+1, n, state, res, cols, diags1, diags2)\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\n(*state)[row][col] = \"#\"\n(*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false\n}\n}\n}\nfunc nQueens(n int) [][][]string {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nstate := make([][]string, n)\nfor i := 0; i < n; i++ {\nrow := make([]string, n)\nfor i := 0; i < n; i++ {\nrow[i] = \"#\"\n}\nstate[i] = row\n}\n// \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\ncols := make([]bool, n)\ndiags1 := make([]bool, 2*n-1)\ndiags2 := make([]bool, 2*n-1)\nres := make([][][]string, 0)\nbacktrack(0, n, &state, &res, &cols, &diags1, &diags2)\nreturn res\n}\n
    n_queens.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nfunction backtrack(row, n, state, res, cols, diags1, diags2) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (row === n) {\nres.push(state.map((row) => row.slice()));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor (let col = 0; col < n; col++) {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nconst diag1 = row - col + n - 1;\nconst diag2 = row + col;\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = 'Q';\ncols[col] = diags1[diag1] = diags2[diag2] = true;\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2);\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = '#';\ncols[col] = diags1[diag1] = diags2[diag2] = false;\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nfunction nQueens(n) {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nconst state = Array.from({ length: n }, () => Array(n).fill('#'));\nconst cols = Array(n).fill(false); // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nconst diags1 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nconst diags2 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nconst res = [];\nbacktrack(0, n, state, res, cols, diags1, diags2);\nreturn res;\n}\n
    n_queens.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nfunction backtrack(\nrow: number,\nn: number,\nstate: string[][],\nres: string[][][],\ncols: boolean[],\ndiags1: boolean[],\ndiags2: boolean[]\n): void {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (row === n) {\nres.push(state.map((row) => row.slice()));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor (let col = 0; col < n; col++) {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nconst diag1 = row - col + n - 1;\nconst diag2 = row + col;\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = 'Q';\ncols[col] = diags1[diag1] = diags2[diag2] = true;\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2);\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = '#';\ncols[col] = diags1[diag1] = diags2[diag2] = false;\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nfunction nQueens(n: number): string[][][] {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nconst state = Array.from({ length: n }, () => Array(n).fill('#'));\nconst cols = Array(n).fill(false); // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nconst diags1 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nconst diags2 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nconst res: string[][][] = [];\nbacktrack(0, n, state, res, cols, diags1, diags2);\nreturn res;\n}\n
    n_queens.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{nQueens}\n
    n_queens.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nvoid backtrack(int row, int n, List<List<string>> state, List<List<List<string>>> res,\nbool[] cols, bool[] diags1, bool[] diags2) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (row == n) {\nList<List<string>> copyState = new List<List<string>>();\nforeach (List<string> sRow in state) {\ncopyState.Add(new List<string>(sRow));\n}\nres.Add(copyState);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor (int col = 0; col < n; col++) {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nint diag1 = row - col + n - 1;\nint diag2 = row + col;\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = \"Q\";\ncols[col] = diags1[diag1] = diags2[diag2] = true;\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row + 1, n, state, res, cols, diags1, diags2);\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = \"#\";\ncols[col] = diags1[diag1] = diags2[diag2] = false;\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nList<List<List<string>>> nQueens(int n) {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nList<List<string>> state = new List<List<string>>();\nfor (int i = 0; i < n; i++) {\nList<string> row = new List<string>();\nfor (int j = 0; j < n; j++) {\nrow.Add(\"#\");\n}\nstate.Add(row);\n}\nbool[] cols = new bool[n]; // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nbool[] diags1 = new bool[2 * n - 1]; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nbool[] diags2 = new bool[2 * n - 1]; // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nList<List<List<string>>> res = new List<List<List<string>>>();\nbacktrack(0, n, state, res, cols, diags1, diags2);\nreturn res;\n}\n
    n_queens.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1aN \u7687\u540e */\nfunc backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {\n// \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\nif row == n {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u5217\nfor col in 0 ..< n {\n// \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\nlet diag1 = row - col + n - 1\nlet diag2 = row + col\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u526f\u5bf9\u89d2\u7ebf\u5b58\u5728\u7687\u540e\nif !cols[col] && !diags1[diag1] && !diags2[diag2] {\n// \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\nstate[row][col] = \"Q\"\ncols[col] = true\ndiags1[diag1] = true\ndiags2[diag2] = true\n// \u653e\u7f6e\u4e0b\u4e00\u884c\nbacktrack(row: row + 1, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)\n// \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\nstate[row][col] = \"#\"\ncols[col] = false\ndiags1[diag1] = false\ndiags2[diag2] = false\n}\n}\n}\n/* \u6c42\u89e3 N \u7687\u540e */\nfunc nQueens(n: Int) -> [[[String]]] {\n// \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\nvar state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\nvar cols = Array(repeating: false, count: n) // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\nvar diags1 = Array(repeating: false, count: 2 * n - 1) // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nvar diags2 = Array(repeating: false, count: 2 * n - 1) // \u8bb0\u5f55\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u6709\u7687\u540e\nvar res: [[[String]]] = []\nbacktrack(row: 0, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)\nreturn res\n}\n
    n_queens.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{nQueens}\n
    n_queens.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{nQueens}\n
    "},{"location":"chapter_backtracking/n_queens_problem/#1241","title":"12.4.1. \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"

    \u9010\u884c\u653e\u7f6e \\(n\\) \u6b21\uff0c\u8003\u8651\u5217\u7ea6\u675f\uff0c\u5219\u4ece\u7b2c\u4e00\u884c\u5230\u6700\u540e\u4e00\u884c\u5206\u522b\u6709 \\(n, n-1, \\cdots, 2, 1\\) \u4e2a\u9009\u62e9\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n!)\\) \u3002\u5b9e\u9645\u4e0a\uff0c\u6839\u636e\u5bf9\u89d2\u7ebf\u7ea6\u675f\u7684\u526a\u679d\u4e5f\u80fd\u591f\u5927\u5e45\u5730\u7f29\u5c0f\u641c\u7d22\u7a7a\u95f4\uff0c\u56e0\u800c\u641c\u7d22\u6548\u7387\u5f80\u5f80\u4f18\u4e8e\u4ee5\u4e0a\u65f6\u95f4\u590d\u6742\u5ea6\u3002

    state \u4f7f\u7528 \\(O(n^2)\\) \u7a7a\u95f4\uff0ccols , diags1 , diags2 \u7686\u4f7f\u7528 \\(O(n)\\) \u7a7a\u95f4\u3002\u6700\u5927\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \uff0c\u4f7f\u7528 \\(O(n)\\) \u6808\u5e27\u7a7a\u95f4\u3002\u56e0\u6b64\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    "},{"location":"chapter_backtracking/permutations_problem/","title":"12.2. \u00a0 \u5168\u6392\u5217\u95ee\u9898","text":"

    \u5168\u6392\u5217\u95ee\u9898\u662f\u56de\u6eaf\u7b97\u6cd5\u7684\u4e00\u4e2a\u5178\u578b\u5e94\u7528\u3002\u5b83\u7684\u5b9a\u4e49\u662f\u5728\u7ed9\u5b9a\u4e00\u4e2a\u96c6\u5408\uff08\u5982\u4e00\u4e2a\u6570\u7ec4\u6216\u5b57\u7b26\u4e32\uff09\u7684\u60c5\u51b5\u4e0b\uff0c\u627e\u51fa\u8fd9\u4e2a\u96c6\u5408\u4e2d\u5143\u7d20\u7684\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u3002

    \u4e0b\u8868\u5217\u4e3e\u4e86\u51e0\u4e2a\u793a\u4f8b\u6570\u636e\uff0c\u5305\u62ec\u8f93\u5165\u6570\u7ec4\u548c\u5bf9\u5e94\u7684\u6240\u6709\u6392\u5217\u3002

    \u8f93\u5165\u6570\u7ec4 \u6240\u6709\u6392\u5217 \\([1]\\) \\([1]\\) \\([1, 2]\\) \\([1, 2], [2, 1]\\) \\([1, 2, 3]\\) \\([1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]\\)"},{"location":"chapter_backtracking/permutations_problem/#1221","title":"12.2.1. \u00a0 \u65e0\u91cd\u590d\u7684\u60c5\u51b5","text":"

    Question

    \u8f93\u5165\u4e00\u4e2a\u6574\u6570\u6570\u7ec4\uff0c\u6570\u7ec4\u4e2d\u4e0d\u5305\u542b\u91cd\u590d\u5143\u7d20\uff0c\u8fd4\u56de\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u3002

    \u4ece\u56de\u6eaf\u7b97\u6cd5\u7684\u89d2\u5ea6\u770b\uff0c\u6211\u4eec\u53ef\u4ee5\u628a\u751f\u6210\u6392\u5217\u7684\u8fc7\u7a0b\u60f3\u8c61\u6210\u4e00\u7cfb\u5217\u9009\u62e9\u7684\u7ed3\u679c\u3002\u5047\u8bbe\u8f93\u5165\u6570\u7ec4\u4e3a \\([1, 2, 3]\\) \uff0c\u5982\u679c\u6211\u4eec\u5148\u9009\u62e9 \\(1\\) \u3001\u518d\u9009\u62e9 \\(3\\) \u3001\u6700\u540e\u9009\u62e9 \\(2\\) \uff0c\u5219\u83b7\u5f97\u6392\u5217 \\([1, 3, 2]\\) \u3002\u56de\u9000\u8868\u793a\u64a4\u9500\u4e00\u4e2a\u9009\u62e9\uff0c\u4e4b\u540e\u7ee7\u7eed\u5c1d\u8bd5\u5176\u4ed6\u9009\u62e9\u3002

    \u4ece\u56de\u6eaf\u7b97\u6cd5\u4ee3\u7801\u7684\u89d2\u5ea6\u770b\uff0c\u5019\u9009\u96c6\u5408 choices \u662f\u8f93\u5165\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\uff0c\u72b6\u6001 state \u662f\u76f4\u81f3\u76ee\u524d\u5df2\u88ab\u9009\u62e9\u7684\u5143\u7d20\u3002\u6ce8\u610f\uff0c\u6bcf\u4e2a\u5143\u7d20\u53ea\u5141\u8bb8\u88ab\u9009\u62e9\u4e00\u6b21\uff0c\u56e0\u6b64\u5728\u904d\u5386\u9009\u62e9\u65f6\uff0c\u5e94\u5f53\u6392\u9664\u5df2\u7ecf\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u641c\u7d22\u8fc7\u7a0b\u5c55\u5f00\u6210\u4e00\u4e2a\u9012\u5f52\u6811\uff0c\u6811\u4e2d\u7684\u6bcf\u4e2a\u8282\u70b9\u4ee3\u8868\u5f53\u524d\u72b6\u6001 state \u3002\u4ece\u6839\u8282\u70b9\u5f00\u59cb\uff0c\u7ecf\u8fc7\u4e09\u8f6e\u9009\u62e9\u540e\u5230\u8fbe\u53f6\u8282\u70b9\uff0c\u6bcf\u4e2a\u53f6\u8282\u70b9\u90fd\u5bf9\u5e94\u4e00\u4e2a\u6392\u5217\u3002

    Fig. \u5168\u6392\u5217\u7684\u9012\u5f52\u6811

    \u60f3\u6e05\u695a\u4ee5\u4e0a\u4fe1\u606f\u4e4b\u540e\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5728\u6846\u67b6\u4ee3\u7801\u4e2d\u505a\u201c\u5b8c\u5f62\u586b\u7a7a\u201d\u4e86\u3002\u4e3a\u4e86\u7f29\u77ed\u4ee3\u7801\u884c\u6570\uff0c\u6211\u4eec\u4e0d\u5355\u72ec\u5b9e\u73b0\u6846\u67b6\u4ee3\u7801\u4e2d\u7684\u5404\u4e2a\u51fd\u6570\uff0c\u800c\u662f\u5c06\u4ed6\u4eec\u5c55\u5f00\u5728 backtrack() \u51fd\u6570\u4e2d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart permutations_i.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nvoid backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.size() == choices.length) {\nres.add(new ArrayList<Integer>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < choices.length; i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i]) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true;\nstate.add(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.remove(state.size() - 1);\n}\n}\n}\n/* \u5168\u6392\u5217 I */\nList<List<Integer>> permutationsI(int[] nums) {\nList<List<Integer>> res = new ArrayList<List<Integer>>();\nbacktrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);\nreturn res;\n}\n
    permutations_i.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nvoid backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.size() == choices.size()) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < choices.size(); i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i]) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true;\nstate.push_back(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop_back();\n}\n}\n}\n/* \u5168\u6392\u5217 I */\nvector<vector<int>> permutationsI(vector<int> nums) {\nvector<int> state;\nvector<bool> selected(nums.size(), false);\nvector<vector<int>> res;\nbacktrack(state, nums, selected, res);\nreturn res;\n}\n
    permutations_i.py
    def backtrack(\nstate: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I\"\"\"\n# \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif len(state) == len(choices):\nres.append(list(state))\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nfor i, choice in enumerate(choices):\n# \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\nif not selected[i]:\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = True\nstate.append(choice)\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = False\nstate.pop()\ndef permutations_i(nums: list[int]) -> list[list[int]]:\n\"\"\"\u5168\u6392\u5217 I\"\"\"\nres = []\nbacktrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\nreturn res\n
    permutations_i.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfunc backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif len(*state) == len(*choices) {\nnewState := append([]int{}, *state...)\n*res = append(*res, newState)\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor i := 0; i < len(*choices); i++ {\nchoice := (*choices)[i]\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif !(*selected)[i] {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n(*selected)[i] = true\n*state = append(*state, choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrackI(state, choices, selected, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n(*selected)[i] = false\n*state = (*state)[:len(*state)-1]\n}\n}\n}\n/* \u5168\u6392\u5217 I */\nfunc permutationsI(nums []int) [][]int {\nres := make([][]int, 0)\nstate := make([]int, 0)\nselected := make([]bool, len(nums))\nbacktrackI(&state, &nums, &selected, &res)\nreturn res\n}\n
    permutations_i.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfunction backtrack(state, choices, selected, res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.length === choices.length) {\nres.push([...state]);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nchoices.forEach((choice, i) => {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i]) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true;\nstate.push(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop();\n}\n});\n}\n/* \u5168\u6392\u5217 I */\nfunction permutationsI(nums) {\nconst res = [];\nbacktrack([], nums, Array(nums.length).fill(false), res);\nreturn res;\n}\n
    permutations_i.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfunction backtrack(\nstate: number[],\nchoices: number[],\nselected: boolean[],\nres: number[][]\n): void {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.length === choices.length) {\nres.push([...state]);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nchoices.forEach((choice, i) => {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i]) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true;\nstate.push(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop();\n}\n});\n}\n/* \u5168\u6392\u5217 I */\nfunction permutationsI(nums: number[]): number[][] {\nconst res: number[][] = [];\nbacktrack([], nums, Array(nums.length).fill(false), res);\nreturn res;\n}\n
    permutations_i.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsI}\n
    permutations_i.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nvoid backtrack(List<int> state, int[] choices, bool[] selected, List<List<int>> res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.Count == choices.Length) {\nres.Add(new List<int>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < choices.Length; i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i]) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true;\nstate.Add(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.RemoveAt(state.Count - 1);\n}\n}\n}\n/* \u5168\u6392\u5217 I */\nList<List<int>> permutationsI(int[] nums) {\nList<List<int>> res = new List<List<int>>();\nbacktrack(new List<int>(), nums, new bool[nums.Length], res);\nreturn res;\n}\n
    permutations_i.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif state.count == choices.count {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (i, choice) in choices.enumerated() {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif !selected[i] {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nselected[i] = true\nstate.append(choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, choices: choices, selected: &selected, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false\nstate.removeLast()\n}\n}\n}\n/* \u5168\u6392\u5217 I */\nfunc permutationsI(nums: [Int]) -> [[Int]] {\nvar state: [Int] = []\nvar selected = Array(repeating: false, count: nums.count)\nvar res: [[Int]] = []\nbacktrack(state: &state, choices: nums, selected: &selected, res: &res)\nreturn res\n}\n
    permutations_i.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsI}\n
    permutations_i.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsI}\n

    \u9700\u8981\u91cd\u70b9\u5173\u6ce8\u7684\u662f\uff0c\u6211\u4eec\u5f15\u5165\u4e86\u4e00\u4e2a\u5e03\u5c14\u578b\u6570\u7ec4 selected \uff0c\u5b83\u7684\u957f\u5ea6\u4e0e\u8f93\u5165\u6570\u7ec4\u957f\u5ea6\u76f8\u7b49\uff0c\u5176\u4e2d selected[i] \u8868\u793a choices[i] \u662f\u5426\u5df2\u88ab\u9009\u62e9\u3002\u6211\u4eec\u5229\u7528 selected \u907f\u514d\u67d0\u4e2a\u5143\u7d20\u88ab\u91cd\u590d\u9009\u62e9\uff0c\u4ece\u800c\u5b9e\u73b0\u526a\u679d\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5047\u8bbe\u6211\u4eec\u7b2c\u4e00\u8f6e\u9009\u62e9 1 \uff0c\u7b2c\u4e8c\u8f6e\u9009\u62e9 3 \uff0c\u7b2c\u4e09\u8f6e\u9009\u62e9 2 \uff0c\u5219\u9700\u8981\u5728\u7b2c\u4e8c\u8f6e\u526a\u6389\u5143\u7d20 1 \u7684\u5206\u652f\uff0c\u5728\u7b2c\u4e09\u8f6e\u526a\u6389\u5143\u7d20 1, 3 \u7684\u5206\u652f\u3002\u6b64\u526a\u679d\u64cd\u4f5c\u53ef\u5c06\u641c\u7d22\u7a7a\u95f4\u5927\u5c0f\u4ece \\(O(n^n)\\) \u964d\u4f4e\u81f3 \\(O(n!)\\) \u3002

    Fig. \u5168\u6392\u5217\u526a\u679d\u793a\u4f8b

    "},{"location":"chapter_backtracking/permutations_problem/#1222","title":"12.2.2. \u00a0 \u8003\u8651\u91cd\u590d\u7684\u60c5\u51b5","text":"

    Question

    \u8f93\u5165\u4e00\u4e2a\u6574\u6570\u6570\u7ec4\uff0c\u6570\u7ec4\u4e2d\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\uff0c\u8fd4\u56de\u6240\u6709\u4e0d\u91cd\u590d\u7684\u6392\u5217\u3002

    \u5047\u8bbe\u8f93\u5165\u6570\u7ec4\u4e3a \\([1, 1, 2]\\) \u3002\u4e3a\u4e86\u65b9\u4fbf\u533a\u5206\u4e24\u4e2a\u91cd\u590d\u7684\u5143\u7d20 \\(1\\) \uff0c\u63a5\u4e0b\u6765\u6211\u4eec\u5c06\u7b2c\u4e8c\u4e2a\u5143\u7d20\u8bb0\u4e3a \\(\\hat{1}\\) \u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u4e0a\u8ff0\u65b9\u6cd5\u751f\u6210\u7684\u6392\u5217\u6709\u4e00\u534a\u90fd\u662f\u91cd\u590d\u7684\u3002

    Fig. \u91cd\u590d\u6392\u5217

    \u90a3\u4e48\uff0c\u5982\u4f55\u53bb\u9664\u91cd\u590d\u7684\u6392\u5217\u5462\uff1f\u6700\u76f4\u63a5\u5730\uff0c\u6211\u4eec\u53ef\u4ee5\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868\uff0c\u76f4\u63a5\u5bf9\u6392\u5217\u7ed3\u679c\u8fdb\u884c\u53bb\u91cd\u3002\u7136\u800c\u8fd9\u6837\u505a\u4e0d\u591f\u4f18\u96c5\uff0c\u56e0\u4e3a\u751f\u6210\u91cd\u590d\u6392\u5217\u7684\u641c\u7d22\u5206\u652f\u662f\u6ca1\u6709\u5fc5\u8981\u7684\uff0c\u5e94\u5f53\u88ab\u63d0\u524d\u8bc6\u522b\u5e76\u526a\u679d\uff0c\u8fd9\u6837\u53ef\u4ee5\u8fdb\u4e00\u6b65\u63d0\u5347\u7b97\u6cd5\u6548\u7387\u3002

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u5728\u7b2c\u4e00\u8f6e\u4e2d\uff0c\u9009\u62e9 \\(1\\) \u6216\u9009\u62e9 \\(\\hat{1}\\) \u662f\u7b49\u4ef7\u7684\uff0c\u56e0\u4e3a\u5728\u8fd9\u4e24\u4e2a\u9009\u62e9\u4e4b\u4e0b\u751f\u6210\u7684\u6240\u6709\u6392\u5217\u90fd\u662f\u91cd\u590d\u7684\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u5e94\u8be5\u628a \\(\\hat{1}\\) \u526a\u679d\u6389\u3002\u540c\u7406\uff0c\u5728\u7b2c\u4e00\u8f6e\u9009\u62e9 \\(2\\) \u540e\uff0c\u7b2c\u4e8c\u8f6e\u9009\u62e9\u4e2d\u7684 \\(1\\) \u548c \\(\\hat{1}\\) \u4e5f\u4f1a\u4ea7\u751f\u91cd\u590d\u5206\u652f\uff0c\u56e0\u6b64\u4e5f\u9700\u8981\u5c06\u7b2c\u4e8c\u8f6e\u7684 \\(\\hat{1}\\) \u526a\u679d\u3002

    Fig. \u91cd\u590d\u6392\u5217\u526a\u679d

    \u672c\u8d28\u4e0a\u770b\uff0c\u6211\u4eec\u7684\u76ee\u6807\u662f\u5b9e\u73b0\u5728\u67d0\u4e00\u8f6e\u9009\u62e9\u4e2d\uff0c\u591a\u4e2a\u76f8\u7b49\u7684\u5143\u7d20\u4ec5\u88ab\u9009\u62e9\u4e00\u6b21\u3002\u56e0\u6b64\uff0c\u5728\u4e0a\u4e00\u9898\u7684\u4ee3\u7801\u7684\u57fa\u7840\u4e0a\uff0c\u6211\u4eec\u8003\u8651\u5728\u6bcf\u4e00\u8f6e\u9009\u62e9\u4e2d\u5f00\u542f\u4e00\u4e2a\u54c8\u5e0c\u8868 duplicated \uff0c\u7528\u4e8e\u8bb0\u5f55\u8be5\u8f6e\u4e2d\u5df2\u7ecf\u5c1d\u8bd5\u8fc7\u7684\u5143\u7d20\uff0c\u5e76\u5c06\u91cd\u590d\u5143\u7d20\u526a\u679d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart permutations_ii.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nvoid backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.size() == choices.length) {\nres.add(new ArrayList<Integer>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nSet<Integer> duplicated = new HashSet<Integer>();\nfor (int i = 0; i < choices.length; i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i] && !duplicated.contains(choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true;\nstate.add(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.remove(state.size() - 1);\n}\n}\n}\n/* \u5168\u6392\u5217 II */\nList<List<Integer>> permutationsII(int[] nums) {\nList<List<Integer>> res = new ArrayList<List<Integer>>();\nbacktrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);\nreturn res;\n}\n
    permutations_ii.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nvoid backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.size() == choices.size()) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nunordered_set<int> duplicated;\nfor (int i = 0; i < choices.size(); i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i] && duplicated.find(choice) == duplicated.end()) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.emplace(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true;\nstate.push_back(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop_back();\n}\n}\n}\n/* \u5168\u6392\u5217 II */\nvector<vector<int>> permutationsII(vector<int> nums) {\nvector<int> state;\nvector<bool> selected(nums.size(), false);\nvector<vector<int>> res;\nbacktrack(state, nums, selected, res);\nreturn res;\n}\n
    permutations_ii.py
    def backtrack(\nstate: list[int], choices: list[int], selected: list[bool], res: list[list[int]]\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II\"\"\"\n# \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif len(state) == len(choices):\nres.append(list(state))\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nduplicated = set[int]()\nfor i, choice in enumerate(choices):\n# \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif not selected[i] and choice not in duplicated:\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.add(choice)  # \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = True\nstate.append(choice)\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = False\nstate.pop()\ndef permutations_ii(nums: list[int]) -> list[list[int]]:\n\"\"\"\u5168\u6392\u5217 II\"\"\"\nres = []\nbacktrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\nreturn res\n
    permutations_ii.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfunc backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif len(*state) == len(*choices) {\nnewState := append([]int{}, *state...)\n*res = append(*res, newState)\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nduplicated := make(map[int]struct{}, 0)\nfor i := 0; i < len(*choices); i++ {\nchoice := (*choices)[i]\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif _, ok := duplicated[choice]; !ok && !(*selected)[i] {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n// \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nduplicated[choice] = struct{}{}\n(*selected)[i] = true\n*state = append(*state, choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrackI(state, choices, selected, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n(*selected)[i] = false\n*state = (*state)[:len(*state)-1]\n}\n}\n}\n/* \u5168\u6392\u5217 II */\nfunc permutationsII(nums []int) [][]int {\nres := make([][]int, 0)\nstate := make([]int, 0)\nselected := make([]bool, len(nums))\nbacktrackII(&state, &nums, &selected, &res)\nreturn res\n}\n
    permutations_ii.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfunction backtrack(state, choices, selected, res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.length === choices.length) {\nres.push([...state]);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nconst duplicated = new Set();\nchoices.forEach((choice, i) => {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i] && !duplicated.has(choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true;\nstate.push(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop();\n}\n});\n}\n/* \u5168\u6392\u5217 II */\nfunction permutationsII(nums) {\nconst res = [];\nbacktrack([], nums, Array(nums.length).fill(false), res);\nreturn res;\n}\n
    permutations_ii.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfunction backtrack(\nstate: number[],\nchoices: number[],\nselected: boolean[],\nres: number[][]\n): void {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.length === choices.length) {\nres.push([...state]);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nconst duplicated = new Set();\nchoices.forEach((choice, i) => {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i] && !duplicated.has(choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true;\nstate.push(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.pop();\n}\n});\n}\n/* \u5168\u6392\u5217 II */\nfunction permutationsII(nums: number[]): number[][] {\nconst res: number[][] = [];\nbacktrack([], nums, Array(nums.length).fill(false), res);\nreturn res;\n}\n
    permutations_ii.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsII}\n
    permutations_ii.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nvoid backtrack(List<int> state, int[] choices, bool[] selected, List<List<int>> res) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif (state.Count == choices.Length) {\nres.Add(new List<int>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nISet<int> duplicated = new HashSet<int>();\nfor (int i = 0; i < choices.Length; i++) {\nint choice = choices[i];\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif (!selected[i] && !duplicated.Contains(choice)) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.Add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true;\nstate.Add(choice);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, choices, selected, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false;\nstate.RemoveAt(state.Count - 1);\n}\n}\n}\n/* \u5168\u6392\u5217 II */\nList<List<int>> permutationsII(int[] nums) {\nList<List<int>> res = new List<List<int>>();\nbacktrack(new List<int>(), nums, new bool[nums.Length], res);\nreturn res;\n}\n
    permutations_ii.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfunc backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {\n// \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\nif state.count == choices.count {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nvar duplicated: Set<Int> = []\nfor (i, choice) in choices.enumerated() {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20 \u4e14 \u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\nif !selected[i], !duplicated.contains(choice) {\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nduplicated.insert(choice) // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\nselected[i] = true\nstate.append(choice)\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, choices: choices, selected: &selected, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nselected[i] = false\nstate.removeLast()\n}\n}\n}\n/* \u5168\u6392\u5217 II */\nfunc permutationsII(nums: [Int]) -> [[Int]] {\nvar state: [Int] = []\nvar selected = Array(repeating: false, count: nums.count)\nvar res: [[Int]] = []\nbacktrack(state: &state, choices: nums, selected: &selected, res: &res)\nreturn res\n}\n
    permutations_ii.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsII}\n
    permutations_ii.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{permutationsII}\n

    \u6ce8\u610f\uff0c\u867d\u7136 selected \u548c duplicated \u90fd\u8d77\u5230\u526a\u679d\u7684\u4f5c\u7528\uff0c\u4f46\u4ed6\u4eec\u526a\u6389\u7684\u662f\u4e0d\u540c\u7684\u5206\u652f\uff1a

    • \u526a\u679d\u6761\u4ef6\u4e00\uff1a\u6574\u4e2a\u641c\u7d22\u8fc7\u7a0b\u4e2d\u53ea\u6709\u4e00\u4e2a selected \u3002\u5b83\u8bb0\u5f55\u7684\u662f\u5f53\u524d\u72b6\u6001\u4e2d\u5305\u542b\u54ea\u4e9b\u5143\u7d20\uff0c\u4f5c\u7528\u662f\u907f\u514d\u67d0\u4e2a\u5143\u7d20\u5728 state \u4e2d\u91cd\u590d\u51fa\u73b0\u3002
    • \u526a\u679d\u6761\u4ef6\u4e8c\uff1a\u6bcf\u8f6e\u9009\u62e9\uff08\u5373\u6bcf\u4e2a\u5f00\u542f\u7684 backtrack \u51fd\u6570\uff09\u90fd\u5305\u542b\u4e00\u4e2a duplicated \u3002\u5b83\u8bb0\u5f55\u7684\u662f\u5728\u904d\u5386\u4e2d\u54ea\u4e9b\u5143\u7d20\u5df2\u88ab\u9009\u62e9\u8fc7\uff0c\u4f5c\u7528\u662f\u4fdd\u8bc1\u76f8\u7b49\u5143\u7d20\u53ea\u88ab\u9009\u62e9\u4e00\u6b21\uff0c\u4ee5\u907f\u514d\u4ea7\u751f\u91cd\u590d\u7684\u641c\u7d22\u5206\u652f\u3002

    \u4e0b\u56fe\u5c55\u793a\u4e86\u4e24\u4e2a\u526a\u679d\u6761\u4ef6\u7684\u751f\u6548\u8303\u56f4\u3002\u6ce8\u610f\uff0c\u6811\u4e2d\u7684\u6bcf\u4e2a\u8282\u70b9\u4ee3\u8868\u4e00\u4e2a\u9009\u62e9\uff0c\u4ece\u6839\u8282\u70b9\u5230\u53f6\u8282\u70b9\u7684\u8def\u5f84\u4e0a\u7684\u5404\u4e2a\u8282\u70b9\u6784\u6210\u4e00\u4e2a\u6392\u5217\u3002

    Fig. \u4e24\u79cd\u526a\u679d\u6761\u4ef6\u7684\u4f5c\u7528\u8303\u56f4

    "},{"location":"chapter_backtracking/permutations_problem/#1223","title":"12.2.3. \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"

    \u5047\u8bbe\u5143\u7d20\u4e24\u4e24\u4e4b\u95f4\u4e92\u4e0d\u76f8\u540c\uff0c\u5219 \\(n\\) \u4e2a\u5143\u7d20\u5171\u6709 \\(n!\\) \u79cd\u6392\u5217\uff08\u9636\u4e58\uff09\uff1b\u5728\u8bb0\u5f55\u7ed3\u679c\u65f6\uff0c\u9700\u8981\u590d\u5236\u957f\u5ea6\u4e3a \\(n\\) \u7684\u5217\u8868\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002\u56e0\u6b64\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n!n)\\) \u3002

    \u6700\u5927\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \uff0c\u4f7f\u7528 \\(O(n)\\) \u6808\u5e27\u7a7a\u95f4\u3002selected \u4f7f\u7528 \\(O(n)\\) \u7a7a\u95f4\u3002\u540c\u4e00\u65f6\u523b\u6700\u591a\u5171\u6709 \\(n\\) \u4e2a duplicated \uff0c\u4f7f\u7528 \\(O(n^2)\\) \u7a7a\u95f4\u3002\u56e0\u6b64\uff0c\u5168\u6392\u5217 I \u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u5168\u6392\u5217 II \u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    "},{"location":"chapter_backtracking/subset_sum_problem/","title":"12.3. \u00a0 \u5b50\u96c6\u548c\u95ee\u9898","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u6b63\u6574\u6570\u6570\u7ec4 nums \u548c\u4e00\u4e2a\u76ee\u6807\u6b63\u6574\u6570 target \uff0c\u8bf7\u627e\u51fa\u6240\u6709\u53ef\u80fd\u7684\u7ec4\u5408\uff0c\u4f7f\u5f97\u7ec4\u5408\u4e2d\u7684\u5143\u7d20\u548c\u7b49\u4e8e target \u3002\u7ed9\u5b9a\u6570\u7ec4\u65e0\u91cd\u590d\u5143\u7d20\uff0c\u6bcf\u4e2a\u5143\u7d20\u53ef\u4ee5\u88ab\u9009\u53d6\u591a\u6b21\u3002\u8bf7\u4ee5\u5217\u8868\u5f62\u5f0f\u8fd4\u56de\u8fd9\u4e9b\u7ec4\u5408\uff0c\u5217\u8868\u4e2d\u4e0d\u5e94\u5305\u542b\u91cd\u590d\u7ec4\u5408\u3002

    \u4f8b\u5982\uff0c\u8f93\u5165\u96c6\u5408 \\(\\{3, 4, 5\\}\\) \u548c\u76ee\u6807\u6574\u6570 \\(9\\) \uff0c\u7531\u4e8e\u96c6\u5408\u4e2d\u7684\u6570\u5b57\u53ef\u4ee5\u88ab\u91cd\u590d\u9009\u53d6\uff0c\u56e0\u6b64\u89e3\u4e3a \\(\\{3, 3, 3\\}, \\{4, 5\\}\\) \u3002\u8bf7\u6ce8\u610f\uff0c\u5b50\u96c6\u662f\u4e0d\u533a\u5206\u5143\u7d20\u987a\u5e8f\u7684\uff0c\u4f8b\u5982 \\(\\{4, 5\\}\\) \u548c \\(\\{5, 4\\}\\) \u662f\u540c\u4e00\u4e2a\u5b50\u96c6\u3002

    "},{"location":"chapter_backtracking/subset_sum_problem/#1231","title":"12.3.1. \u00a0 \u4ece\u5168\u6392\u5217\u5f15\u51fa\u89e3\u6cd5","text":"

    \u7c7b\u4f3c\u4e8e\u4e0a\u8282\u5168\u6392\u5217\u95ee\u9898\u7684\u89e3\u6cd5\uff0c\u6211\u4eec\u53ef\u4ee5\u628a\u5b50\u96c6\u7684\u751f\u6210\u8fc7\u7a0b\u60f3\u8c61\u6210\u4e00\u7cfb\u5217\u9009\u62e9\u7684\u7ed3\u679c\uff0c\u5e76\u5728\u9009\u62e9\u8fc7\u7a0b\u4e2d\u5b9e\u65f6\u66f4\u65b0\u201c\u5143\u7d20\u548c\u201d\uff0c\u5f53\u5143\u7d20\u548c\u7b49\u4e8e target \u65f6\uff0c\u5c31\u5c06\u5b50\u96c6\u8bb0\u5f55\u81f3\u7ed3\u679c\u5217\u8868\u3002

    \u800c\u4e0e\u5168\u6392\u5217\u95ee\u9898\u4e0d\u540c\u7684\u662f\uff0c\u672c\u9898\u5141\u8bb8\u91cd\u590d\u9009\u53d6\u540c\u4e00\u5143\u7d20\uff0c\u56e0\u6b64\u65e0\u9700\u501f\u52a9 selected \u5e03\u5c14\u5217\u8868\u6765\u8bb0\u5f55\u5143\u7d20\u662f\u5426\u5df2\u88ab\u9009\u62e9\u3002\u6211\u4eec\u53ef\u4ee5\u5bf9\u5168\u6392\u5217\u4ee3\u7801\u8fdb\u884c\u5c0f\u5e45\u4fee\u6539\uff0c\u521d\u6b65\u5f97\u5230\u89e3\u9898\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart subset_sum_i_naive.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(List<Integer> state, int target, int total, int[] choices, List<List<Integer>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (total == target) {\nres.add(new ArrayList<>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < choices.length; i++) {\n// \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif (total + choices[i] > target) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\nstate.add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target, total + choices[i], choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.remove(state.size() - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nList<List<Integer>> subsetSumINaive(int[] nums, int target) {\nList<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nint total = 0; // \u5b50\u96c6\u548c\nList<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, total, nums, res);\nreturn res;\n}\n
    subset_sum_i_naive.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(vector<int> &state, int target, int total, vector<int> &choices, vector<vector<int>> &res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (total == target) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (size_t i = 0; i < choices.size(); i++) {\n// \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif (total + choices[i] > target) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\nstate.push_back(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target, total + choices[i], choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop_back();\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nvector<vector<int>> subsetSumINaive(vector<int> &nums, int target) {\nvector<int> state;       // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nint total = 0;           // \u5b50\u96c6\u548c\nvector<vector<int>> res; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, total, nums, res);\nreturn res;\n}\n
    subset_sum_i_naive.py
    def backtrack(\nstate: list[int],\ntarget: int,\ntotal: int,\nchoices: list[int],\nres: list[list[int]],\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I\"\"\"\n# \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif total == target:\nres.append(list(state))\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nfor i in range(len(choices)):\n# \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif total + choices[i] > target:\ncontinue\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\nstate.append(choices[i])\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target, total + choices[i], choices, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop()\ndef subset_sum_i_naive(nums: list[int], target: int) -> list[list[int]]:\n\"\"\"\u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09\"\"\"\nstate = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\ntotal = 0  # \u5b50\u96c6\u548c\nres = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, total, nums, res)\nreturn res\n
    subset_sum_i_naive.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunc backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == total {\nnewState := append([]int{}, *state...)\n*res = append(*res, newState)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor i := 0; i < len(*choices); i++ {\n// \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif total+(*choices)[i] > target {\ncontinue\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n*state = append(*state, (*choices)[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n*state = (*state)[:len(*state)-1]\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunc subsetSumINaive(nums []int, target int) [][]int {\nstate := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\ntotal := 0              // \u5b50\u96c6\u548c\nres := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrackSubsetSumINaive(total, target, &state, &nums, &res)\nreturn res\n}\n
    subset_sum_i_naive.js
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumINaive}\n
    subset_sum_i_naive.ts
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumINaive}\n
    subset_sum_i_naive.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumINaive}\n
    subset_sum_i_naive.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(List<int> state, int target, int total, int[] choices, List<List<int>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (total == target) {\nres.Add(new List<int>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (int i = 0; i < choices.Length; i++) {\n// \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif (total + choices[i] > target) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\nstate.Add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target, total + choices[i], choices, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.RemoveAt(state.Count - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nList<List<int>> subsetSumINaive(int[] nums, int target) {\nList<int> state = new List<int>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nint total = 0; // \u5b50\u96c6\u548c\nList<List<int>> res = new List<List<int>>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, total, nums, res);\nreturn res;\n}\n
    subset_sum_i_naive.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunc backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif total == target {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor i in stride(from: 0, to: choices.count, by: 1) {\n// \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\nif total + choices[i] > target {\ncontinue\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\nstate.append(choices[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, target: target, total: total + choices[i], choices: choices, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.removeLast()\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunc subsetSumINaive(nums: [Int], target: Int) -> [[Int]] {\nvar state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nlet total = 0 // \u5b50\u96c6\u548c\nvar res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state: &state, target: target, total: total, choices: nums, res: &res)\nreturn res\n}\n
    subset_sum_i_naive.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumINaive}\n
    subset_sum_i_naive.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumINaive}\n

    \u5411\u4ee5\u4e0a\u4ee3\u7801\u8f93\u5165\u6570\u7ec4 \\([3, 4, 5]\\) \u548c\u76ee\u6807\u5143\u7d20 \\(9\\) \uff0c\u8f93\u51fa\u7ed3\u679c\u4e3a \\([3, 3, 3], [4, 5], [5, 4]\\) \u3002\u867d\u7136\u6210\u529f\u627e\u51fa\u4e86\u6240\u6709\u548c\u4e3a \\(9\\) \u7684\u5b50\u96c6\uff0c\u4f46\u5176\u4e2d\u5b58\u5728\u91cd\u590d\u7684\u5b50\u96c6 \\([4, 5]\\) \u548c \\([5, 4]\\) \u3002\u8fd9\u662f\u56e0\u4e3a\u641c\u7d22\u8fc7\u7a0b\u662f\u533a\u5206\u9009\u62e9\u987a\u5e8f\u7684\uff0c\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5148\u9009 \\(4\\) \u540e\u9009 \\(5\\) \u4e0e\u5148\u9009 \\(5\\) \u540e\u9009 \\(4\\) \u662f\u4e24\u79cd\u4e0d\u540c\u7684\u60c5\u51b5\u3002

    Fig. \u5b50\u96c6\u641c\u7d22\u4e0e\u8d8a\u754c\u526a\u679d

    "},{"location":"chapter_backtracking/subset_sum_problem/#1232","title":"12.3.2. \u00a0 \u91cd\u590d\u5b50\u96c6\u526a\u679d","text":"

    \u4e3a\u4e86\u53bb\u9664\u91cd\u590d\u5b50\u96c6\uff0c\u4e00\u79cd\u76f4\u63a5\u7684\u601d\u8def\u662f\u5bf9\u7ed3\u679c\u5217\u8868\u8fdb\u884c\u53bb\u91cd\u3002\u4f46\u8fd9\u4e2a\u65b9\u6cd5\u6548\u7387\u5f88\u4f4e\uff0c\u56e0\u4e3a\uff1a

    • \u5f53\u6570\u7ec4\u5143\u7d20\u8f83\u591a\uff0c\u5c24\u5176\u662f\u5f53 target \u8f83\u5927\u65f6\uff0c\u641c\u7d22\u8fc7\u7a0b\u4f1a\u4ea7\u751f\u5927\u91cf\u7684\u91cd\u590d\u5b50\u96c6\u3002
    • \u6bd4\u8f83\u5b50\u96c6\uff08\u6570\u7ec4\uff09\u7684\u5f02\u540c\u662f\u5f88\u8017\u65f6\u7684\uff0c\u9700\u8981\u5148\u6392\u5e8f\u6570\u7ec4\uff0c\u518d\u6bd4\u8f83\u6570\u7ec4\u4e2d\u6bcf\u4e2a\u5143\u7d20\u7684\u5f02\u540c\u3002

    \u4e3a\u4e86\u8fbe\u5230\u6700\u4f73\u6548\u7387\uff0c\u6211\u4eec\u5e0c\u671b\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u901a\u8fc7\u526a\u679d\u8fdb\u884c\u53bb\u91cd\u3002\u89c2\u5bdf\u4e0b\u56fe\uff0c\u91cd\u590d\u5b50\u96c6\u662f\u5728\u4ee5\u4e0d\u540c\u987a\u5e8f\u9009\u62e9\u6570\u7ec4\u5143\u7d20\u65f6\u4ea7\u751f\u7684\uff0c\u5177\u4f53\u6765\u770b\uff1a

    1. \u7b2c\u4e00\u8f6e\u548c\u7b2c\u4e8c\u8f6e\u5206\u522b\u9009\u62e9 \\(3\\) , \\(4\\) \uff0c\u4f1a\u751f\u6210\u5305\u542b\u8fd9\u4e24\u4e2a\u5143\u7d20\u7684\u6240\u6709\u5b50\u96c6\uff0c\u8bb0\u4e3a \\([3, 4, \\cdots]\\) \u3002
    2. \u82e5\u7b2c\u4e00\u8f6e\u9009\u62e9 \\(4\\) \uff0c\u5219\u7b2c\u4e8c\u8f6e\u5e94\u8be5\u8df3\u8fc7 \\(3\\) \uff0c\u56e0\u4e3a\u8be5\u9009\u62e9\u4ea7\u751f\u7684\u5b50\u96c6 \\([4, 3, \\cdots]\\) \u548c 1. \u4e2d\u63d0\u5230\u7684\u5b50\u96c6\u5b8c\u5168\u91cd\u590d\u3002
    3. \u540c\u7406\uff0c\u82e5\u7b2c\u4e00\u8f6e\u9009\u62e9 \\(5\\) \uff0c\u5219\u7b2c\u4e8c\u8f6e\u5e94\u8be5\u8df3\u8fc7 \\(3\\) \u548c \\(4\\) \uff0c\u56e0\u4e3a\u5b50\u96c6 \\([5, 3, \\cdots]\\) \u548c\u5b50\u96c6 \\([5, 4, \\cdots]\\) \u548c\u4e4b\u524d\u7684\u5b50\u96c6\u91cd\u590d\u3002

    Fig. \u4e0d\u540c\u9009\u62e9\u987a\u5e8f\u5bfc\u81f4\u7684\u91cd\u590d\u5b50\u96c6

    \u603b\u7ed3\u6765\u770b\uff0c\u7ed9\u5b9a\u8f93\u5165\u6570\u7ec4 \\([x_1, x_2, \\cdots, x_n]\\) \uff0c\u8bbe\u641c\u7d22\u8fc7\u7a0b\u4e2d\u7684\u9009\u62e9\u5e8f\u5217\u4e3a \\([x_{i_1}, x_{i_2}, \\cdots , x_{i_m}]\\) \uff0c\u5219\u8be5\u9009\u62e9\u5e8f\u5217\u9700\u8981\u6ee1\u8db3 \\(i_1 \\leq i_2 \\leq \\cdots \\leq i_m\\) \u3002\u4e0d\u6ee1\u8db3\u8be5\u6761\u4ef6\u7684\u9009\u62e9\u5e8f\u5217\u90fd\u662f\u91cd\u590d\u5b50\u96c6\u3002

    \u4e3a\u5b9e\u73b0\u8be5\u526a\u679d\uff0c\u6211\u4eec\u521d\u59cb\u5316\u53d8\u91cf start \uff0c\u7528\u4e8e\u6307\u793a\u904d\u5386\u8d77\u70b9\u3002\u5f53\u505a\u51fa\u9009\u62e9 \\(x_{i}\\) \u540e\uff0c\u8bbe\u5b9a\u4e0b\u4e00\u8f6e\u4ece\u7d22\u5f15 \\(i\\) \u5f00\u59cb\u904d\u5386\uff0c\u4ece\u800c\u5b8c\u6210\u5b50\u96c6\u53bb\u91cd\u3002

    \u9664\u6b64\u4e4b\u5916\uff0c\u6211\u4eec\u8fd8\u5bf9\u4ee3\u7801\u8fdb\u884c\u4e86\u4e24\u9879\u4f18\u5316\u3002\u9996\u5148\uff0c\u6211\u4eec\u5728\u5f00\u542f\u641c\u7d22\u524d\u5c06\u6570\u7ec4 nums \u6392\u5e8f\uff0c\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u5f53\u5b50\u96c6\u548c\u8d85\u8fc7 target \u65f6\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\uff0c\u56e0\u4e3a\u540e\u8fb9\u7684\u5143\u7d20\u66f4\u5927\uff0c\u5176\u5b50\u96c6\u548c\u90fd\u4e00\u5b9a\u4f1a\u8d85\u8fc7 target \u3002\u5176\u6b21\uff0c\u6211\u4eec\u901a\u8fc7\u5728 target \u4e0a\u6267\u884c\u51cf\u6cd5\u6765\u7edf\u8ba1\u5143\u7d20\u548c\uff0c\u5f53 target \u7b49\u4e8e \\(0\\) \u65f6\u8bb0\u5f55\u89e3\uff0c\u7701\u53bb\u4e86\u5143\u7d20\u548c\u53d8\u91cf total \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart subset_sum_i.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.add(new ArrayList<>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor (int i = start; i < choices.length; i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.remove(state.size() - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nList<List<Integer>> subsetSumI(int[] nums, int target) {\nList<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nArrays.sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\nList<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_i.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor (int i = start; i < choices.size(); i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.push_back(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop_back();\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nvector<vector<int>> subsetSumI(vector<int> &nums, int target) {\nvector<int> state;              // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nsort(nums.begin(), nums.end()); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0;                  // \u904d\u5386\u8d77\u59cb\u70b9\nvector<vector<int>> res;        // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_i.py
    def backtrack(\nstate: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I\"\"\"\n# \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0:\nres.append(list(state))\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\n# \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor i in range(start, len(choices)):\n# \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n# \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target - choices[i] < 0:\nbreak\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.append(choices[i])\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop()\ndef subset_sum_i(nums: list[int], target: int) -> list[list[int]]:\n\"\"\"\u6c42\u89e3\u5b50\u96c6\u548c I\"\"\"\nstate = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\nnums.sort()  # \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nstart = 0  # \u904d\u5386\u8d77\u59cb\u70b9\nres = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res)\nreturn res\n
    subset_sum_i.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunc backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0 {\nnewState := append([]int{}, *state...)\n*res = append(*res, newState)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor i := start; i < len(*choices); i++ {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target-(*choices)[i] < 0 {\nbreak\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n*state = append(*state, (*choices)[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrackSubsetSumI(i, target-(*choices)[i], state, choices, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n*state = (*state)[:len(*state)-1]\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunc subsetSumI(nums []int, target int) [][]int {\nstate := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nsort.Ints(nums)         // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nstart := 0              // \u904d\u5386\u8d77\u59cb\u70b9\nres := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrackSubsetSumI(start, target, &state, &nums, &res)\nreturn res\n}\n
    subset_sum_i.js
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumI}\n
    subset_sum_i.ts
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumI}\n
    subset_sum_i.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumI}\n
    subset_sum_i.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(List<int> state, int target, int[] choices, int start, List<List<int>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.Add(new List<int>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor (int i = start; i < choices.Length; i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.Add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.RemoveAt(state.Count - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nList<List<int>> subsetSumI(int[] nums, int target) {\nList<int> state = new List<int>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nArray.Sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\nList<List<int>> res = new List<List<int>>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_i.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0 {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\nfor i in stride(from: start, to: choices.count, by: 1) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target - choices[i] < 0 {\nbreak\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.append(choices[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, target: target - choices[i], choices: choices, start: i, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.removeLast()\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunc subsetSumI(nums: [Int], target: Int) -> [[Int]] {\nvar state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nlet nums = nums.sorted() // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nlet start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\nvar res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state: &state, target: target, choices: nums, start: start, res: &res)\nreturn res\n}\n
    subset_sum_i.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumI}\n
    subset_sum_i.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumI}\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u4e3a\u5c06\u6570\u7ec4 \\([3, 4, 5]\\) \u548c\u76ee\u6807\u5143\u7d20 \\(9\\) \u8f93\u5165\u5230\u4ee5\u4e0a\u4ee3\u7801\u540e\u7684\u6574\u4f53\u56de\u6eaf\u8fc7\u7a0b\u3002

    Fig. \u5b50\u96c6\u548c I \u56de\u6eaf\u8fc7\u7a0b

    "},{"location":"chapter_backtracking/subset_sum_problem/#1233","title":"12.3.3. \u00a0 \u76f8\u7b49\u5143\u7d20\u526a\u679d","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u6b63\u6574\u6570\u6570\u7ec4 nums \u548c\u4e00\u4e2a\u76ee\u6807\u6b63\u6574\u6570 target \uff0c\u8bf7\u627e\u51fa\u6240\u6709\u53ef\u80fd\u7684\u7ec4\u5408\uff0c\u4f7f\u5f97\u7ec4\u5408\u4e2d\u7684\u5143\u7d20\u548c\u7b49\u4e8e target \u3002\u7ed9\u5b9a\u6570\u7ec4\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\uff0c\u6bcf\u4e2a\u5143\u7d20\u53ea\u53ef\u88ab\u9009\u62e9\u4e00\u6b21\u3002\u8bf7\u4ee5\u5217\u8868\u5f62\u5f0f\u8fd4\u56de\u8fd9\u4e9b\u7ec4\u5408\uff0c\u5217\u8868\u4e2d\u4e0d\u5e94\u5305\u542b\u91cd\u590d\u7ec4\u5408\u3002

    \u76f8\u6bd4\u4e8e\u4e0a\u9898\uff0c\u672c\u9898\u7684\u8f93\u5165\u6570\u7ec4\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\uff0c\u8fd9\u5f15\u5165\u4e86\u65b0\u7684\u95ee\u9898\u3002\u4f8b\u5982\uff0c\u7ed9\u5b9a\u6570\u7ec4 \\([4, \\hat{4}, 5]\\) \u548c\u76ee\u6807\u5143\u7d20 \\(9\\) \uff0c\u5219\u73b0\u6709\u4ee3\u7801\u7684\u8f93\u51fa\u7ed3\u679c\u4e3a \\([4, 5], [\\hat{4}, 5]\\) \uff0c\u4e5f\u51fa\u73b0\u4e86\u91cd\u590d\u5b50\u96c6\u3002\u9020\u6210\u8fd9\u79cd\u91cd\u590d\u7684\u539f\u56e0\u662f\u76f8\u7b49\u5143\u7d20\u5728\u67d0\u8f6e\u4e2d\u88ab\u591a\u6b21\u9009\u62e9\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u7b2c\u4e00\u8f6e\u5171\u6709\u4e09\u4e2a\u9009\u62e9\uff0c\u5176\u4e2d\u4e24\u4e2a\u90fd\u4e3a \\(4\\) \uff0c\u4f1a\u4ea7\u751f\u4e24\u4e2a\u91cd\u590d\u7684\u641c\u7d22\u5206\u652f\uff0c\u4ece\u800c\u8f93\u51fa\u91cd\u590d\u5b50\u96c6\uff1b\u540c\u7406\uff0c\u7b2c\u4e8c\u8f6e\u7684\u4e24\u4e2a \\(4\\) \u4e5f\u4f1a\u4ea7\u751f\u91cd\u590d\u5b50\u96c6\u3002

    Fig. \u76f8\u7b49\u5143\u7d20\u5bfc\u81f4\u7684\u91cd\u590d\u5b50\u96c6

    \u4e3a\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u9700\u8981\u9650\u5236\u76f8\u7b49\u5143\u7d20\u5728\u6bcf\u4e00\u8f6e\u4e2d\u53ea\u88ab\u9009\u62e9\u4e00\u6b21\u3002\u5b9e\u73b0\u65b9\u5f0f\u6bd4\u8f83\u5de7\u5999\uff1a\u7531\u4e8e\u6570\u7ec4\u662f\u5df2\u6392\u5e8f\u7684\uff0c\u56e0\u6b64\u76f8\u7b49\u5143\u7d20\u90fd\u662f\u76f8\u90bb\u7684\u3002\u5229\u7528\u8be5\u7279\u6027\uff0c\u5728\u67d0\u8f6e\u9009\u62e9\u4e2d\uff0c\u82e5\u5f53\u524d\u5143\u7d20\u4e0e\u5176\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u5219\u8bf4\u660e\u5b83\u5df2\u7ecf\u88ab\u9009\u62e9\u8fc7\uff0c\u56e0\u6b64\u76f4\u63a5\u8df3\u8fc7\u5f53\u524d\u5143\u7d20\u3002

    \u4e0e\u6b64\u540c\u65f6\uff0c\u672c\u9898\u89c4\u5b9a\u6570\u7ec4\u5143\u7d20\u53ea\u80fd\u88ab\u9009\u62e9\u4e00\u6b21\u3002\u5e78\u8fd0\u7684\u662f\uff0c\u6211\u4eec\u4e5f\u53ef\u4ee5\u5229\u7528\u53d8\u91cf start \u6765\u6ee1\u8db3\u8be5\u7ea6\u675f\uff1a\u5f53\u505a\u51fa\u9009\u62e9 \\(x_{i}\\) \u540e\uff0c\u8bbe\u5b9a\u4e0b\u4e00\u8f6e\u4ece\u7d22\u5f15 \\(i + 1\\) \u5f00\u59cb\u5411\u540e\u904d\u5386\u3002\u8fd9\u6837\u5373\u80fd\u53bb\u9664\u91cd\u590d\u5b50\u96c6\uff0c\u4e5f\u80fd\u907f\u514d\u91cd\u590d\u9009\u62e9\u76f8\u7b49\u5143\u7d20\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart subset_sum_ii.java
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nvoid backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.add(new ArrayList<>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n// \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor (int i = start; i < choices.length; i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif (i > start && choices[i] == choices[i - 1]) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i + 1, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.remove(state.size() - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nList<List<Integer>> subsetSumII(int[] nums, int target) {\nList<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nArrays.sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\nList<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_ii.cpp
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nvoid backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.push_back(state);\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n// \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor (int i = start; i < choices.size(); i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif (i > start && choices[i] == choices[i - 1]) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.push_back(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i + 1, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop_back();\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nvector<vector<int>> subsetSumII(vector<int> &nums, int target) {\nvector<int> state;              // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nsort(nums.begin(), nums.end()); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0;                  // \u904d\u5386\u8d77\u59cb\u70b9\nvector<vector<int>> res;        // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_ii.py
    def backtrack(\nstate: list[int], target: int, choices: list[int], start: int, res: list[list[int]]\n):\n\"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II\"\"\"\n# \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0:\nres.append(list(state))\nreturn\n# \u904d\u5386\u6240\u6709\u9009\u62e9\n# \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n# \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor i in range(start, len(choices)):\n# \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n# \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target - choices[i] < 0:\nbreak\n# \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif i > start and choices[i] == choices[i - 1]:\ncontinue\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.append(choices[i])\n# \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i + 1, res)\n# \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.pop()\ndef subset_sum_ii(nums: list[int], target: int) -> list[list[int]]:\n\"\"\"\u6c42\u89e3\u5b50\u96c6\u548c II\"\"\"\nstate = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\nnums.sort()  # \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nstart = 0  # \u904d\u5386\u8d77\u59cb\u70b9\nres = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res)\nreturn res\n
    subset_sum_ii.go
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfunc backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0 {\nnewState := append([]int{}, *state...)\n*res = append(*res, newState)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n// \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor i := start; i < len(*choices); i++ {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target-(*choices)[i] < 0 {\nbreak\n}\n// \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif i > start && (*choices)[i] == (*choices)[i-1] {\ncontinue\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n*state = append(*state, (*choices)[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n*state = (*state)[:len(*state)-1]\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunc subsetSumII(nums []int, target int) [][]int {\nstate := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nsort.Ints(nums)         // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nstart := 0              // \u904d\u5386\u8d77\u59cb\u70b9\nres := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrackSubsetSumII(start, target, &state, &nums, &res)\nreturn res\n}\n
    subset_sum_ii.js
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumII}\n
    subset_sum_ii.ts
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumII}\n
    subset_sum_ii.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumII}\n
    subset_sum_ii.cs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nvoid backtrack(List<int> state, int target, int[] choices, int start, List<List<int>> res) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif (target == 0) {\nres.Add(new List<int>(state));\nreturn;\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n// \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor (int i = start; i < choices.Length; i++) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif (target - choices[i] < 0) {\nbreak;\n}\n// \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif (i > start && choices[i] == choices[i - 1]) {\ncontinue;\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.Add(choices[i]);\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state, target - choices[i], choices, i + 1, res);\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.RemoveAt(state.Count - 1);\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nList<List<int>> subsetSumII(int[] nums, int target) {\nList<int> state = new List<int>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nArray.Sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nint start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\nList<List<int>> res = new List<List<int>>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state, target, nums, start, res);\nreturn res;\n}\n
    subset_sum_ii.swift
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfunc backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {\n// \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\nif target == 0 {\nres.append(state)\nreturn\n}\n// \u904d\u5386\u6240\u6709\u9009\u62e9\n// \u526a\u679d\u4e8c\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u751f\u6210\u91cd\u590d\u5b50\u96c6\n// \u526a\u679d\u4e09\uff1a\u4ece start \u5f00\u59cb\u904d\u5386\uff0c\u907f\u514d\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\nfor i in stride(from: start, to: choices.count, by: 1) {\n// \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u7ed3\u675f\u5faa\u73af\n// \u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u5df2\u6392\u5e8f\uff0c\u540e\u8fb9\u5143\u7d20\u66f4\u5927\uff0c\u5b50\u96c6\u548c\u4e00\u5b9a\u8d85\u8fc7 target\nif target - choices[i] < 0 {\nbreak\n}\n// \u526a\u679d\u56db\uff1a\u5982\u679c\u8be5\u5143\u7d20\u4e0e\u5de6\u8fb9\u5143\u7d20\u76f8\u7b49\uff0c\u8bf4\u660e\u8be5\u641c\u7d22\u5206\u652f\u91cd\u590d\uff0c\u76f4\u63a5\u8df3\u8fc7\nif i > start, choices[i] == choices[i - 1] {\ncontinue\n}\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\nstate.append(choices[i])\n// \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\nbacktrack(state: &state, target: target - choices[i], choices: choices, start: i + 1, res: &res)\n// \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\nstate.removeLast()\n}\n}\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunc subsetSumII(nums: [Int], target: Int) -> [[Int]] {\nvar state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\nlet nums = nums.sorted() // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\nlet start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\nvar res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\nbacktrack(state: &state, target: target, choices: nums, start: start, res: &res)\nreturn res\n}\n
    subset_sum_ii.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumII}\n
    subset_sum_ii.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{subsetSumII}\n

    \u4e0b\u56fe\u5c55\u793a\u4e86\u6570\u7ec4 \\([4, 4, 5]\\) \u548c\u76ee\u6807\u5143\u7d20 \\(9\\) \u7684\u56de\u6eaf\u8fc7\u7a0b\uff0c\u5171\u5305\u542b\u56db\u79cd\u526a\u679d\u64cd\u4f5c\u3002\u5efa\u8bae\u4f60\u5c06\u56fe\u793a\u4e0e\u4ee3\u7801\u6ce8\u91ca\u76f8\u7ed3\u5408\uff0c\u7406\u89e3\u6574\u4e2a\u641c\u7d22\u8fc7\u7a0b\uff0c\u4ee5\u53ca\u6bcf\u79cd\u526a\u679d\u64cd\u4f5c\u662f\u5982\u4f55\u5de5\u4f5c\u7684\u3002

    Fig. \u5b50\u96c6\u548c II \u56de\u6eaf\u8fc7\u7a0b

    "},{"location":"chapter_backtracking/summary/","title":"12.5. \u00a0 \u5c0f\u7ed3","text":"
    • \u56de\u6eaf\u7b97\u6cd5\u672c\u8d28\u662f\u7a77\u4e3e\u6cd5\uff0c\u901a\u8fc7\u5bf9\u89e3\u7a7a\u95f4\u8fdb\u884c\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u6765\u5bfb\u627e\u7b26\u5408\u6761\u4ef6\u7684\u89e3\u3002\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u9047\u5230\u6ee1\u8db3\u6761\u4ef6\u7684\u89e3\u5219\u8bb0\u5f55\uff0c\u76f4\u81f3\u627e\u5230\u6240\u6709\u89e3\u6216\u904d\u5386\u5b8c\u6210\u540e\u7ed3\u675f\u3002
    • \u56de\u6eaf\u7b97\u6cd5\u7684\u641c\u7d22\u8fc7\u7a0b\u5305\u62ec\u5c1d\u8bd5\u4e0e\u56de\u9000\u4e24\u4e2a\u90e8\u5206\u3002\u5b83\u901a\u8fc7\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u6765\u5c1d\u8bd5\u5404\u79cd\u9009\u62e9\uff0c\u5f53\u9047\u5230\u4e0d\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\u7684\u60c5\u51b5\u65f6\uff0c\u5219\u64a4\u9500\u4e0a\u4e00\u6b65\u7684\u9009\u62e9\uff0c\u9000\u56de\u5230\u4e4b\u524d\u7684\u72b6\u6001\uff0c\u5e76\u7ee7\u7eed\u5c1d\u8bd5\u5176\u4ed6\u9009\u62e9\u3002\u5c1d\u8bd5\u4e0e\u56de\u9000\u662f\u4e24\u4e2a\u65b9\u5411\u76f8\u53cd\u7684\u64cd\u4f5c\u3002
    • \u56de\u6eaf\u95ee\u9898\u901a\u5e38\u5305\u542b\u591a\u4e2a\u7ea6\u675f\u6761\u4ef6\uff0c\u5b83\u4eec\u53ef\u7528\u4e8e\u5b9e\u73b0\u526a\u679d\u64cd\u4f5c\u3002\u526a\u679d\u53ef\u4ee5\u63d0\u524d\u7ed3\u675f\u4e0d\u5fc5\u8981\u7684\u641c\u7d22\u5206\u652f\uff0c\u5927\u5e45\u63d0\u5347\u641c\u7d22\u6548\u7387\u3002
    • \u56de\u6eaf\u7b97\u6cd5\u4e3b\u8981\u53ef\u7528\u4e8e\u89e3\u51b3\u641c\u7d22\u95ee\u9898\u548c\u7ea6\u675f\u6ee1\u8db3\u95ee\u9898\u3002\u7ec4\u5408\u4f18\u5316\u95ee\u9898\u867d\u7136\u53ef\u4ee5\u7528\u56de\u6eaf\u7b97\u6cd5\u89e3\u51b3\uff0c\u4f46\u5f80\u5f80\u5b58\u5728\u66f4\u9ad8\u6548\u7387\u6216\u66f4\u597d\u6548\u679c\u7684\u89e3\u6cd5\u3002
    • \u5168\u6392\u5217\u95ee\u9898\u65e8\u5728\u641c\u7d22\u7ed9\u5b9a\u96c6\u5408\u7684\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u3002\u6211\u4eec\u501f\u52a9\u4e00\u4e2a\u6570\u7ec4\u6765\u8bb0\u5f55\u6bcf\u4e2a\u5143\u7d20\u662f\u5426\u88ab\u9009\u62e9\uff0c\u526a\u679d\u6389\u91cd\u590d\u9009\u62e9\u540c\u4e00\u5143\u7d20\u7684\u641c\u7d22\u5206\u652f\uff0c\u786e\u4fdd\u6bcf\u4e2a\u5143\u7d20\u53ea\u88ab\u9009\u62e9\u4e00\u6b21\u3002
    • \u5728\u5168\u6392\u5217\u95ee\u9898\u4e2d\uff0c\u5982\u679c\u96c6\u5408\u4e2d\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff0c\u5219\u6700\u7ec8\u7ed3\u679c\u4f1a\u51fa\u73b0\u91cd\u590d\u6392\u5217\u3002\u6211\u4eec\u9700\u8981\u7ea6\u675f\u76f8\u7b49\u5143\u7d20\u5728\u6bcf\u8f6e\u4e2d\u53ea\u80fd\u88ab\u9009\u62e9\u4e00\u6b21\uff0c\u8fd9\u901a\u5e38\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868\u6765\u5b9e\u73b0\u3002
    • \u5b50\u96c6\u548c\u95ee\u9898\u7684\u76ee\u6807\u662f\u5728\u7ed9\u5b9a\u96c6\u5408\u4e2d\u627e\u5230\u548c\u4e3a\u76ee\u6807\u503c\u7684\u6240\u6709\u5b50\u96c6\u3002\u96c6\u5408\u4e0d\u533a\u5206\u5143\u7d20\u987a\u5e8f\uff0c\u800c\u641c\u7d22\u8fc7\u7a0b\u4f1a\u8f93\u51fa\u6240\u6709\u987a\u5e8f\u7684\u7ed3\u679c\uff0c\u4ea7\u751f\u91cd\u590d\u5b50\u96c6\u3002\u6211\u4eec\u5728\u56de\u6eaf\u524d\u5c06\u6570\u636e\u8fdb\u884c\u6392\u5e8f\uff0c\u5e76\u8bbe\u7f6e\u4e00\u4e2a\u53d8\u91cf\u6765\u6307\u793a\u6bcf\u4e00\u8f6e\u7684\u904d\u5386\u8d77\u70b9\uff0c\u4ece\u800c\u5c06\u751f\u6210\u91cd\u590d\u5b50\u96c6\u7684\u641c\u7d22\u5206\u652f\u8fdb\u884c\u526a\u679d\u3002
    • \u5bf9\u4e8e\u5b50\u96c6\u548c\u95ee\u9898\uff0c\u6570\u7ec4\u4e2d\u7684\u76f8\u7b49\u5143\u7d20\u4f1a\u4ea7\u751f\u91cd\u590d\u96c6\u5408\u3002\u6211\u4eec\u5229\u7528\u6570\u7ec4\u5df2\u6392\u5e8f\u7684\u524d\u7f6e\u6761\u4ef6\uff0c\u901a\u8fc7\u5224\u65ad\u76f8\u90bb\u5143\u7d20\u662f\u5426\u76f8\u7b49\u5b9e\u73b0\u526a\u679d\uff0c\u4ece\u800c\u786e\u4fdd\u76f8\u7b49\u5143\u7d20\u5728\u6bcf\u8f6e\u4e2d\u53ea\u80fd\u88ab\u9009\u4e2d\u4e00\u6b21\u3002
    • \\(n\\) \u7687\u540e\u65e8\u5728\u5bfb\u627e\u5c06 \\(n\\) \u4e2a\u7687\u540e\u653e\u7f6e\u5230 \\(n \\times n\\) \u5c3a\u5bf8\u68cb\u76d8\u4e0a\u7684\u65b9\u6848\uff0c\u8981\u6c42\u6240\u6709\u7687\u540e\u4e24\u4e24\u4e4b\u95f4\u65e0\u6cd5\u653b\u51fb\u5bf9\u65b9\u3002\u8be5\u95ee\u9898\u7684\u7ea6\u675f\u6761\u4ef6\u6709\u884c\u7ea6\u675f\u3001\u5217\u7ea6\u675f\u3001\u4e3b\u5bf9\u89d2\u7ebf\u548c\u526f\u5bf9\u89d2\u7ebf\u7ea6\u675f\u3002\u4e3a\u6ee1\u8db3\u884c\u7ea6\u675f\uff0c\u6211\u4eec\u91c7\u7528\u6309\u884c\u653e\u7f6e\u7684\u7b56\u7565\uff0c\u4fdd\u8bc1\u6bcf\u4e00\u884c\u653e\u7f6e\u4e00\u4e2a\u7687\u540e\u3002
    • \u5217\u7ea6\u675f\u548c\u5bf9\u89d2\u7ebf\u7ea6\u675f\u7684\u5904\u7406\u65b9\u5f0f\u7c7b\u4f3c\u3002\u5bf9\u4e8e\u5217\u7ea6\u675f\uff0c\u6211\u4eec\u5229\u7528\u4e00\u4e2a\u6570\u7ec4\u6765\u8bb0\u5f55\u6bcf\u4e00\u5217\u662f\u5426\u6709\u7687\u540e\uff0c\u4ece\u800c\u6307\u793a\u9009\u4e2d\u7684\u683c\u5b50\u662f\u5426\u5408\u6cd5\u3002\u5bf9\u4e8e\u5bf9\u89d2\u7ebf\u7ea6\u675f\uff0c\u6211\u4eec\u501f\u52a9\u4e24\u4e2a\u6570\u7ec4\u6765\u5206\u522b\u8bb0\u5f55\u8be5\u4e3b\u3001\u526f\u5bf9\u89d2\u7ebf\u662f\u5426\u5b58\u5728\u7687\u540e\uff1b\u96be\u70b9\u5728\u4e8e\u627e\u5904\u5728\u5230\u540c\u4e00\u4e3b\uff08\u526f\uff09\u5bf9\u89d2\u7ebf\u4e0a\u683c\u5b50\u6ee1\u8db3\u7684\u884c\u5217\u7d22\u5f15\u89c4\u5f8b\u3002
    "},{"location":"chapter_computational_complexity/","title":"2. \u00a0 \u590d\u6742\u5ea6","text":""},{"location":"chapter_computational_complexity/performance_evaluation/","title":"2.1. \u00a0 \u7b97\u6cd5\u6548\u7387\u8bc4\u4f30","text":""},{"location":"chapter_computational_complexity/performance_evaluation/#211","title":"2.1.1. \u00a0 \u7b97\u6cd5\u8bc4\u4ef7\u7ef4\u5ea6","text":"

    \u4ece\u603b\u4f53\u4e0a\u770b\uff0c\u7b97\u6cd5\u8bbe\u8ba1\u8ffd\u6c42\u4ee5\u4e0b\u4e24\u4e2a\u5c42\u9762\u7684\u76ee\u6807\uff1a

    1. \u627e\u5230\u95ee\u9898\u89e3\u6cd5\u3002\u7b97\u6cd5\u9700\u8981\u5728\u89c4\u5b9a\u7684\u8f93\u5165\u8303\u56f4\u5185\uff0c\u53ef\u9760\u5730\u6c42\u5f97\u95ee\u9898\u7684\u6b63\u786e\u89e3\u3002
    2. \u5bfb\u6c42\u6700\u4f18\u89e3\u6cd5\u3002\u540c\u4e00\u4e2a\u95ee\u9898\u53ef\u80fd\u5b58\u5728\u591a\u79cd\u89e3\u6cd5\uff0c\u6211\u4eec\u5e0c\u671b\u627e\u5230\u5c3d\u53ef\u80fd\u9ad8\u6548\u7684\u7b97\u6cd5\u3002

    \u56e0\u6b64\uff0c\u5728\u80fd\u591f\u89e3\u51b3\u95ee\u9898\u7684\u524d\u63d0\u4e0b\uff0c\u7b97\u6cd5\u6548\u7387\u6210\u4e3a\u4e3b\u8981\u7684\u8bc4\u4ef7\u7ef4\u5ea6\uff0c\u4e3b\u8981\u5305\u62ec\uff1a

    • \u65f6\u95f4\u6548\u7387\uff0c\u5373\u7b97\u6cd5\u8fd0\u884c\u901f\u5ea6\u7684\u5feb\u6162\u3002
    • \u7a7a\u95f4\u6548\u7387\uff0c\u5373\u7b97\u6cd5\u5360\u7528\u5185\u5b58\u7a7a\u95f4\u7684\u5927\u5c0f\u3002

    \u7b80\u800c\u8a00\u4e4b\uff0c\u6211\u4eec\u7684\u76ee\u6807\u662f\u8bbe\u8ba1\u201c\u65e2\u5feb\u53c8\u7701\u201d\u7684\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u3002\u638c\u63e1\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\u7684\u65b9\u6cd5\u5219\u81f3\u5173\u91cd\u8981\uff0c\u56e0\u4e3a\u53ea\u6709\u4e86\u89e3\u8bc4\u4ef7\u6807\u51c6\uff0c\u6211\u4eec\u624d\u80fd\u8fdb\u884c\u7b97\u6cd5\u4e4b\u95f4\u7684\u5bf9\u6bd4\u5206\u6790\uff0c\u4ece\u800c\u6307\u5bfc\u7b97\u6cd5\u8bbe\u8ba1\u4e0e\u4f18\u5316\u8fc7\u7a0b\u3002

    "},{"location":"chapter_computational_complexity/performance_evaluation/#212","title":"2.1.2. \u00a0 \u6548\u7387\u8bc4\u4f30\u65b9\u6cd5","text":""},{"location":"chapter_computational_complexity/performance_evaluation/#_1","title":"\u5b9e\u9645\u6d4b\u8bd5","text":"

    \u5047\u8bbe\u6211\u4eec\u73b0\u5728\u6709\u7b97\u6cd5 A \u548c\u7b97\u6cd5 B\uff0c\u5b83\u4eec\u90fd\u80fd\u89e3\u51b3\u540c\u4e00\u95ee\u9898\uff0c\u73b0\u5728\u9700\u8981\u5bf9\u6bd4\u8fd9\u4e24\u4e2a\u7b97\u6cd5\u7684\u6548\u7387\u3002\u6211\u4eec\u6700\u76f4\u63a5\u7684\u65b9\u6cd5\u5c31\u662f\u627e\u4e00\u53f0\u8ba1\u7b97\u673a\uff0c\u8fd0\u884c\u8fd9\u4e24\u4e2a\u7b97\u6cd5\uff0c\u5e76\u76d1\u63a7\u8bb0\u5f55\u5b83\u4eec\u7684\u8fd0\u884c\u65f6\u95f4\u548c\u5185\u5b58\u5360\u7528\u60c5\u51b5\u3002\u8fd9\u79cd\u8bc4\u4f30\u65b9\u5f0f\u80fd\u591f\u53cd\u6620\u771f\u5b9e\u60c5\u51b5\uff0c\u4f46\u4e5f\u5b58\u5728\u8f83\u5927\u5c40\u9650\u6027\u3002

    \u96be\u4ee5\u6392\u9664\u6d4b\u8bd5\u73af\u5883\u7684\u5e72\u6270\u56e0\u7d20\u3002\u786c\u4ef6\u914d\u7f6e\u4f1a\u5f71\u54cd\u7b97\u6cd5\u7684\u6027\u80fd\u8868\u73b0\u3002\u4f8b\u5982\uff0c\u5728\u67d0\u53f0\u8ba1\u7b97\u673a\u4e2d\uff0c\u7b97\u6cd5 A \u7684\u8fd0\u884c\u65f6\u95f4\u6bd4\u7b97\u6cd5 B \u77ed\uff1b\u4f46\u5728\u53e6\u4e00\u53f0\u914d\u7f6e\u4e0d\u540c\u7684\u8ba1\u7b97\u673a\u4e2d\uff0c\u6211\u4eec\u53ef\u80fd\u5f97\u5230\u76f8\u53cd\u7684\u6d4b\u8bd5\u7ed3\u679c\u3002\u8fd9\u610f\u5473\u7740\u6211\u4eec\u9700\u8981\u5728\u5404\u79cd\u673a\u5668\u4e0a\u8fdb\u884c\u6d4b\u8bd5\uff0c\u800c\u8fd9\u662f\u4e0d\u73b0\u5b9e\u7684\u3002

    \u5c55\u5f00\u5b8c\u6574\u6d4b\u8bd5\u975e\u5e38\u8017\u8d39\u8d44\u6e90\u3002\u968f\u7740\u8f93\u5165\u6570\u636e\u91cf\u7684\u53d8\u5316\uff0c\u7b97\u6cd5\u4f1a\u8868\u73b0\u51fa\u4e0d\u540c\u7684\u6548\u7387\u3002\u4f8b\u5982\uff0c\u8f93\u5165\u6570\u636e\u91cf\u8f83\u5c0f\u65f6\uff0c\u7b97\u6cd5 A \u7684\u8fd0\u884c\u65f6\u95f4\u53ef\u80fd\u77ed\u4e8e\u7b97\u6cd5 B\uff1b\u800c\u8f93\u5165\u6570\u636e\u91cf\u8f83\u5927\u65f6\uff0c\u6d4b\u8bd5\u7ed3\u679c\u53ef\u80fd\u76f8\u53cd\u3002\u56e0\u6b64\uff0c\u4e3a\u4e86\u5f97\u5230\u6709\u8bf4\u670d\u529b\u7684\u7ed3\u8bba\uff0c\u6211\u4eec\u9700\u8981\u6d4b\u8bd5\u5404\u79cd\u89c4\u6a21\u7684\u8f93\u5165\u6570\u636e\uff0c\u8fd9\u6837\u9700\u8981\u5360\u7528\u5927\u91cf\u7684\u8ba1\u7b97\u8d44\u6e90\u3002

    "},{"location":"chapter_computational_complexity/performance_evaluation/#_2","title":"\u7406\u8bba\u4f30\u7b97","text":"

    \u7531\u4e8e\u5b9e\u9645\u6d4b\u8bd5\u5177\u6709\u8f83\u5927\u7684\u5c40\u9650\u6027\uff0c\u6211\u4eec\u53ef\u4ee5\u8003\u8651\u4ec5\u901a\u8fc7\u4e00\u4e9b\u8ba1\u7b97\u6765\u8bc4\u4f30\u7b97\u6cd5\u7684\u6548\u7387\u3002\u8fd9\u79cd\u4f30\u7b97\u65b9\u6cd5\u88ab\u79f0\u4e3a\u300c\u590d\u6742\u5ea6\u5206\u6790 Complexity Analysis\u300d\u6216\u300c\u6e10\u8fd1\u590d\u6742\u5ea6\u5206\u6790 Asymptotic Complexity Analysis\u300d\u3002

    \u590d\u6742\u5ea6\u5206\u6790\u8bc4\u4f30\u7684\u662f\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u968f\u7740\u8f93\u5165\u6570\u636e\u91cf\u589e\u591a\u65f6\u7684\u589e\u957f\u8d8b\u52bf\u3002\u8fd9\u4e2a\u5b9a\u4e49\u6709\u4e9b\u62d7\u53e3\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5176\u5206\u4e3a\u4e09\u4e2a\u91cd\u70b9\u6765\u7406\u89e3\uff1a

    • \u201c\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u201d\u53ef\u5206\u4e3a\u201c\u8fd0\u884c\u65f6\u95f4\u201d\u548c\u201c\u5360\u7528\u7a7a\u95f4\u201d\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u5c06\u590d\u6742\u5ea6\u5206\u4e3a\u300c\u65f6\u95f4\u590d\u6742\u5ea6 Time Complexity\u300d\u548c\u300c\u7a7a\u95f4\u590d\u6742\u5ea6 Space Complexity\u300d\uff1b
    • \u201c\u968f\u7740\u8f93\u5165\u6570\u636e\u91cf\u589e\u591a\u65f6\u201d\u8868\u793a\u590d\u6742\u5ea6\u4e0e\u8f93\u5165\u6570\u636e\u91cf\u6709\u5173\uff0c\u53cd\u6620\u4e86\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u4e0e\u8f93\u5165\u6570\u636e\u91cf\u4e4b\u95f4\u7684\u5173\u7cfb\uff1b
    • \u201c\u589e\u957f\u8d8b\u52bf\u201d\u8868\u793a\u590d\u6742\u5ea6\u5206\u6790\u5173\u6ce8\u7684\u662f\u7b97\u6cd5\u65f6\u95f4\u4e0e\u7a7a\u95f4\u7684\u589e\u957f\u8d8b\u52bf\uff0c\u800c\u975e\u5177\u4f53\u7684\u8fd0\u884c\u65f6\u95f4\u6216\u5360\u7528\u7a7a\u95f4\uff1b

    \u590d\u6742\u5ea6\u5206\u6790\u514b\u670d\u4e86\u5b9e\u9645\u6d4b\u8bd5\u65b9\u6cd5\u7684\u5f0a\u7aef\u3002\u9996\u5148\uff0c\u5b83\u72ec\u7acb\u4e8e\u6d4b\u8bd5\u73af\u5883\uff0c\u56e0\u6b64\u5206\u6790\u7ed3\u679c\u9002\u7528\u4e8e\u6240\u6709\u8fd0\u884c\u5e73\u53f0\u3002\u5176\u6b21\uff0c\u5b83\u53ef\u4ee5\u4f53\u73b0\u4e0d\u540c\u6570\u636e\u91cf\u4e0b\u7684\u7b97\u6cd5\u6548\u7387\uff0c\u5c24\u5176\u662f\u5728\u5927\u6570\u636e\u91cf\u4e0b\u7684\u7b97\u6cd5\u6027\u80fd\u3002

    \u5982\u679c\u4f60\u5bf9\u590d\u6742\u5ea6\u5206\u6790\u7684\u6982\u5ff5\u4ecd\u611f\u5230\u56f0\u60d1\uff0c\u65e0\u9700\u62c5\u5fc3\uff0c\u6211\u4eec\u4f1a\u5728\u540e\u7eed\u7ae0\u8282\u8be6\u7ec6\u4ecb\u7ecd\u3002

    "},{"location":"chapter_computational_complexity/performance_evaluation/#213","title":"2.1.3. \u00a0 \u590d\u6742\u5ea6\u5206\u6790\u91cd\u8981\u6027","text":"

    \u590d\u6742\u5ea6\u5206\u6790\u4e3a\u6211\u4eec\u63d0\u4f9b\u4e86\u4e00\u628a\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\u7684\u201c\u6807\u5c3a\u201d\uff0c\u544a\u8bc9\u6211\u4eec\u6267\u884c\u67d0\u4e2a\u7b97\u6cd5\u6240\u9700\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u8d44\u6e90\uff0c\u5e76\u4f7f\u6211\u4eec\u80fd\u591f\u5bf9\u6bd4\u4e0d\u540c\u7b97\u6cd5\u4e4b\u95f4\u7684\u6548\u7387\u3002

    \u590d\u6742\u5ea6\u662f\u4e2a\u6570\u5b66\u6982\u5ff5\uff0c\u5bf9\u4e8e\u521d\u5b66\u8005\u53ef\u80fd\u6bd4\u8f83\u62bd\u8c61\uff0c\u5b66\u4e60\u96be\u5ea6\u76f8\u5bf9\u8f83\u9ad8\u3002\u4ece\u8fd9\u4e2a\u89d2\u5ea6\u770b\uff0c\u590d\u6742\u5ea6\u5206\u6790\u53ef\u80fd\u4e0d\u592a\u9002\u5408\u4f5c\u4e3a\u7b2c\u4e00\u7ae0\u7684\u5185\u5bb9\u3002\u7136\u800c\uff0c\u5f53\u6211\u4eec\u8ba8\u8bba\u67d0\u4e2a\u6570\u636e\u7ed3\u6784\u6216\u7b97\u6cd5\u7684\u7279\u70b9\u65f6\uff0c\u6211\u4eec\u96be\u4ee5\u907f\u514d\u8981\u5206\u6790\u5176\u8fd0\u884c\u901f\u5ea6\u548c\u7a7a\u95f4\u4f7f\u7528\u60c5\u51b5\u3002\u56e0\u6b64\uff0c\u5728\u6df1\u5165\u5b66\u4e60\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u4e4b\u524d\uff0c\u5efa\u8bae\u8bfb\u8005\u5148\u5bf9\u590d\u6742\u5ea6\u5efa\u7acb\u521d\u6b65\u7684\u4e86\u89e3\uff0c\u5e76\u80fd\u591f\u5b8c\u6210\u7b80\u5355\u6848\u4f8b\u7684\u590d\u6742\u5ea6\u5206\u6790\u3002

    "},{"location":"chapter_computational_complexity/space_complexity/","title":"2.3. \u00a0 \u7a7a\u95f4\u590d\u6742\u5ea6","text":"

    \u300c\u7a7a\u95f4\u590d\u6742\u5ea6 Space Complexity\u300d\u7528\u4e8e\u8861\u91cf\u7b97\u6cd5\u4f7f\u7528\u5185\u5b58\u7a7a\u95f4\u968f\u7740\u6570\u636e\u91cf\u53d8\u5927\u65f6\u7684\u589e\u957f\u8d8b\u52bf\u3002\u8fd9\u4e2a\u6982\u5ff5\u4e0e\u65f6\u95f4\u590d\u6742\u5ea6\u975e\u5e38\u7c7b\u4f3c\u3002

    "},{"location":"chapter_computational_complexity/space_complexity/#231","title":"2.3.1. \u00a0 \u7b97\u6cd5\u76f8\u5173\u7a7a\u95f4","text":"

    \u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u4f7f\u7528\u7684\u5185\u5b58\u7a7a\u95f4\u4e3b\u8981\u5305\u62ec\u4ee5\u4e0b\u51e0\u79cd\uff1a

    • \u300c\u8f93\u5165\u7a7a\u95f4\u300d\u7528\u4e8e\u5b58\u50a8\u7b97\u6cd5\u7684\u8f93\u5165\u6570\u636e\uff1b
    • \u300c\u6682\u5b58\u7a7a\u95f4\u300d\u7528\u4e8e\u5b58\u50a8\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u53d8\u91cf\u3001\u5bf9\u8c61\u3001\u51fd\u6570\u4e0a\u4e0b\u6587\u7b49\u6570\u636e\uff1b
    • \u300c\u8f93\u51fa\u7a7a\u95f4\u300d\u7528\u4e8e\u5b58\u50a8\u7b97\u6cd5\u7684\u8f93\u51fa\u6570\u636e\uff1b

    \u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u7edf\u8ba1\u8303\u56f4\u662f\u300c\u6682\u5b58\u7a7a\u95f4\u300d+\u300c\u8f93\u51fa\u7a7a\u95f4\u300d\u3002

    \u6682\u5b58\u7a7a\u95f4\u53ef\u4ee5\u8fdb\u4e00\u6b65\u5212\u5206\u4e3a\u4e09\u4e2a\u90e8\u5206\uff1a

    • \u300c\u6682\u5b58\u6570\u636e\u300d\u7528\u4e8e\u4fdd\u5b58\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u5404\u79cd\u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u7b49\u3002
    • \u300c\u6808\u5e27\u7a7a\u95f4\u300d\u7528\u4e8e\u4fdd\u5b58\u8c03\u7528\u51fd\u6570\u7684\u4e0a\u4e0b\u6587\u6570\u636e\u3002\u7cfb\u7edf\u5728\u6bcf\u6b21\u8c03\u7528\u51fd\u6570\u65f6\u90fd\u4f1a\u5728\u6808\u9876\u90e8\u521b\u5efa\u4e00\u4e2a\u6808\u5e27\uff0c\u51fd\u6570\u8fd4\u56de\u540e\uff0c\u6808\u5e27\u7a7a\u95f4\u4f1a\u88ab\u91ca\u653e\u3002
    • \u300c\u6307\u4ee4\u7a7a\u95f4\u300d\u7528\u4e8e\u4fdd\u5b58\u7f16\u8bd1\u540e\u7684\u7a0b\u5e8f\u6307\u4ee4\uff0c\u5728\u5b9e\u9645\u7edf\u8ba1\u4e2d\u901a\u5e38\u5ffd\u7565\u4e0d\u8ba1\u3002

    \u56e0\u6b64\uff0c\u5728\u5206\u6790\u4e00\u6bb5\u7a0b\u5e8f\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u65f6\uff0c\u6211\u4eec\u4e00\u822c\u7edf\u8ba1 \u6682\u5b58\u6570\u636e\u3001\u8f93\u51fa\u6570\u636e\u3001\u6808\u5e27\u7a7a\u95f4 \u4e09\u90e8\u5206\u3002

    Fig. \u7b97\u6cd5\u4f7f\u7528\u7684\u76f8\u5173\u7a7a\u95f4

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u7c7b */\nclass Node {\nint val;\nNode next;\nNode(int x) { val = x; }\n}\n/* \u51fd\u6570 */\nint function() {\n// do something...\nreturn 0;\n}\nint algorithm(int n) {        // \u8f93\u5165\u6570\u636e\nfinal int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nint b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nNode node = new Node(0);  // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nint c = function();       // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7ed3\u6784\u4f53 */\nstruct Node {\nint val;\nNode *next;\nNode(int x) : val(x), next(nullptr) {}\n};\n/* \u51fd\u6570 */\nint func() {\n// do something...\nreturn 0;\n}\nint algorithm(int n) {        // \u8f93\u5165\u6570\u636e\nconst int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nint b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nNode* node = new Node(0); // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nint c = func();           // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    class Node:\n\"\"\"\u7c7b\"\"\"\ndef __init__(self, x: int):\nself.val: int = x                 # \u8282\u70b9\u503c\nself.next: Optional[Node] = None  # \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\uff08\u5f15\u7528\uff09\ndef function() -> int:\n\"\"\"\u51fd\u6570\"\"\"\n# do something...\nreturn 0\ndef algorithm(n) -> int:  # \u8f93\u5165\u6570\u636e\nA = 0                 # \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff0c\u4e00\u822c\u7528\u5927\u5199\u5b57\u6bcd\u8868\u793a\uff09\nb = 0                 # \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nnode = Node(0)        # \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nc = function()        # \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn A + b + c      # \u8f93\u51fa\u6570\u636e\n
    /* \u7ed3\u6784\u4f53 */\ntype node struct {\nval  int\nnext *node\n}\n/* \u521b\u5efa node \u7ed3\u6784\u4f53  */\nfunc newNode(val int) *node {\nreturn &node{val: val}\n}\n/* \u51fd\u6570 */\nfunc function() int {\n// do something...\nreturn 0\n}\nfunc algorithm(n int) int { // \u8f93\u5165\u6570\u636e\nconst a = 0             // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nb := 0                  // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nnewNode(0)              // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nc := function()         // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c        // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\nval;\nnext;\nconstructor(val) {\nthis.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\nthis.next = null;                       // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n}\n}\n/* \u51fd\u6570 */\nfunction constFunc() {\n// do something\nreturn 0;\n}\nfunction algorithm(n) {       // \u8f93\u5165\u6570\u636e\nconst a = 0;              // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nlet b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nconst node = new Node(0); // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nconst c = constFunc();    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\nval: number;\nnext: Node | null;\nconstructor(val?: number) {\nthis.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\nthis.next = null;                       // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n}\n}\n/* \u51fd\u6570 */\nfunction constFunc(): number {\n// do something\nreturn 0;\n}\nfunction algorithm(n: number): number { // \u8f93\u5165\u6570\u636e\nconst a = 0;                        // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nlet b = 0;                          // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nconst node = new Node(0);           // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nconst c = constFunc();              // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;                   // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u51fd\u6570 */\nint func() {\n// do something...\nreturn 0;\n}\nint algorithm(int n) { // \u8f93\u5165\u6570\u636e\nconst int a = 0;   // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nint b = 0;         // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nint c = func();    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;  // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node\n{\nint val;\nNode next;\nNode(int x) { val = x; }\n}\n/* \u51fd\u6570 */\nint function()\n{\n// do something...\nreturn 0;\n}\nint algorithm(int n)          // \u8f93\u5165\u6570\u636e\n{\nconst int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nint b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nNode node = new Node(0);  // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nint c = function();       // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\nvar val: Int\nvar next: Node?\ninit(x: Int) {\nval = x\n}\n}\n/* \u51fd\u6570 */\nfunc function() -> Int {\n// do something...\nreturn 0\n}\nfunc algorithm(n: Int) -> Int { // \u8f93\u5165\u6570\u636e\nlet a = 0             // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nvar b = 0             // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nlet node = Node(x: 0) // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nlet c = function()    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c      // \u8f93\u51fa\u6570\u636e\n}\n
    \n
    /* \u7c7b */\nclass Node {\nint val;\nNode next;\nNode(this.val, [this.next]);\n}\n/* \u51fd\u6570 */\nint function() {\n// do something...\nreturn 0;\n}\nint algorithm(int n) {  // \u8f93\u5165\u6570\u636e\nconst int a = 0;      // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\nint b = 0;            // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\nNode node = Node(0);  // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\nint c = function();   // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\nreturn a + b + c;     // \u8f93\u51fa\u6570\u636e\n}\n
    "},{"location":"chapter_computational_complexity/space_complexity/#232","title":"2.3.2. \u00a0 \u63a8\u7b97\u65b9\u6cd5","text":"

    \u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u63a8\u7b97\u65b9\u6cd5\u4e0e\u65f6\u95f4\u590d\u6742\u5ea6\u5927\u81f4\u76f8\u540c\uff0c\u53ea\u662f\u5c06\u7edf\u8ba1\u5bf9\u8c61\u4ece\u201c\u8ba1\u7b97\u64cd\u4f5c\u6570\u91cf\u201d\u8f6c\u4e3a\u201c\u4f7f\u7528\u7a7a\u95f4\u5927\u5c0f\u201d\u3002\u4e0e\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u540c\u7684\u662f\uff0c\u6211\u4eec\u901a\u5e38\u53ea\u5173\u6ce8\u300c\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u300d\uff0c\u8fd9\u662f\u56e0\u4e3a\u5185\u5b58\u7a7a\u95f4\u662f\u4e00\u9879\u786c\u6027\u8981\u6c42\uff0c\u6211\u4eec\u5fc5\u987b\u786e\u4fdd\u5728\u6240\u6709\u8f93\u5165\u6570\u636e\u4e0b\u90fd\u6709\u8db3\u591f\u7684\u5185\u5b58\u7a7a\u95f4\u9884\u7559\u3002

    \u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e2d\u7684\u201c\u6700\u5dee\u201d\u6709\u4e24\u5c42\u542b\u4e49\uff0c\u5206\u522b\u662f\u8f93\u5165\u6570\u636e\u7684\u6700\u5dee\u5206\u5e03\u548c\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u6700\u5dee\u65f6\u95f4\u70b9\u3002

    • \u4ee5\u6700\u5dee\u8f93\u5165\u6570\u636e\u4e3a\u51c6\u3002\u5f53 \\(n < 10\\) \u65f6\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \uff1b\u4f46\u5f53 \\(n > 10\\) \u65f6\uff0c\u521d\u59cb\u5316\u7684\u6570\u7ec4 nums \u5360\u7528 \\(O(n)\\) \u7a7a\u95f4\uff1b\u56e0\u6b64\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff1b
    • \u4ee5\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u5cf0\u503c\u5185\u5b58\u4e3a\u51c6\u3002\u4f8b\u5982\uff0c\u7a0b\u5e8f\u5728\u6267\u884c\u6700\u540e\u4e00\u884c\u4e4b\u524d\uff0c\u5360\u7528 \\(O(1)\\) \u7a7a\u95f4\uff1b\u5f53\u521d\u59cb\u5316\u6570\u7ec4 nums \u65f6\uff0c\u7a0b\u5e8f\u5360\u7528 \\(O(n)\\) \u7a7a\u95f4\uff1b\u56e0\u6b64\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff1b
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    void algorithm(int n) {\nint a = 0;                   // O(1)\nint[] b = new int[10000];    // O(1)\nif (n > 10)\nint[] nums = new int[n]; // O(n)\n}\n
    void algorithm(int n) {\nint a = 0;               // O(1)\nvector<int> b(10000);    // O(1)\nif (n > 10)\nvector<int> nums(n); // O(n)\n}\n
    def algorithm(n: int) -> None:\na = 0               # O(1)\nb = [0] * 10000     # O(1)\nif n > 10:\nnums = [0] * n  # O(n)\n
    func algorithm(n int) {\na := 0                      // O(1)\nb := make([]int, 10000)     // O(1)\nvar nums []int\nif n > 10 {\nnums := make([]int, n)  // O(n)\n}\nfmt.Println(a, b, nums)\n}\n
    function algorithm(n) {\nconst a = 0;                   // O(1)\nconst b = new Array(10000);    // O(1)\nif (n > 10) {\nconst nums = new Array(n); // O(n)\n}\n}\n
    function algorithm(n: number): void {\nconst a = 0;                   // O(1)\nconst b = new Array(10000);    // O(1)\nif (n > 10) {\nconst nums = new Array(n); // O(n)\n}\n}\n
    void algorithm(int n) {\nint a = 0;               // O(1)\nint b[10000];            // O(1)\nif (n > 10)\nvector<int> nums(n); // O(n)\n}\n
    void algorithm(int n)\n{\nint a = 0;                   // O(1)\nint[] b = new int[10000];    // O(1)\nif (n > 10)\n{\nint[] nums = new int[n]; // O(n)\n}\n}\n
    func algorithm(n: Int) {\nlet a = 0 // O(1)\nlet b = Array(repeating: 0, count: 10000) // O(1)\nif n > 10 {\nlet nums = Array(repeating: 0, count: n) // O(n)\n}\n}\n
    \n
    void algorithm(int n) {\nint a = 0;                            // O(1)\nList<int> b = List.filled(10000, 0);  // O(1)\nif (n > 10) {\nList<int> nums = List.filled(n, 0); // O(n)\n}\n}\n

    \u5728\u9012\u5f52\u51fd\u6570\u4e2d\uff0c\u9700\u8981\u6ce8\u610f\u7edf\u8ba1\u6808\u5e27\u7a7a\u95f4\u3002\u4f8b\u5982\uff0c\u51fd\u6570 loop() \u5728\u5faa\u73af\u4e2d\u8c03\u7528\u4e86 \\(n\\) \u6b21 function() \uff0c\u6bcf\u8f6e\u4e2d\u7684 function() \u90fd\u8fd4\u56de\u5e76\u91ca\u653e\u4e86\u6808\u5e27\u7a7a\u95f4\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(1)\\) \u3002\u800c\u9012\u5f52\u51fd\u6570 recur() \u5728\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u4f1a\u540c\u65f6\u5b58\u5728 \\(n\\) \u4e2a\u672a\u8fd4\u56de\u7684 recur() \uff0c\u4ece\u800c\u5360\u7528 \\(O(n)\\) \u7684\u6808\u5e27\u7a7a\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    int function() {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\nfor (int i = 0; i < n; i++) {\nfunction();\n}\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\nif (n == 1) return;\nreturn recur(n - 1);\n}\n
    int func() {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\nfor (int i = 0; i < n; i++) {\nfunc();\n}\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\nif (n == 1) return;\nreturn recur(n - 1);\n}\n
    def function() -> int:\n# do something\nreturn 0\ndef loop(n: int) -> None:\n\"\"\"\u5faa\u73af O(1)\"\"\"\nfor _ in range(n):\nfunction()\ndef recur(n: int) -> int:\n\"\"\"\u9012\u5f52 O(n)\"\"\"\nif n == 1: return\nreturn recur(n - 1)\n
    func function() int {\n// do something\nreturn 0\n}\n/* \u5faa\u73af O(1) */\nfunc loop(n int) {\nfor i := 0; i < n; i++ {\nfunction()\n}\n}\n/* \u9012\u5f52 O(n) */\nfunc recur(n int) {\nif n == 1 {\nreturn\n}\nrecur(n - 1)\n}\n
    function constFunc() {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nfunction loop(n) {\nfor (let i = 0; i < n; i++) {\nconstFunc();\n}\n}\n/* \u9012\u5f52 O(n) */\nfunction recur(n) {\nif (n === 1) return;\nreturn recur(n - 1);\n}\n
    function constFunc(): number {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nfunction loop(n: number): void {\nfor (let i = 0; i < n; i++) {\nconstFunc();\n}\n}\n/* \u9012\u5f52 O(n) */\nfunction recur(n: number): void {\nif (n === 1) return;\nreturn recur(n - 1);\n}\n
    int func() {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\nfor (int i = 0; i < n; i++) {\nfunc();\n}\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\nif (n == 1) return;\nreturn recur(n - 1);\n}\n
    int function()\n{\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n)\n{\nfor (int i = 0; i < n; i++)\n{\nfunction();\n}\n}\n/* \u9012\u5f52 O(n) */\nint recur(int n)\n{\nif (n == 1) return 1;\nreturn recur(n - 1);\n}\n
    @discardableResult\nfunc function() -> Int {\n// do something\nreturn 0\n}\n/* \u5faa\u73af O(1) */\nfunc loop(n: Int) {\nfor _ in 0 ..< n {\nfunction()\n}\n}\n/* \u9012\u5f52 O(n) */\nfunc recur(n: Int) {\nif n == 1 {\nreturn\n}\nrecur(n: n - 1)\n}\n
    \n
    int function() {\n// do something\nreturn 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\nfor (int i = 0; i < n; i++) {\nfunction();\n}\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\nif (n == 1) return;\nreturn recur(n - 1);\n}\n
    "},{"location":"chapter_computational_complexity/space_complexity/#233","title":"2.3.3. \u00a0 \u5e38\u89c1\u7c7b\u578b","text":"

    \u8bbe\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u5e38\u89c1\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u7c7b\u578b\u6709\uff08\u4ece\u4f4e\u5230\u9ad8\u6392\u5217\uff09

    \\[ \\begin{aligned} O(1) < O(\\log n) < O(n) < O(n^2) < O(2^n) \\newline \\text{\u5e38\u6570\u9636} < \\text{\u5bf9\u6570\u9636} < \\text{\u7ebf\u6027\u9636} < \\text{\u5e73\u65b9\u9636} < \\text{\u6307\u6570\u9636} \\end{aligned} \\]

    Fig. \u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u5e38\u89c1\u7c7b\u578b

    Tip

    \u90e8\u5206\u793a\u4f8b\u4ee3\u7801\u9700\u8981\u4e00\u4e9b\u524d\u7f6e\u77e5\u8bc6\uff0c\u5305\u62ec\u6570\u7ec4\u3001\u94fe\u8868\u3001\u4e8c\u53c9\u6811\u3001\u9012\u5f52\u7b97\u6cd5\u7b49\u3002\u5982\u679c\u9047\u5230\u770b\u4e0d\u61c2\u7684\u5730\u65b9\u65e0\u9700\u62c5\u5fc3\uff0c\u53ef\u4ee5\u5728\u5b66\u4e60\u5b8c\u540e\u9762\u7ae0\u8282\u540e\u518d\u6765\u590d\u4e60\uff0c\u73b0\u9636\u6bb5\u6211\u4eec\u5148\u4e13\u6ce8\u4e8e\u7406\u89e3\u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u542b\u4e49\u548c\u63a8\u7b97\u65b9\u6cd5\u3002

    "},{"location":"chapter_computational_complexity/space_complexity/#o1","title":"\u5e38\u6570\u9636 \\(O(1)\\)","text":"

    \u5e38\u6570\u9636\u5e38\u89c1\u4e8e\u6570\u91cf\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u65e0\u5173\u7684\u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u3002

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u5728\u5faa\u73af\u4e2d\u521d\u59cb\u5316\u53d8\u91cf\u6216\u8c03\u7528\u51fd\u6570\u800c\u5360\u7528\u7684\u5185\u5b58\uff0c\u5728\u8fdb\u5165\u4e0b\u4e00\u5faa\u73af\u540e\u5c31\u4f1a\u88ab\u91ca\u653e\uff0c\u5373\u4e0d\u4f1a\u7d2f\u79ef\u5360\u7528\u7a7a\u95f4\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(1)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nfinal int a = 0;\nint b = 0;\nint[] nums = new int[10000];\nListNode node = new ListNode(0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nint c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nfunction();\n}\n}\n
    space_complexity.cpp
    /* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst int a = 0;\nint b = 0;\nvector<int> nums(10000);\nListNode node(0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nint c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nfunc();\n}\n}\n
    space_complexity.py
    def constant(n: int) -> None:\n\"\"\"\u5e38\u6570\u9636\"\"\"\n# \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\na = 0\nnums = [0] * 10000\nnode = ListNode(0)\n# \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor _ in range(n):\nc = 0\n# \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor _ in range(n):\nfunction()\n
    space_complexity.go
    /* \u5e38\u6570\u9636 */\nfunc spaceConstant(n int) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst a = 0\nb := 0\nnums := make([]int, 10000)\nListNode := newNode(0)\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nvar c int\nfor i := 0; i < n; i++ {\nc = 0\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor i := 0; i < n; i++ {\nfunction()\n}\nfmt.Println(a, b, nums, c, ListNode)\n}\n
    space_complexity.js
    /* \u5e38\u6570\u9636 */\nfunction constant(n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst a = 0;\nconst b = 0;\nconst nums = new Array(10000);\nconst node = new ListNode(0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (let i = 0; i < n; i++) {\nconst c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (let i = 0; i < n; i++) {\nconstFunc();\n}\n}\n
    space_complexity.ts
    /* \u5e38\u6570\u9636 */\nfunction constant(n: number): void {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst a = 0;\nconst b = 0;\nconst nums = new Array(10000);\nconst node = new ListNode(0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (let i = 0; i < n; i++) {\nconst c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (let i = 0; i < n; i++) {\nconstFunc();\n}\n}\n
    space_complexity.c
    /* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst int a = 0;\nint b = 0;\nint nums[1000];\nListNode *node = newListNode(0);\nfree(node);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nint c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nfunc();\n}\n}\n
    space_complexity.cs
    /* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nint a = 0;\nint b = 0;\nint[] nums = new int[10000];\nListNode node = new ListNode(0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nint c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (int i = 0; i < n; i++) {\nfunction();\n}\n}\n
    space_complexity.swift
    /* \u5e38\u6570\u9636 */\nfunc constant(n: Int) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nlet a = 0\nvar b = 0\nlet nums = Array(repeating: 0, count: 10000)\nlet node = ListNode(x: 0)\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor _ in 0 ..< n {\nlet c = 0\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor _ in 0 ..< n {\nfunction()\n}\n}\n
    space_complexity.zig
    // \u5e38\u6570\u9636\nfn constant(n: i32) void {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nconst a: i32 = 0;\nvar b: i32 = 0;\nvar nums = [_]i32{0}**10000;\nvar node = inc.ListNode(i32){.val = 0};\nvar i: i32 = 0;\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nwhile (i < n) : (i += 1) {\nvar c: i32 = 0;\n_ = c;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\ni = 0;\nwhile (i < n) : (i += 1) {\n_ = function();\n}\n_ = a;\n_ = b;\n_ = nums;\n_ = node;\n}\n
    space_complexity.dart
    /* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n// \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\nfinal int a = 0;\nint b = 0;\nList<int> nums = List.filled(10000, 0);\n// \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\nfor (var i = 0; i < n; i++) {\nint c = 0;\n}\n// \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\nfor (var i = 0; i < n; i++) {\nfunction();\n}\n}\n
    "},{"location":"chapter_computational_complexity/space_complexity/#on","title":"\u7ebf\u6027\u9636 \\(O(n)\\)","text":"

    \u7ebf\u6027\u9636\u5e38\u89c1\u4e8e\u5143\u7d20\u6570\u91cf\u4e0e \\(n\\) \u6210\u6b63\u6bd4\u7684\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\u7b49\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nint[] nums = new int[n];\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nList<ListNode> nodes = new ArrayList<>();\nfor (int i = 0; i < n; i++) {\nnodes.add(new ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nMap<Integer, String> map = new HashMap<>();\nfor (int i = 0; i < n; i++) {\nmap.put(i, String.valueOf(i));\n}\n}\n
    space_complexity.cpp
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nvector<int> nums(n);\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nvector<ListNode> nodes;\nfor (int i = 0; i < n; i++) {\nnodes.push_back(ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nunordered_map<int, string> map;\nfor (int i = 0; i < n; i++) {\nmap[i] = to_string(i);\n}\n}\n
    space_complexity.py
    def linear(n: int) -> None:\n\"\"\"\u7ebf\u6027\u9636\"\"\"\n# \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nnums = [0] * n\n# \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nmapp = dict[int, str]()\nfor i in range(n):\nmapp[i] = str(i)\n
    space_complexity.go
    /* \u7ebf\u6027\u9636 */\nfunc spaceLinear(n int) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n_ = make([]int, n)\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nvar nodes []*node\nfor i := 0; i < n; i++ {\nnodes = append(nodes, newNode(i))\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nm := make(map[int]string, n)\nfor i := 0; i < n; i++ {\nm[i] = strconv.Itoa(i)\n}\n}\n
    space_complexity.js
    /* \u7ebf\u6027\u9636 */\nfunction linear(n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nconst nums = new Array(n);\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nconst nodes = [];\nfor (let i = 0; i < n; i++) {\nnodes.push(new ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nconst map = new Map();\nfor (let i = 0; i < n; i++) {\nmap.set(i, i.toString());\n}\n}\n
    space_complexity.ts
    /* \u7ebf\u6027\u9636 */\nfunction linear(n: number): void {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nconst nums = new Array(n);\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nconst nodes: ListNode[] = [];\nfor (let i = 0; i < n; i++) {\nnodes.push(new ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nconst map = new Map();\nfor (let i = 0; i < n; i++) {\nmap.set(i, i.toString());\n}\n}\n
    space_complexity.c
    /* \u54c8\u5e0c\u8868 */\nstruct hashTable {\nint key;\nint val;\nUT_hash_handle hh; // \u57fa\u4e8e uthash.h \u5b9e\u73b0\n};\ntypedef struct hashTable hashTable;\n/* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nint *nums = malloc(sizeof(int) * n);\nfree(nums);\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nListNode **nodes = malloc(sizeof(ListNode *) * n);\nfor (int i = 0; i < n; i++) {\nnodes[i] = newListNode(i);\n}\n// \u5185\u5b58\u91ca\u653e\nfor (int i = 0; i < n; i++) {\nfree(nodes[i]);\n}\nfree(nodes);\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nhashTable *h = NULL;\nfor (int i = 0; i < n; i++) {\nhashTable *tmp = malloc(sizeof(hashTable));\ntmp->key = i;\ntmp->val = i;\nHASH_ADD_INT(h, key, tmp);\n}\n// \u5185\u5b58\u91ca\u653e\nhashTable *curr, *tmp;\nHASH_ITER(hh, h, curr, tmp) {\nHASH_DEL(h, curr);\nfree(curr);\n}\n}\n
    space_complexity.cs
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nint[] nums = new int[n];\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nList<ListNode> nodes = new();\nfor (int i = 0; i < n; i++) {\nnodes.Add(new ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nDictionary<int, string> map = new();\nfor (int i = 0; i < n; i++) {\nmap.Add(i, i.ToString());\n}\n}\n
    space_complexity.swift
    /* \u7ebf\u6027\u9636 */\nfunc linear(n: Int) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nlet nums = Array(repeating: 0, count: n)\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nlet nodes = (0 ..< n).map { ListNode(x: $0) }\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nlet map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, \"\\($0)\") })\n}\n
    space_complexity.zig
    // \u7ebf\u6027\u9636\nfn linear(comptime n: i32) !void {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nvar nums = [_]i32{0}**n;\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nvar nodes = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer nodes.deinit();\nvar i: i32 = 0;\nwhile (i < n) : (i += 1) {\ntry nodes.append(i);\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nvar map = std.AutoArrayHashMap(i32, []const u8).init(std.heap.page_allocator);\ndefer map.deinit();\nvar j: i32 = 0;\nwhile (j < n) : (j += 1) {\nconst string = try std.fmt.allocPrint(std.heap.page_allocator, \"{d}\", .{j});\ndefer std.heap.page_allocator.free(string);\ntry map.put(i, string);\n}\n_ = nums;\n}\n
    space_complexity.dart
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n// \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\nList<int> nums = List.filled(n, 0);\n// \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nList<ListNode> nodes = [];\nfor (var i = 0; i < n; i++) {\nnodes.add(ListNode(i));\n}\n// \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\nMap<int, String> map = HashMap();\nfor (var i = 0; i < n; i++) {\nmap.putIfAbsent(i, () => i.toString());\n}\n}\n

    \u4ee5\u4e0b\u9012\u5f52\u51fd\u6570\u4f1a\u540c\u65f6\u5b58\u5728 \\(n\\) \u4e2a\u672a\u8fd4\u56de\u7684 algorithm() \u51fd\u6570\uff0c\u4f7f\u7528 \\(O(n)\\) \u5927\u5c0f\u7684\u6808\u5e27\u7a7a\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\nSystem.out.println(\"\u9012\u5f52 n = \" + n);\nif (n == 1)\nreturn;\nlinearRecur(n - 1);\n}\n
    space_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\ncout << \"\u9012\u5f52 n = \" << n << endl;\nif (n == 1)\nreturn;\nlinearRecur(n - 1);\n}\n
    space_complexity.py
    def linear_recur(n: int) -> None:\n\"\"\"\u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\nprint(\"\u9012\u5f52 n =\", n)\nif n == 1:\nreturn\nlinear_recur(n - 1)\n
    space_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceLinearRecur(n int) {\nfmt.Println(\"\u9012\u5f52 n =\", n)\nif n == 1 {\nreturn\n}\nspaceLinearRecur(n - 1)\n}\n
    space_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n) {\nconsole.log(`\u9012\u5f52 n = ${n}`);\nif (n === 1) return;\nlinearRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n: number): void {\nconsole.log(`\u9012\u5f52 n = ${n}`);\nif (n === 1) return;\nlinearRecur(n - 1);\n}\n
    space_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\nprintf(\"\u9012\u5f52 n = %d\\r\\n\", n);\nif (n == 1)\nreturn;\nlinearRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\nConsole.WriteLine(\"\u9012\u5f52 n = \" + n);\nif (n == 1) return;\nlinearRecur(n - 1);\n}\n
    space_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc linearRecur(n: Int) {\nprint(\"\u9012\u5f52 n = \\(n)\")\nif n == 1 {\nreturn\n}\nlinearRecur(n: n - 1)\n}\n
    space_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn linearRecur(comptime n: i32) void {\nstd.debug.print(\"\u9012\u5f52 n = {}\\n\", .{n});\nif (n == 1) return;\nlinearRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\nprint('\u9012\u5f52 n = $n');\nif (n == 1) return;\nlinearRecur(n - 1);\n}\n

    Fig. \u9012\u5f52\u51fd\u6570\u4ea7\u751f\u7684\u7ebf\u6027\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/space_complexity/#on2","title":"\u5e73\u65b9\u9636 \\(O(n^2)\\)","text":"

    \u5e73\u65b9\u9636\u5e38\u89c1\u4e8e\u77e9\u9635\u548c\u56fe\uff0c\u5143\u7d20\u6570\u91cf\u4e0e \\(n\\) \u6210\u5e73\u65b9\u5173\u7cfb\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nint[][] numMatrix = new int[n][n];\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nList<List<Integer>> numList = new ArrayList<>();\nfor (int i = 0; i < n; i++) {\nList<Integer> tmp = new ArrayList<>();\nfor (int j = 0; j < n; j++) {\ntmp.add(0);\n}\nnumList.add(tmp);\n}\n}\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nvector<vector<int>> numMatrix;\nfor (int i = 0; i < n; i++) {\nvector<int> tmp;\nfor (int j = 0; j < n; j++) {\ntmp.push_back(0);\n}\nnumMatrix.push_back(tmp);\n}\n}\n
    space_complexity.py
    def quadratic(n: int) -> None:\n\"\"\"\u5e73\u65b9\u9636\"\"\"\n# \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nnum_matrix = [[0] * n for _ in range(n)]\n
    space_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc spaceQuadratic(n int) {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nnumMatrix := make([][]int, n)\nfor i := 0; i < n; i++ {\nnumMatrix[i] = make([]int, n)\n}\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nconst numMatrix = Array(n)\n.fill(null)\n.map(() => Array(n).fill(null));\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nconst numList = [];\nfor (let i = 0; i < n; i++) {\nconst tmp = [];\nfor (let j = 0; j < n; j++) {\ntmp.push(0);\n}\nnumList.push(tmp);\n}\n}\n
    space_complexity.ts
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n: number): void {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nconst numMatrix = Array(n)\n.fill(null)\n.map(() => Array(n).fill(null));\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nconst numList = [];\nfor (let i = 0; i < n; i++) {\nconst tmp = [];\nfor (let j = 0; j < n; j++) {\ntmp.push(0);\n}\nnumList.push(tmp);\n}\n}\n
    space_complexity.c
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nint **numMatrix = malloc(sizeof(int *) * n);\nfor (int i = 0; i < n; i++) {\nint *tmp = malloc(sizeof(int) * n);\nfor (int j = 0; j < n; j++) {\ntmp[j] = 0;\n}\nnumMatrix[i] = tmp;\n}\n// \u5185\u5b58\u91ca\u653e\nfor (int i = 0; i < n; i++) {\nfree(numMatrix[i]);\n}\nfree(numMatrix);\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nint[,] numMatrix = new int[n, n];\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nList<List<int>> numList = new();\nfor (int i = 0; i < n; i++) {\nList<int> tmp = new();\nfor (int j = 0; j < n; j++) {\ntmp.Add(0);\n}\nnumList.Add(tmp);\n}\n}\n
    space_complexity.swift
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n: Int) {\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nlet numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) !void {\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nvar nodes = std.ArrayList(std.ArrayList(i32)).init(std.heap.page_allocator);\ndefer nodes.deinit();\nvar i: i32 = 0;\nwhile (i < n) : (i += 1) {\nvar tmp = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer tmp.deinit();\nvar j: i32 = 0;\nwhile (j < n) : (j += 1) {\ntry tmp.append(0);\n}\ntry nodes.append(tmp);\n}\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n// \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\nList<List<int>> numMatrix = List.generate(n, (_) => List.filled(n, 0));\n// \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\nList<List<int>> numList = [];\nfor (var i = 0; i < n; i++) {\nList<int> tmp = [];\nfor (int j = 0; j < n; j++) {\ntmp.add(0);\n}\nnumList.add(tmp);\n}\n}\n

    \u5728\u4ee5\u4e0b\u9012\u5f52\u51fd\u6570\u4e2d\uff0c\u540c\u65f6\u5b58\u5728 \\(n\\) \u4e2a\u672a\u8fd4\u56de\u7684 algorithm() \uff0c\u5e76\u4e14\u6bcf\u4e2a\u51fd\u6570\u4e2d\u90fd\u521d\u59cb\u5316\u4e86\u4e00\u4e2a\u6570\u7ec4\uff0c\u957f\u5ea6\u5206\u522b\u4e3a \\(n, n-1, n-2, ..., 2, 1\\) \uff0c\u5e73\u5747\u957f\u5ea6\u4e3a \\(\\frac{n}{2}\\) \uff0c\u56e0\u6b64\u603b\u4f53\u5360\u7528 \\(O(n^2)\\) \u7a7a\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\nif (n <= 0)\nreturn 0;\n// \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\nint[] nums = new int[n];\nSystem.out.println(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.length);\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\nif (n <= 0)\nreturn 0;\nvector<int> nums(n);\ncout << \"\u9012\u5f52 n = \" << n << \" \u4e2d\u7684 nums \u957f\u5ea6 = \" << nums.size() << endl;\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.py
    def quadratic_recur(n: int) -> int:\n\"\"\"\u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\nif n <= 0:\nreturn 0\n# \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\nnums = [0] * n\nreturn quadratic_recur(n - 1)\n
    space_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceQuadraticRecur(n int) int {\nif n <= 0 {\nreturn 0\n}\nnums := make([]int, n)\nfmt.Printf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d \\n\", n, len(nums))\nreturn spaceQuadraticRecur(n - 1)\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n) {\nif (n <= 0) return 0;\nconst nums = new Array(n);\nconsole.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n: number): number {\nif (n <= 0) return 0;\nconst nums = new Array(n);\nconsole.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\nif (n <= 0)\nreturn 0;\nint *nums = malloc(sizeof(int) * n);\nprintf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d\\r\\n\", n, n);\nfree(nums);\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\nif (n <= 0) return 0;\nint[] nums = new int[n];\nConsole.WriteLine(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.Length);\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\n@discardableResult\nfunc quadraticRecur(n: Int) -> Int {\nif n <= 0 {\nreturn 0\n}\n// \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\nlet nums = Array(repeating: 0, count: n)\nprint(\"\u9012\u5f52 n = \\(n) \u4e2d\u7684 nums \u957f\u5ea6 = \\(nums.count)\")\nreturn quadraticRecur(n: n - 1)\n}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn quadraticRecur(comptime n: i32) i32 {\nif (n <= 0) return 0;\nvar nums = [_]i32{0}**n;\nstd.debug.print(\"\u9012\u5f52 n = {} \u4e2d\u7684 nums \u957f\u5ea6 = {}\\n\", .{n, nums.len});\nreturn quadraticRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\nif (n <= 0) return 0;\nList<int> nums = List.filled(n, 0);\nprint('\u9012\u5f52 n = $n \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}');\nreturn quadraticRecur(n - 1);\n}\n

    Fig. \u9012\u5f52\u51fd\u6570\u4ea7\u751f\u7684\u5e73\u65b9\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/space_complexity/#o2n","title":"\u6307\u6570\u9636 \\(O(2^n)\\)","text":"

    \u6307\u6570\u9636\u5e38\u89c1\u4e8e\u4e8c\u53c9\u6811\u3002\u9ad8\u5ea6\u4e3a \\(n\\) \u7684\u300c\u6ee1\u4e8c\u53c9\u6811\u300d\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\(2^n - 1\\) \uff0c\u5360\u7528 \\(O(2^n)\\) \u7a7a\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart space_complexity.java
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode buildTree(int n) {\nif (n == 0)\nreturn null;\nTreeNode root = new TreeNode(0);\nroot.left = buildTree(n - 1);\nroot.right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\nif (n == 0)\nreturn nullptr;\nTreeNode *root = new TreeNode(0);\nroot->left = buildTree(n - 1);\nroot->right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.py
    def build_tree(n: int) -> TreeNode | None:\n\"\"\"\u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09\"\"\"\nif n == 0:\nreturn None\nroot = TreeNode(0)\nroot.left = build_tree(n - 1)\nroot.right = build_tree(n - 1)\nreturn root\n
    space_complexity.go
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n int) *treeNode {\nif n == 0 {\nreturn nil\n}\nroot := newTreeNode(0)\nroot.left = buildTree(n - 1)\nroot.right = buildTree(n - 1)\nreturn root\n}\n
    space_complexity.js
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n) {\nif (n === 0) return null;\nconst root = new TreeNode(0);\nroot.left = buildTree(n - 1);\nroot.right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n: number): TreeNode | null {\nif (n === 0) return null;\nconst root = new TreeNode(0);\nroot.left = buildTree(n - 1);\nroot.right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.c
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\nif (n == 0)\nreturn NULL;\nTreeNode *root = newTreeNode(0);\nroot->left = buildTree(n - 1);\nroot->right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? buildTree(int n) {\nif (n == 0) return null;\nTreeNode root = new TreeNode(0);\nroot.left = buildTree(n - 1);\nroot.right = buildTree(n - 1);\nreturn root;\n}\n
    space_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n: Int) -> TreeNode? {\nif n == 0 {\nreturn nil\n}\nlet root = TreeNode(x: 0)\nroot.left = buildTree(n: n - 1)\nroot.right = buildTree(n: n - 1)\nreturn root\n}\n
    space_complexity.zig
    // \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09\nfn buildTree(mem_allocator: std.mem.Allocator, n: i32) !?*inc.TreeNode(i32) {\nif (n == 0) return null;\nconst root = try mem_allocator.create(inc.TreeNode(i32));\nroot.init(0);\nroot.left = try buildTree(mem_allocator, n - 1);\nroot.right = try buildTree(mem_allocator, n - 1);\nreturn root;\n}\n
    space_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? buildTree(int n) {\nif (n == 0) return null;\nTreeNode root = TreeNode(0);\nroot.left = buildTree(n - 1);\nroot.right = buildTree(n - 1);\nreturn root;\n}\n

    Fig. \u6ee1\u4e8c\u53c9\u6811\u4ea7\u751f\u7684\u6307\u6570\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/space_complexity/#olog-n","title":"\u5bf9\u6570\u9636 \\(O(\\log n)\\)","text":"

    \u5bf9\u6570\u9636\u5e38\u89c1\u4e8e\u5206\u6cbb\u7b97\u6cd5\u548c\u6570\u636e\u7c7b\u578b\u8f6c\u6362\u7b49\u3002

    \u4f8b\u5982\u201c\u5f52\u5e76\u6392\u5e8f\u201d\u7b97\u6cd5\uff0c\u8f93\u5165\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4\uff0c\u6bcf\u8f6e\u9012\u5f52\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5212\u5206\u4e3a\u4e24\u534a\uff0c\u5f62\u6210\u9ad8\u5ea6\u4e3a \\(\\log n\\) \u7684\u9012\u5f52\u6811\uff0c\u4f7f\u7528 \\(O(\\log n)\\) \u6808\u5e27\u7a7a\u95f4\u3002

    \u518d\u4f8b\u5982\u201c\u6570\u5b57\u8f6c\u5316\u4e3a\u5b57\u7b26\u4e32\u201d\uff0c\u8f93\u5165\u4efb\u610f\u6b63\u6574\u6570 \\(n\\) \uff0c\u5b83\u7684\u4f4d\u6570\u4e3a \\(\\log_{10} n\\) \uff0c\u5373\u5bf9\u5e94\u5b57\u7b26\u4e32\u957f\u5ea6\u4e3a \\(\\log_{10} n\\) \uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log_{10} n) = O(\\log n)\\) \u3002

    "},{"location":"chapter_computational_complexity/space_complexity/#234","title":"2.3.4. \u00a0 \u6743\u8861\u65f6\u95f4\u4e0e\u7a7a\u95f4","text":"

    \u7406\u60f3\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u5e0c\u671b\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u90fd\u80fd\u8fbe\u5230\u6700\u4f18\u3002\u7136\u800c\u5728\u5b9e\u9645\u60c5\u51b5\u4e2d\uff0c\u540c\u65f6\u4f18\u5316\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u901a\u5e38\u662f\u975e\u5e38\u56f0\u96be\u7684\u3002

    \u964d\u4f4e\u65f6\u95f4\u590d\u6742\u5ea6\u901a\u5e38\u9700\u8981\u4ee5\u63d0\u5347\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a\u4ee3\u4ef7\uff0c\u53cd\u4e4b\u4ea6\u7136\u3002\u6211\u4eec\u5c06\u727a\u7272\u5185\u5b58\u7a7a\u95f4\u6765\u63d0\u5347\u7b97\u6cd5\u8fd0\u884c\u901f\u5ea6\u7684\u601d\u8def\u79f0\u4e3a\u201c\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u201d\uff1b\u53cd\u4e4b\uff0c\u5219\u79f0\u4e3a\u201c\u4ee5\u65f6\u95f4\u6362\u7a7a\u95f4\u201d\u3002

    \u9009\u62e9\u54ea\u79cd\u601d\u8def\u53d6\u51b3\u4e8e\u6211\u4eec\u66f4\u770b\u91cd\u54ea\u4e2a\u65b9\u9762\u3002\u5728\u5927\u591a\u6570\u60c5\u51b5\u4e0b\uff0c\u65f6\u95f4\u6bd4\u7a7a\u95f4\u66f4\u5b9d\u8d35\uff0c\u56e0\u6b64\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u901a\u5e38\u662f\u66f4\u5e38\u7528\u7684\u7b56\u7565\u3002\u5f53\u7136\uff0c\u5728\u6570\u636e\u91cf\u5f88\u5927\u7684\u60c5\u51b5\u4e0b\uff0c\u63a7\u5236\u7a7a\u95f4\u590d\u6742\u5ea6\u4e5f\u662f\u975e\u5e38\u91cd\u8981\u7684\u3002

    "},{"location":"chapter_computational_complexity/summary/","title":"2.4. \u00a0 \u5c0f\u7ed3","text":"

    \u7b97\u6cd5\u6548\u7387\u8bc4\u4f30

    • \u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u662f\u8bc4\u4ef7\u7b97\u6cd5\u6027\u80fd\u7684\u4e24\u4e2a\u5173\u952e\u7ef4\u5ea6\u3002
    • \u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u5b9e\u9645\u6d4b\u8bd5\u6765\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\uff0c\u4f46\u96be\u4ee5\u6d88\u9664\u6d4b\u8bd5\u73af\u5883\u7684\u5f71\u54cd\uff0c\u4e14\u4f1a\u8017\u8d39\u5927\u91cf\u8ba1\u7b97\u8d44\u6e90\u3002
    • \u590d\u6742\u5ea6\u5206\u6790\u53ef\u4ee5\u514b\u670d\u5b9e\u9645\u6d4b\u8bd5\u7684\u5f0a\u7aef\uff0c\u5206\u6790\u7ed3\u679c\u9002\u7528\u4e8e\u6240\u6709\u8fd0\u884c\u5e73\u53f0\uff0c\u5e76\u4e14\u80fd\u591f\u63ed\u793a\u7b97\u6cd5\u5728\u4e0d\u540c\u6570\u636e\u89c4\u6a21\u4e0b\u7684\u6548\u7387\u3002

    \u65f6\u95f4\u590d\u6742\u5ea6

    • \u65f6\u95f4\u590d\u6742\u5ea6\u7528\u4e8e\u8861\u91cf\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u968f\u6570\u636e\u91cf\u589e\u957f\u7684\u8d8b\u52bf\uff0c\u53ef\u4ee5\u6709\u6548\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\uff0c\u4f46\u5728\u67d0\u4e9b\u60c5\u51b5\u4e0b\u53ef\u80fd\u5931\u6548\uff0c\u5982\u5728\u8f93\u5165\u6570\u636e\u91cf\u8f83\u5c0f\u6216\u65f6\u95f4\u590d\u6742\u5ea6\u76f8\u540c\u65f6\uff0c\u65e0\u6cd5\u7cbe\u786e\u5bf9\u6bd4\u7b97\u6cd5\u6548\u7387\u7684\u4f18\u52a3\u3002
    • \u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4f7f\u7528\u5927 \\(O\\) \u7b26\u53f7\u8868\u793a\uff0c\u5373\u51fd\u6570\u6e10\u8fd1\u4e0a\u754c\uff0c\u53cd\u6620\u5f53 \\(n\\) \u8d8b\u5411\u6b63\u65e0\u7a77\u65f6\uff0c\\(T(n)\\) \u7684\u589e\u957f\u7ea7\u522b\u3002
    • \u63a8\u7b97\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u4e3a\u4e24\u6b65\uff0c\u9996\u5148\u7edf\u8ba1\u8ba1\u7b97\u64cd\u4f5c\u6570\u91cf\uff0c\u7136\u540e\u5224\u65ad\u6e10\u8fd1\u4e0a\u754c\u3002
    • \u5e38\u89c1\u65f6\u95f4\u590d\u6742\u5ea6\u4ece\u5c0f\u5230\u5927\u6392\u5217\u6709 \\(O(1)\\) , \\(O(\\log n)\\) , \\(O(n)\\) , \\(O(n \\log n)\\) , \\(O(n^2)\\) , \\(O(2^n)\\) , \\(O(n!)\\) \u7b49\u3002
    • \u67d0\u4e9b\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u975e\u56fa\u5b9a\uff0c\u800c\u662f\u4e0e\u8f93\u5165\u6570\u636e\u7684\u5206\u5e03\u6709\u5173\u3002\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u4e3a\u6700\u5dee\u3001\u6700\u4f73\u3001\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u51e0\u4e4e\u4e0d\u7528\uff0c\u56e0\u4e3a\u8f93\u5165\u6570\u636e\u4e00\u822c\u9700\u8981\u6ee1\u8db3\u4e25\u683c\u6761\u4ef6\u624d\u80fd\u8fbe\u5230\u6700\u4f73\u60c5\u51b5\u3002
    • \u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u53cd\u6620\u7b97\u6cd5\u5728\u968f\u673a\u6570\u636e\u8f93\u5165\u4e0b\u7684\u8fd0\u884c\u6548\u7387\uff0c\u6700\u63a5\u8fd1\u5b9e\u9645\u5e94\u7528\u4e2d\u7684\u7b97\u6cd5\u6027\u80fd\u3002\u8ba1\u7b97\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u9700\u8981\u7edf\u8ba1\u8f93\u5165\u6570\u636e\u5206\u5e03\u4ee5\u53ca\u7efc\u5408\u540e\u7684\u6570\u5b66\u671f\u671b\u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6

    • \u7c7b\u4f3c\u4e8e\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u7528\u4e8e\u8861\u91cf\u7b97\u6cd5\u5360\u7528\u7a7a\u95f4\u968f\u6570\u636e\u91cf\u589e\u957f\u7684\u8d8b\u52bf\u3002
    • \u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u76f8\u5173\u5185\u5b58\u7a7a\u95f4\u53ef\u5206\u4e3a\u8f93\u5165\u7a7a\u95f4\u3001\u6682\u5b58\u7a7a\u95f4\u3001\u8f93\u51fa\u7a7a\u95f4\u3002\u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\u8f93\u5165\u7a7a\u95f4\u4e0d\u8ba1\u5165\u7a7a\u95f4\u590d\u6742\u5ea6\u8ba1\u7b97\u3002\u6682\u5b58\u7a7a\u95f4\u53ef\u5206\u4e3a\u6307\u4ee4\u7a7a\u95f4\u3001\u6570\u636e\u7a7a\u95f4\u3001\u6808\u5e27\u7a7a\u95f4\uff0c\u5176\u4e2d\u6808\u5e27\u7a7a\u95f4\u901a\u5e38\u4ec5\u5728\u9012\u5f52\u51fd\u6570\u4e2d\u5f71\u54cd\u7a7a\u95f4\u590d\u6742\u5ea6\u3002
    • \u6211\u4eec\u901a\u5e38\u53ea\u5173\u6ce8\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\uff0c\u5373\u7edf\u8ba1\u7b97\u6cd5\u5728\u6700\u5dee\u8f93\u5165\u6570\u636e\u548c\u6700\u5dee\u8fd0\u884c\u65f6\u95f4\u70b9\u4e0b\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u3002
    • \u5e38\u89c1\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece\u5c0f\u5230\u5927\u6392\u5217\u6709 \\(O(1)\\) , \\(O(\\log n)\\) , \\(O(n)\\) , \\(O(n^2)\\) , \\(O(2^n)\\) \u7b49\u3002
    "},{"location":"chapter_computational_complexity/summary/#241-q-a","title":"2.4.1. \u00a0 Q & A","text":"

    \u5c3e\u9012\u5f52\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u662f \\(O(1)\\) \u5417\uff1f

    \u7406\u8bba\u4e0a\uff0c\u5c3e\u9012\u5f52\u51fd\u6570\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u88ab\u4f18\u5316\u81f3 \\(O(1)\\) \u3002\u4e0d\u8fc7\u7edd\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\uff08\u4f8b\u5982 Java, Python, C++, Go, C# \u7b49\uff09 \u90fd\u4e0d\u652f\u6301\u81ea\u52a8\u4f18\u5316\u5c3e\u9012\u5f52\uff0c\u56e0\u6b64\u4e00\u822c\u6765\u8bf4\u7a7a\u95f4\u590d\u6742\u5ea6\u662f \\(O(n)\\) \u3002

    \u51fd\u6570\u548c\u65b9\u6cd5\u8fd9\u4e24\u4e2a\u672f\u8bed\u7684\u533a\u522b\u662f\u4ec0\u4e48\uff1f

    \u51fd\u6570\uff08function\uff09\u53ef\u4ee5\u72ec\u7acb\u88ab\u6267\u884c\uff0c\u6240\u6709\u53c2\u6570\u90fd\u4ee5\u663e\u5f0f\u4f20\u9012\u3002 \u65b9\u6cd5\uff08method\uff09\u4e0e\u4e00\u4e2a\u5bf9\u8c61\u5173\u8054\uff0c\u65b9\u6cd5\u88ab\u9690\u5f0f\u4f20\u9012\u7ed9\u8c03\u7528\u5b83\u7684\u5bf9\u8c61\uff0c\u65b9\u6cd5\u80fd\u591f\u5bf9\u7c7b\u7684\u5b9e\u4f8b\u4e2d\u5305\u542b\u7684\u6570\u636e\u8fdb\u884c\u64cd\u4f5c\u3002

    \u56e0\u6b64\uff0cC \u548c Go \u53ea\u6709\u51fd\u6570\uff0cJava \u548c C# \u53ea\u6709\u65b9\u6cd5\uff0c\u5728 C++, Python \u4e2d\u53d6\u51b3\u4e8e\u5b83\u662f\u5426\u5c5e\u4e8e\u4e00\u4e2a\u7c7b\u3002

    \u56fe\u7247\u201c\u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u5e38\u89c1\u7c7b\u578b\u201d\u53cd\u6620\u7684\u662f\u5426\u662f\u5360\u7528\u7a7a\u95f4\u7684\u7edd\u5bf9\u5927\u5c0f\uff1f

    \u4e0d\u662f\uff0c\u8be5\u56fe\u7247\u5c55\u793a\u7684\u662f\u7a7a\u95f4\u590d\u6742\u5ea6\uff08\u5373\u589e\u957f\u8d8b\u52bf\uff09\uff0c\u800c\u4e0d\u662f\u5360\u7528\u7a7a\u95f4\u7684\u7edd\u5bf9\u5927\u5c0f\u3002\u6bcf\u4e2a\u66f2\u7ebf\u90fd\u5305\u542b\u4e00\u4e2a\u5e38\u6570\u9879\uff0c\u7528\u6765\u628a\u6240\u6709\u66f2\u7ebf\u7684\u53d6\u503c\u8303\u56f4\u538b\u7f29\u5230\u4e00\u4e2a\u89c6\u89c9\u8212\u9002\u7684\u8303\u56f4\u5185\u3002 \u5b9e\u9645\u4e2d\uff0c\u56e0\u4e3a\u6211\u4eec\u901a\u5e38\u4e0d\u77e5\u9053\u6bcf\u4e2a\u65b9\u6cd5\u7684\u201c\u5e38\u6570\u9879\u201d\u590d\u6742\u5ea6\u662f\u591a\u5c11\uff0c\u6240\u4ee5\u4e00\u822c\u65e0\u6cd5\u4ec5\u51ed\u590d\u6742\u5ea6\u6765\u9009\u62e9 \\(n = 8\\) \u4e4b\u4e0b\u7684\u6700\u4f18\u89e3\u6cd5\uff1b\u4f46\u76f8\u5bf9\u5730 \\(n = 8^5\\) \u5c31\u5f88\u597d\u9009\u4e86\uff0c\u8fd9\u662f\u590d\u6742\u5ea6\u5360\u4e3b\u5bfc\u7684\u60c5\u51b5\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/","title":"2.2. \u00a0 \u65f6\u95f4\u590d\u6742\u5ea6","text":""},{"location":"chapter_computational_complexity/time_complexity/#221","title":"2.2.1. \u00a0 \u7edf\u8ba1\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4","text":"

    \u8fd0\u884c\u65f6\u95f4\u53ef\u4ee5\u76f4\u89c2\u4e14\u51c6\u786e\u5730\u53cd\u6620\u7b97\u6cd5\u7684\u6548\u7387\u3002\u7136\u800c\uff0c\u5982\u679c\u6211\u4eec\u60f3\u8981\u51c6\u786e\u9884\u4f30\u4e00\u6bb5\u4ee3\u7801\u7684\u8fd0\u884c\u65f6\u95f4\uff0c\u5e94\u8be5\u5982\u4f55\u64cd\u4f5c\u5462\uff1f

    1. \u786e\u5b9a\u8fd0\u884c\u5e73\u53f0\uff0c\u5305\u62ec\u786c\u4ef6\u914d\u7f6e\u3001\u7f16\u7a0b\u8bed\u8a00\u3001\u7cfb\u7edf\u73af\u5883\u7b49\uff0c\u8fd9\u4e9b\u56e0\u7d20\u90fd\u4f1a\u5f71\u54cd\u4ee3\u7801\u7684\u8fd0\u884c\u6548\u7387\u3002
    2. \u8bc4\u4f30\u5404\u79cd\u8ba1\u7b97\u64cd\u4f5c\u6240\u9700\u7684\u8fd0\u884c\u65f6\u95f4\uff0c\u4f8b\u5982\u52a0\u6cd5\u64cd\u4f5c + \u9700\u8981 1 ns\uff0c\u4e58\u6cd5\u64cd\u4f5c * \u9700\u8981 10 ns\uff0c\u6253\u5370\u64cd\u4f5c\u9700\u8981 5 ns \u7b49\u3002
    3. \u7edf\u8ba1\u4ee3\u7801\u4e2d\u6240\u6709\u7684\u8ba1\u7b97\u64cd\u4f5c\uff0c\u5e76\u5c06\u6240\u6709\u64cd\u4f5c\u7684\u6267\u884c\u65f6\u95f4\u6c42\u548c\uff0c\u4ece\u800c\u5f97\u5230\u8fd0\u884c\u65f6\u95f4\u3002

    \u4f8b\u5982\u4ee5\u4e0b\u4ee3\u7801\uff0c\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u6839\u636e\u4ee5\u4e0a\u65b9\u6cd5\uff0c\u53ef\u4ee5\u5f97\u5230\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u4e3a \\(6n + 12\\) ns \u3002

    \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\] JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\nint a = 2;  // 1 ns\na = a + 1;  // 1 ns\na = a * 2;  // 10 ns\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nSystem.out.println(0);     // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\nint a = 2;  // 1 ns\na = a + 1;  // 1 ns\na = a * 2;  // 10 ns\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\ncout << 0 << endl;         // 5 ns\n}\n}\n
    # \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\ndef algorithm(n: int) -> None:\na = 2      # 1 ns\na = a + 1  # 1 ns\na = a * 2  # 10 ns\n# \u5faa\u73af n \u6b21\nfor _ in range(n):  # 1 ns\nprint(0)        # 5 ns\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunc algorithm(n int) {\na := 2      // 1 ns\na = a + 1   // 1 ns\na = a * 2   // 10 ns\n// \u5faa\u73af n \u6b21\nfor i := 0; i < n; i++ {    // 1 ns\nfmt.Println(a)          // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunction algorithm(n) {\nvar a = 2; // 1 ns\na = a + 1; // 1 ns\na = a * 2; // 10 ns\n// \u5faa\u73af n \u6b21\nfor(let i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nconsole.log(0); // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunction algorithm(n: number): void {\nvar a: number = 2; // 1 ns\na = a + 1; // 1 ns\na = a * 2; // 10 ns\n// \u5faa\u73af n \u6b21\nfor(let i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nconsole.log(0); // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\nint a = 2;  // 1 ns\na = a + 1;  // 1 ns\na = a * 2;  // 10 ns\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) {   // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nprintf(\"%d\", 0);            // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n)\n{\nint a = 2;  // 1 ns\na = a + 1;  // 1 ns\na = a * 2;  // 10 ns\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++)\n{  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nConsole.WriteLine(0);     // 5 ns\n}\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunc algorithm(n: Int) {\nvar a = 2 // 1 ns\na = a + 1 // 1 ns\na = a * 2 // 10 ns\n// \u5faa\u73af n \u6b21\nfor _ in 0 ..< n { // 1 ns\nprint(0) // 5 ns\n}\n}\n
    \n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\nint a = 2; // 1 ns\na = a + 1; // 1 ns\na = a * 2; // 10 ns\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\nprint(0); // 5 ns\n}\n}\n

    \u7136\u800c\u5b9e\u9645\u4e0a\uff0c\u7edf\u8ba1\u7b97\u6cd5\u7684\u8fd0\u884c\u65f6\u95f4\u65e2\u4e0d\u5408\u7406\u4e5f\u4e0d\u73b0\u5b9e\u3002\u9996\u5148\uff0c\u6211\u4eec\u4e0d\u5e0c\u671b\u9884\u4f30\u65f6\u95f4\u548c\u8fd0\u884c\u5e73\u53f0\u7ed1\u5b9a\uff0c\u56e0\u4e3a\u7b97\u6cd5\u9700\u8981\u5728\u5404\u79cd\u4e0d\u540c\u7684\u5e73\u53f0\u4e0a\u8fd0\u884c\u3002\u5176\u6b21\uff0c\u6211\u4eec\u5f88\u96be\u83b7\u77e5\u6bcf\u79cd\u64cd\u4f5c\u7684\u8fd0\u884c\u65f6\u95f4\uff0c\u8fd9\u7ed9\u9884\u4f30\u8fc7\u7a0b\u5e26\u6765\u4e86\u6781\u5927\u7684\u96be\u5ea6\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#222","title":"2.2.2. \u00a0 \u7edf\u8ba1\u65f6\u95f4\u589e\u957f\u8d8b\u52bf","text":"

    \u300c\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\u300d\u91c7\u53d6\u4e86\u4e00\u79cd\u4e0d\u540c\u7684\u65b9\u6cd5\uff0c\u5176\u7edf\u8ba1\u7684\u4e0d\u662f\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\uff0c\u800c\u662f\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u968f\u7740\u6570\u636e\u91cf\u53d8\u5927\u65f6\u7684\u589e\u957f\u8d8b\u52bf\u3002

    \u201c\u65f6\u95f4\u589e\u957f\u8d8b\u52bf\u201d\u8fd9\u4e2a\u6982\u5ff5\u8f83\u4e3a\u62bd\u8c61\uff0c\u6211\u4eec\u901a\u8fc7\u4e00\u4e2a\u4f8b\u5b50\u6765\u52a0\u4ee5\u7406\u89e3\u3002\u5047\u8bbe\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u7ed9\u5b9a\u4e09\u4e2a\u7b97\u6cd5 A , B , C \u3002

    • \u7b97\u6cd5 A \u53ea\u6709 \\(1\\) \u4e2a\u6253\u5370\u64cd\u4f5c\uff0c\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u4e0d\u968f\u7740 \\(n\\) \u589e\u5927\u800c\u589e\u957f\u3002\u6211\u4eec\u79f0\u6b64\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a\u300c\u5e38\u6570\u9636\u300d\u3002
    • \u7b97\u6cd5 B \u4e2d\u7684\u6253\u5370\u64cd\u4f5c\u9700\u8981\u5faa\u73af \\(n\\) \u6b21\uff0c\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u968f\u7740 \\(n\\) \u589e\u5927\u5448\u7ebf\u6027\u589e\u957f\u3002\u6b64\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u88ab\u79f0\u4e3a\u300c\u7ebf\u6027\u9636\u300d\u3002
    • \u7b97\u6cd5 C \u4e2d\u7684\u6253\u5370\u64cd\u4f5c\u9700\u8981\u5faa\u73af \\(1000000\\) \u6b21\uff0c\u4f46\u8fd0\u884c\u65f6\u95f4\u4ecd\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u65e0\u5173\u3002\u56e0\u6b64 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u548c A \u76f8\u540c\uff0c\u4ecd\u4e3a\u300c\u5e38\u6570\u9636\u300d\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\nSystem.out.println(0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\nfor (int i = 0; i < n; i++) {\nSystem.out.println(0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\nfor (int i = 0; i < 1000000; i++) {\nSystem.out.println(0);\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\ncout << 0 << endl;\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\nfor (int i = 0; i < n; i++) {\ncout << 0 << endl;\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\nfor (int i = 0; i < 1000000; i++) {\ncout << 0 << endl;\n}\n}\n
    # \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\ndef algorithm_A(n: int) -> None:\nprint(0)\n# \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\ndef algorithm_B(n: int) -> None:\nfor _ in range(n):\nprint(0)\n# \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\ndef algorithm_C(n: int) -> None:\nfor _ in range(1000000):\nprint(0)\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithm_A(n int) {\nfmt.Println(0)\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunc algorithm_B(n int) {\nfor i := 0; i < n; i++ {\nfmt.Println(0)\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithm_C(n int) {\nfor i := 0; i < 1000000; i++ {\nfmt.Println(0)\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_A(n) {\nconsole.log(0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunction algorithm_B(n) {\nfor (let i = 0; i < n; i++) {\nconsole.log(0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_C(n) {\nfor (let i = 0; i < 1000000; i++) {\nconsole.log(0);\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_A(n: number): void {\nconsole.log(0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunction algorithm_B(n: number): void {\nfor (let i = 0; i < n; i++) {\nconsole.log(0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_C(n: number): void {\nfor (let i = 0; i < 1000000; i++) {\nconsole.log(0);\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\nprintf(\"%d\", 0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\nfor (int i = 0; i < n; i++) {\nprintf(\"%d\", 0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\nfor (int i = 0; i < 1000000; i++) {\nprintf(\"%d\", 0);\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n)\n{\nConsole.WriteLine(0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n)\n{\nfor (int i = 0; i < n; i++)\n{\nConsole.WriteLine(0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n)\n{\nfor (int i = 0; i < 1000000; i++)\n{\nConsole.WriteLine(0);\n}\n}\n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithmA(n: Int) {\nprint(0)\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunc algorithmB(n: Int) {\nfor _ in 0 ..< n {\nprint(0)\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithmC(n: Int) {\nfor _ in 0 ..< 1000000 {\nprint(0)\n}\n}\n
    \n
    // \u7b97\u6cd5 A \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithmA(int n) {\nprint(0);\n}\n// \u7b97\u6cd5 B \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithmB(int n) {\nfor (int i = 0; i < n; i++) {\nprint(0);\n}\n}\n// \u7b97\u6cd5 C \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithmC(int n) {\nfor (int i = 0; i < 1000000; i++) {\nprint(0);\n}\n}\n

    Fig. \u7b97\u6cd5 A, B, C \u7684\u65f6\u95f4\u589e\u957f\u8d8b\u52bf

    \u76f8\u8f83\u4e8e\u76f4\u63a5\u7edf\u8ba1\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\u6709\u54ea\u4e9b\u4f18\u52bf\u548c\u5c40\u9650\u6027\u5462\uff1f

    \u65f6\u95f4\u590d\u6742\u5ea6\u80fd\u591f\u6709\u6548\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\u3002\u4f8b\u5982\uff0c\u7b97\u6cd5 B \u7684\u8fd0\u884c\u65f6\u95f4\u5448\u7ebf\u6027\u589e\u957f\uff0c\u5728 \\(n > 1\\) \u65f6\u6bd4\u7b97\u6cd5 A \u6162\uff0c\u5728 \\(n > 1000000\\) \u65f6\u6bd4\u7b97\u6cd5 C \u6162\u3002\u4e8b\u5b9e\u4e0a\uff0c\u53ea\u8981\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u8db3\u591f\u5927\uff0c\u590d\u6742\u5ea6\u4e3a\u300c\u5e38\u6570\u9636\u300d\u7684\u7b97\u6cd5\u4e00\u5b9a\u4f18\u4e8e\u300c\u7ebf\u6027\u9636\u300d\u7684\u7b97\u6cd5\uff0c\u8fd9\u6b63\u662f\u65f6\u95f4\u589e\u957f\u8d8b\u52bf\u6240\u8868\u8fbe\u7684\u542b\u4e49\u3002

    \u65f6\u95f4\u590d\u6742\u5ea6\u7684\u63a8\u7b97\u65b9\u6cd5\u66f4\u7b80\u4fbf\u3002\u663e\u7136\uff0c\u8fd0\u884c\u5e73\u53f0\u548c\u8ba1\u7b97\u64cd\u4f5c\u7c7b\u578b\u90fd\u4e0e\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u7684\u589e\u957f\u8d8b\u52bf\u65e0\u5173\u3002\u56e0\u6b64\u5728\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u7b80\u5355\u5730\u5c06\u6240\u6709\u8ba1\u7b97\u64cd\u4f5c\u7684\u6267\u884c\u65f6\u95f4\u89c6\u4e3a\u76f8\u540c\u7684\u201c\u5355\u4f4d\u65f6\u95f4\u201d\uff0c\u4ece\u800c\u5c06\u201c\u8ba1\u7b97\u64cd\u4f5c\u7684\u8fd0\u884c\u65f6\u95f4\u7684\u7edf\u8ba1\u201d\u7b80\u5316\u4e3a\u201c\u8ba1\u7b97\u64cd\u4f5c\u7684\u6570\u91cf\u7684\u7edf\u8ba1\u201d\uff0c\u8fd9\u6837\u7684\u7b80\u5316\u65b9\u6cd5\u5927\u5927\u964d\u4f4e\u4e86\u4f30\u7b97\u96be\u5ea6\u3002

    \u65f6\u95f4\u590d\u6742\u5ea6\u4e5f\u5b58\u5728\u4e00\u5b9a\u7684\u5c40\u9650\u6027\u3002\u4f8b\u5982\uff0c\u5c3d\u7ba1\u7b97\u6cd5 A \u548c C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u76f8\u540c\uff0c\u4f46\u5b9e\u9645\u8fd0\u884c\u65f6\u95f4\u5dee\u522b\u5f88\u5927\u3002\u540c\u6837\uff0c\u5c3d\u7ba1\u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u6bd4 C \u9ad8\uff0c\u4f46\u5728\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u8f83\u5c0f\u65f6\uff0c\u7b97\u6cd5 B \u660e\u663e\u4f18\u4e8e\u7b97\u6cd5 C \u3002\u5728\u8fd9\u4e9b\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u5f88\u96be\u4ec5\u51ed\u65f6\u95f4\u590d\u6742\u5ea6\u5224\u65ad\u7b97\u6cd5\u6548\u7387\u9ad8\u4f4e\u3002\u5f53\u7136\uff0c\u5c3d\u7ba1\u5b58\u5728\u4e0a\u8ff0\u95ee\u9898\uff0c\u590d\u6742\u5ea6\u5206\u6790\u4ecd\u7136\u662f\u8bc4\u5224\u7b97\u6cd5\u6548\u7387\u6700\u6709\u6548\u4e14\u5e38\u7528\u7684\u65b9\u6cd5\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#223","title":"2.2.3. \u00a0 \u51fd\u6570\u6e10\u8fd1\u4e0a\u754c","text":"

    \u8bbe\u7b97\u6cd5\u7684\u8ba1\u7b97\u64cd\u4f5c\u6570\u91cf\u662f\u4e00\u4e2a\u5173\u4e8e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u7684\u51fd\u6570\uff0c\u8bb0\u4e3a \\(T(n)\\) \uff0c\u5219\u4ee5\u4e0b\u7b97\u6cd5\u7684\u64cd\u4f5c\u6570\u91cf\u4e3a

    \\[ T(n) = 3 + 2n \\] JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    void algorithm(int n) {\nint a = 1;  // +1\na = a + 1;  // +1\na = a * 2;  // +1\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\nSystem.out.println(0);    // +1\n}\n}\n
    void algorithm(int n) {\nint a = 1;  // +1\na = a + 1;  // +1\na = a * 2;  // +1\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\ncout << 0 << endl;    // +1\n}\n}\n
    def algorithm(n: int) -> None:\na = 1      # +1\na = a + 1  # +1\na = a * 2  # +1\n# \u5faa\u73af n \u6b21\nfor i in range(n):  # +1\nprint(0)        # +1\n
    func algorithm(n int) {\na := 1      // +1\na = a + 1   // +1\na = a * 2   // +1\n// \u5faa\u73af n \u6b21\nfor i := 0; i < n; i++ {   // +1\nfmt.Println(a)         // +1\n}\n}\n
    function algorithm(n) {\nvar a = 1; // +1\na += 1; // +1\na *= 2; // +1\n// \u5faa\u73af n \u6b21\nfor(let i = 0; i < n; i++){ // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\nconsole.log(0); // +1\n}\n}\n
    function algorithm(n: number): void{\nvar a: number = 1; // +1\na += 1; // +1\na *= 2; // +1\n// \u5faa\u73af n \u6b21\nfor(let i = 0; i < n; i++){ // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\nconsole.log(0); // +1\n}\n}\n
    void algorithm(int n) {\nint a = 1;  // +1\na = a + 1;  // +1\na = a * 2;  // +1\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) {   // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\nprintf(\"%d\", 0);            // +1\n}\n}  
    void algorithm(int n)\n{\nint a = 1;  // +1\na = a + 1;  // +1\na = a * 2;  // +1\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n{\nConsole.WriteLine(0);   // +1\n}\n}\n
    func algorithm(n: Int) {\nvar a = 1 // +1\na = a + 1 // +1\na = a * 2 // +1\n// \u5faa\u73af n \u6b21\nfor _ in 0 ..< n { // +1\nprint(0) // +1\n}\n}\n
    \n
    void algorithm(int n) {\nint a = 1; // +1\na = a + 1; // +1\na = a * 2; // +1\n// \u5faa\u73af n \u6b21\nfor (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\nprint(0); // +1\n}\n}\n

    \\(T(n)\\) \u662f\u4e00\u6b21\u51fd\u6570\uff0c\u8bf4\u660e\u65f6\u95f4\u589e\u957f\u8d8b\u52bf\u662f\u7ebf\u6027\u7684\uff0c\u56e0\u6b64\u53ef\u4ee5\u5f97\u51fa\u65f6\u95f4\u590d\u6742\u5ea6\u662f\u7ebf\u6027\u9636\u3002

    \u6211\u4eec\u5c06\u7ebf\u6027\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u8bb0\u4e3a \\(O(n)\\) \uff0c\u8fd9\u4e2a\u6570\u5b66\u7b26\u53f7\u79f0\u4e3a\u300c\u5927 \\(O\\) \u8bb0\u53f7 Big-\\(O\\) Notation\u300d\uff0c\u8868\u793a\u51fd\u6570 \\(T(n)\\) \u7684\u300c\u6e10\u8fd1\u4e0a\u754c Asymptotic Upper Bound\u300d\u3002

    \u63a8\u7b97\u65f6\u95f4\u590d\u6742\u5ea6\u672c\u8d28\u4e0a\u662f\u8ba1\u7b97\u201c\u64cd\u4f5c\u6570\u91cf\u51fd\u6570 \\(T(n)\\)\u201d\u7684\u6e10\u8fd1\u4e0a\u754c\u3002\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u6765\u770b\u51fd\u6570\u6e10\u8fd1\u4e0a\u754c\u7684\u6570\u5b66\u5b9a\u4e49\u3002

    \u51fd\u6570\u6e10\u8fd1\u4e0a\u754c

    \u82e5\u5b58\u5728\u6b63\u5b9e\u6570 \\(c\\) \u548c\u5b9e\u6570 \\(n_0\\) \uff0c\u4f7f\u5f97\u5bf9\u4e8e\u6240\u6709\u7684 \\(n > n_0\\) \uff0c\u5747\u6709 $$ T(n) \\leq c \\cdot f(n) $$ \u5219\u53ef\u8ba4\u4e3a \\(f(n)\\) \u7ed9\u51fa\u4e86 \\(T(n)\\) \u7684\u4e00\u4e2a\u6e10\u8fd1\u4e0a\u754c\uff0c\u8bb0\u4e3a $$ T(n) = O(f(n)) $$

    Fig. \u51fd\u6570\u7684\u6e10\u8fd1\u4e0a\u754c

    \u4ece\u672c\u8d28\u4e0a\u8bb2\uff0c\u8ba1\u7b97\u6e10\u8fd1\u4e0a\u754c\u5c31\u662f\u5bfb\u627e\u4e00\u4e2a\u51fd\u6570 \\(f(n)\\) \uff0c\u4f7f\u5f97\u5f53 \\(n\\) \u8d8b\u5411\u4e8e\u65e0\u7a77\u5927\u65f6\uff0c\\(T(n)\\) \u548c \\(f(n)\\) \u5904\u4e8e\u76f8\u540c\u7684\u589e\u957f\u7ea7\u522b\uff0c\u4ec5\u76f8\u5dee\u4e00\u4e2a\u5e38\u6570\u9879 \\(c\\) \u7684\u500d\u6570\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#224","title":"2.2.4. \u00a0 \u63a8\u7b97\u65b9\u6cd5","text":"

    \u6e10\u8fd1\u4e0a\u754c\u7684\u6570\u5b66\u5473\u513f\u6709\u70b9\u91cd\uff0c\u5982\u679c\u4f60\u611f\u89c9\u6ca1\u6709\u5b8c\u5168\u7406\u89e3\uff0c\u4e5f\u65e0\u9700\u62c5\u5fc3\u3002\u56e0\u4e3a\u5728\u5b9e\u9645\u4f7f\u7528\u4e2d\uff0c\u6211\u4eec\u53ea\u9700\u8981\u638c\u63e1\u63a8\u7b97\u65b9\u6cd5\uff0c\u6570\u5b66\u610f\u4e49\u53ef\u4ee5\u9010\u6e10\u9886\u609f\u3002

    \u6839\u636e\u5b9a\u4e49\uff0c\u786e\u5b9a \\(f(n)\\) \u4e4b\u540e\uff0c\u6211\u4eec\u4fbf\u53ef\u5f97\u5230\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(f(n))\\) \u3002\u90a3\u4e48\u5982\u4f55\u786e\u5b9a\u6e10\u8fd1\u4e0a\u754c \\(f(n)\\) \u5462\uff1f\u603b\u4f53\u5206\u4e3a\u4e24\u6b65\uff1a\u9996\u5148\u7edf\u8ba1\u64cd\u4f5c\u6570\u91cf\uff0c\u7136\u540e\u5224\u65ad\u6e10\u8fd1\u4e0a\u754c\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#_1","title":"\u7b2c\u4e00\u6b65\uff1a\u7edf\u8ba1\u64cd\u4f5c\u6570\u91cf","text":"

    \u9488\u5bf9\u4ee3\u7801\uff0c\u9010\u884c\u4ece\u4e0a\u5230\u4e0b\u8ba1\u7b97\u5373\u53ef\u3002\u7136\u800c\uff0c\u7531\u4e8e\u4e0a\u8ff0 \\(c \\cdot f(n)\\) \u4e2d\u7684\u5e38\u6570\u9879 \\(c\\) \u53ef\u4ee5\u53d6\u4efb\u610f\u5927\u5c0f\uff0c\u56e0\u6b64\u64cd\u4f5c\u6570\u91cf \\(T(n)\\) \u4e2d\u7684\u5404\u79cd\u7cfb\u6570\u3001\u5e38\u6570\u9879\u90fd\u53ef\u4ee5\u88ab\u5ffd\u7565\u3002\u6839\u636e\u6b64\u539f\u5219\uff0c\u53ef\u4ee5\u603b\u7ed3\u51fa\u4ee5\u4e0b\u8ba1\u6570\u7b80\u5316\u6280\u5de7\uff1a

    1. \u5ffd\u7565\u4e0e \\(n\\) \u65e0\u5173\u7684\u64cd\u4f5c\u3002\u56e0\u4e3a\u5b83\u4eec\u90fd\u662f \\(T(n)\\) \u4e2d\u7684\u5e38\u6570\u9879\uff0c\u5bf9\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u4ea7\u751f\u5f71\u54cd\u3002
    2. \u7701\u7565\u6240\u6709\u7cfb\u6570\u3002\u4f8b\u5982\uff0c\u5faa\u73af \\(2n\\) \u6b21\u3001\\(5n + 1\\) \u6b21\u7b49\uff0c\u90fd\u53ef\u4ee5\u7b80\u5316\u8bb0\u4e3a \\(n\\) \u6b21\uff0c\u56e0\u4e3a \\(n\\) \u524d\u9762\u7684\u7cfb\u6570\u5bf9\u65f6\u95f4\u590d\u6742\u5ea6\u6ca1\u6709\u5f71\u54cd\u3002
    3. \u5faa\u73af\u5d4c\u5957\u65f6\u4f7f\u7528\u4e58\u6cd5\u3002\u603b\u64cd\u4f5c\u6570\u91cf\u7b49\u4e8e\u5916\u5c42\u5faa\u73af\u548c\u5185\u5c42\u5faa\u73af\u64cd\u4f5c\u6570\u91cf\u4e4b\u79ef\uff0c\u6bcf\u4e00\u5c42\u5faa\u73af\u4f9d\u7136\u53ef\u4ee5\u5206\u522b\u5957\u7528\u4e0a\u8ff0 1. \u548c 2. \u6280\u5de7\u3002

    \u4ee5\u4e0b\u793a\u4f8b\u5c55\u793a\u4e86\u4f7f\u7528\u4e0a\u8ff0\u6280\u5de7\u524d\u3001\u540e\u7684\u7edf\u8ba1\u7ed3\u679c\u3002

    \\[ \\begin{aligned} T(n) & = 2n(n + 1) + (5n + 1) + 2 & \\text{\u5b8c\u6574\u7edf\u8ba1 (-.-|||)} \\newline & = 2n^2 + 7n + 3 \\newline T(n) & = n^2 + n & \\text{\u5077\u61d2\u7edf\u8ba1 (o.O)} \\end{aligned} \\]

    \u6700\u7ec8\uff0c\u4e24\u8005\u90fd\u80fd\u63a8\u51fa\u76f8\u540c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u7ed3\u679c\uff0c\u5373 \\(O(n^2)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    void algorithm(int n) {\nint a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (int i = 0; i < 5 * n + 1; i++) {\nSystem.out.println(0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (int i = 0; i < 2 * n; i++) {\nfor (int j = 0; j < n + 1; j++) {\nSystem.out.println(0);\n}\n}\n}\n
    void algorithm(int n) {\nint a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (int i = 0; i < 5 * n + 1; i++) {\ncout << 0 << endl;\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (int i = 0; i < 2 * n; i++) {\nfor (int j = 0; j < n + 1; j++) {\ncout << 0 << endl;\n}\n}\n}\n
    def algorithm(n: int) -> None:\na = 1      # +0\uff08\u6280\u5de7 1\uff09\na = a + n  # +0\uff08\u6280\u5de7 1\uff09\n# +n\uff08\u6280\u5de7 2\uff09\nfor i in range(5 * n + 1):\nprint(0)\n# +n*n\uff08\u6280\u5de7 3\uff09\nfor i in range(2 * n):\nfor j in range(n + 1):\nprint(0)\n
    func algorithm(n int) {\na := 1     // +0\uff08\u6280\u5de7 1\uff09\na = a + n  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor i := 0; i < 5 * n + 1; i++ {\nfmt.Println(0)\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor i := 0; i < 2 * n; i++ {\nfor j := 0; j < n + 1; j++ {\nfmt.Println(0)\n}\n}\n}\n
    function algorithm(n) {\nlet a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (let i = 0; i < 5 * n + 1; i++) {\nconsole.log(0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (let i = 0; i < 2 * n; i++) {\nfor (let j = 0; j < n + 1; j++) {\nconsole.log(0);\n}\n}\n}\n
    function algorithm(n: number): void {\nlet a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (let i = 0; i < 5 * n + 1; i++) {\nconsole.log(0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (let i = 0; i < 2 * n; i++) {\nfor (let j = 0; j < n + 1; j++) {\nconsole.log(0);\n}\n}\n}\n
    void algorithm(int n) {\nint a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (int i = 0; i < 5 * n + 1; i++) {\nprintf(\"%d\", 0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (int i = 0; i < 2 * n; i++) {\nfor (int j = 0; j < n + 1; j++) {\nprintf(\"%d\", 0);\n}\n}\n}\n
    void algorithm(int n)\n{\nint a = 1;  // +0\uff08\u6280\u5de7 1\uff09\na = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (int i = 0; i < 5 * n + 1; i++)\n{\nConsole.WriteLine(0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (int i = 0; i < 2 * n; i++)\n{\nfor (int j = 0; j < n + 1; j++)\n{\nConsole.WriteLine(0);\n}\n}\n}\n
    func algorithm(n: Int) {\nvar a = 1 // +0\uff08\u6280\u5de7 1\uff09\na = a + n // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor _ in 0 ..< (5 * n + 1) {\nprint(0)\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor _ in 0 ..< (2 * n) {\nfor _ in 0 ..< (n + 1) {\nprint(0)\n}\n}\n}\n
    \n
    void algorithm(int n) {\nint a = 1; // +0\uff08\u6280\u5de7 1\uff09\na = a + n; // +0\uff08\u6280\u5de7 1\uff09\n// +n\uff08\u6280\u5de7 2\uff09\nfor (int i = 0; i < 5 * n + 1; i++) {\nprint(0);\n}\n// +n*n\uff08\u6280\u5de7 3\uff09\nfor (int i = 0; i < 2 * n; i++) {\nfor (int j = 0; j < n + 1; j++) {\nprint(0);\n}\n}\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#_2","title":"\u7b2c\u4e8c\u6b65\uff1a\u5224\u65ad\u6e10\u8fd1\u4e0a\u754c","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\u7531\u591a\u9879\u5f0f \\(T(n)\\) \u4e2d\u6700\u9ad8\u9636\u7684\u9879\u6765\u51b3\u5b9a\u3002\u8fd9\u662f\u56e0\u4e3a\u5728 \\(n\\) \u8d8b\u4e8e\u65e0\u7a77\u5927\u65f6\uff0c\u6700\u9ad8\u9636\u7684\u9879\u5c06\u53d1\u6325\u4e3b\u5bfc\u4f5c\u7528\uff0c\u5176\u4ed6\u9879\u7684\u5f71\u54cd\u90fd\u53ef\u4ee5\u88ab\u5ffd\u7565\u3002

    \u4ee5\u4e0b\u8868\u683c\u5c55\u793a\u4e86\u4e00\u4e9b\u4f8b\u5b50\uff0c\u5176\u4e2d\u4e00\u4e9b\u5938\u5f20\u7684\u503c\u662f\u4e3a\u4e86\u5f3a\u8c03\u201c\u7cfb\u6570\u65e0\u6cd5\u64bc\u52a8\u9636\u6570\u201d\u8fd9\u4e00\u7ed3\u8bba\u3002\u5f53 \\(n\\) \u8d8b\u4e8e\u65e0\u7a77\u5927\u65f6\uff0c\u8fd9\u4e9b\u5e38\u6570\u53d8\u5f97\u65e0\u8db3\u8f7b\u91cd\u3002

    \u64cd\u4f5c\u6570\u91cf \\(T(n)\\) \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(f(n))\\) \\(100000\\) \\(O(1)\\) \\(3n + 2\\) \\(O(n)\\) \\(2n^2 + 3n + 2\\) \\(O(n^2)\\) \\(n^3 + 10000n^2\\) \\(O(n^3)\\) \\(2^n + 10000n^{10000}\\) \\(O(2^n)\\)"},{"location":"chapter_computational_complexity/time_complexity/#225","title":"2.2.5. \u00a0 \u5e38\u89c1\u7c7b\u578b","text":"

    \u8bbe\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u5e38\u89c1\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u7c7b\u578b\u5305\u62ec\uff08\u6309\u7167\u4ece\u4f4e\u5230\u9ad8\u7684\u987a\u5e8f\u6392\u5217\uff09\uff1a

    \\[ \\begin{aligned} O(1) < O(\\log n) < O(n) < O(n \\log n) < O(n^2) < O(2^n) < O(n!) \\newline \\text{\u5e38\u6570\u9636} < \\text{\u5bf9\u6570\u9636} < \\text{\u7ebf\u6027\u9636} < \\text{\u7ebf\u6027\u5bf9\u6570\u9636} < \\text{\u5e73\u65b9\u9636} < \\text{\u6307\u6570\u9636} < \\text{\u9636\u4e58\u9636} \\end{aligned} \\]

    Fig. \u65f6\u95f4\u590d\u6742\u5ea6\u7684\u5e38\u89c1\u7c7b\u578b

    Tip

    \u90e8\u5206\u793a\u4f8b\u4ee3\u7801\u9700\u8981\u4e00\u4e9b\u9884\u5907\u77e5\u8bc6\uff0c\u5305\u62ec\u6570\u7ec4\u3001\u9012\u5f52\u7b97\u6cd5\u7b49\u3002\u5982\u679c\u9047\u5230\u4e0d\u7406\u89e3\u7684\u90e8\u5206\uff0c\u8bf7\u4e0d\u8981\u62c5\u5fc3\uff0c\u53ef\u4ee5\u5728\u5b66\u4e60\u5b8c\u540e\u9762\u7ae0\u8282\u540e\u518d\u56de\u987e\u3002\u73b0\u9636\u6bb5\uff0c\u8bf7\u5148\u4e13\u6ce8\u4e8e\u7406\u89e3\u65f6\u95f4\u590d\u6742\u5ea6\u7684\u542b\u4e49\u548c\u63a8\u7b97\u65b9\u6cd5\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#o1","title":"\u5e38\u6570\u9636 \\(O(1)\\)","text":"

    \u5e38\u6570\u9636\u7684\u64cd\u4f5c\u6570\u91cf\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u65e0\u5173\uff0c\u5373\u4e0d\u968f\u7740 \\(n\\) \u7684\u53d8\u5316\u800c\u53d8\u5316\u3002

    \u5bf9\u4e8e\u4ee5\u4e0b\u7b97\u6cd5\uff0c\u5c3d\u7ba1\u64cd\u4f5c\u6570\u91cf size \u53ef\u80fd\u5f88\u5927\uff0c\u4f46\u7531\u4e8e\u5176\u4e0e\u6570\u636e\u5927\u5c0f \\(n\\) \u65e0\u5173\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(1)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\nint count = 0;\nint size = 100000;\nfor (int i = 0; i < size; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.cpp
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\nint count = 0;\nint size = 100000;\nfor (int i = 0; i < size; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.py
    def constant(n: int) -> int:\n\"\"\"\u5e38\u6570\u9636\"\"\"\ncount = 0\nsize = 100000\nfor _ in range(size):\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u5e38\u6570\u9636 */\nfunc constant(n int) int {\ncount := 0\nsize := 100000\nfor i := 0; i < size; i++ {\ncount++\n}\nreturn count\n}\n
    time_complexity.js
    /* \u5e38\u6570\u9636 */\nfunction constant(n) {\nlet count = 0;\nconst size = 100000;\nfor (let i = 0; i < size; i++) count++;\nreturn count;\n}\n
    time_complexity.ts
    /* \u5e38\u6570\u9636 */\nfunction constant(n: number): number {\nlet count = 0;\nconst size = 100000;\nfor (let i = 0; i < size; i++) count++;\nreturn count;\n}\n
    time_complexity.c
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\nint count = 0;\nint size = 100000;\nint i = 0;\nfor (int i = 0; i < size; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\nint count = 0;\nint size = 100000;\nfor (int i = 0; i < size; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.swift
    /* \u5e38\u6570\u9636 */\nfunc constant(n: Int) -> Int {\nvar count = 0\nlet size = 100_000\nfor _ in 0 ..< size {\ncount += 1\n}\nreturn count\n}\n
    time_complexity.zig
    // \u5e38\u6570\u9636\nfn constant(n: i32) i32 {\n_ = n;\nvar count: i32 = 0;\nconst size: i32 = 100_000;\nvar i: i32 = 0;\nwhile(i<size) : (i += 1) {\ncount += 1;\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\nint count = 0;\nint size = 100000;\nfor (var i = 0; i < size; i++) {\ncount++;\n}\nreturn count;\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#on","title":"\u7ebf\u6027\u9636 \\(O(n)\\)","text":"

    \u7ebf\u6027\u9636\u7684\u64cd\u4f5c\u6570\u91cf\u76f8\u5bf9\u4e8e\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4ee5\u7ebf\u6027\u7ea7\u522b\u589e\u957f\u3002\u7ebf\u6027\u9636\u901a\u5e38\u51fa\u73b0\u5728\u5355\u5c42\u5faa\u73af\u4e2d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\nint count = 0;\nfor (int i = 0; i < n; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\nint count = 0;\nfor (int i = 0; i < n; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.py
    def linear(n: int) -> int:\n\"\"\"\u7ebf\u6027\u9636\"\"\"\ncount = 0\nfor _ in range(n):\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u7ebf\u6027\u9636 */\nfunc linear(n int) int {\ncount := 0\nfor i := 0; i < n; i++ {\ncount++\n}\nreturn count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636 */\nfunction linear(n) {\nlet count = 0;\nfor (let i = 0; i < n; i++) count++;\nreturn count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636 */\nfunction linear(n: number): number {\nlet count = 0;\nfor (let i = 0; i < n; i++) count++;\nreturn count;\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\nint count = 0;\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\nint count = 0;\nfor (int i = 0; i < n; i++)\ncount++;\nreturn count;\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636 */\nfunc linear(n: Int) -> Int {\nvar count = 0\nfor _ in 0 ..< n {\ncount += 1\n}\nreturn count\n}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\nfn linear(n: i32) i32 {\nvar count: i32 = 0;\nvar i: i32 = 0;\nwhile (i < n) : (i += 1) {\ncount += 1;\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\nint count = 0;\nfor (var i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n

    \u904d\u5386\u6570\u7ec4\u548c\u904d\u5386\u94fe\u8868\u7b49\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(n)\\) \uff0c\u5176\u4e2d \\(n\\) \u4e3a\u6570\u7ec4\u6216\u94fe\u8868\u7684\u957f\u5ea6\u3002

    \u5982\u4f55\u786e\u5b9a\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \uff1f

    \u6570\u636e\u5927\u5c0f \\(n\\) \u9700\u6839\u636e\u8f93\u5165\u6570\u636e\u7684\u7c7b\u578b\u6765\u5177\u4f53\u786e\u5b9a\u3002\u4f8b\u5982\uff0c\u5728\u4e0a\u8ff0\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u76f4\u63a5\u5c06 \\(n\\) \u89c6\u4e3a\u8f93\u5165\u6570\u636e\u5927\u5c0f\uff1b\u5728\u4e0b\u9762\u904d\u5386\u6570\u7ec4\u7684\u793a\u4f8b\u4e2d\uff0c\u6570\u636e\u5927\u5c0f \\(n\\) \u4e3a\u6570\u7ec4\u7684\u957f\u5ea6\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int[] nums) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (int num : nums) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(vector<int> &nums) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (int num : nums) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.py
    def array_traversal(nums: list[int]) -> int:\n\"\"\"\u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\"\"\"\ncount = 0\n# \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor num in nums:\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums []int) int {\ncount := 0\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor range nums {\ncount++\n}\nreturn count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums) {\nlet count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (let i = 0; i < nums.length; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums: number[]): number {\nlet count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (let i = 0; i < nums.length; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int *nums, int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int[] nums) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nforeach (int num in nums) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums: [Int]) -> Int {\nvar count = 0\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor _ in nums {\ncount += 1\n}\nreturn count\n}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\nfn arrayTraversal(nums: []i32) i32 {\nvar count: i32 = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (nums) |_| {\ncount += 1;\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(List<int> nums) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\nfor (var num in nums) {\ncount++;\n}\nreturn count;\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#on2","title":"\u5e73\u65b9\u9636 \\(O(n^2)\\)","text":"

    \u5e73\u65b9\u9636\u7684\u64cd\u4f5c\u6570\u91cf\u76f8\u5bf9\u4e8e\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4ee5\u5e73\u65b9\u7ea7\u522b\u589e\u957f\u3002\u5e73\u65b9\u9636\u901a\u5e38\u51fa\u73b0\u5728\u5d4c\u5957\u5faa\u73af\u4e2d\uff0c\u5916\u5c42\u5faa\u73af\u548c\u5185\u5c42\u5faa\u73af\u90fd\u4e3a \\(O(n)\\) \uff0c\u56e0\u6b64\u603b\u4f53\u4e3a \\(O(n^2)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.py
    def quadratic(n: int) -> int:\n\"\"\"\u5e73\u65b9\u9636\"\"\"\ncount = 0\n# \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor i in range(n):\nfor j in range(n):\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n int) int {\ncount := 0\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor i := 0; i < n; i++ {\nfor j := 0; j < n; j++ {\ncount++\n}\n}\nreturn count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\nlet count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (let i = 0; i < n; i++) {\nfor (let j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n: number): number {\nlet count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (let i = 0; i < n; i++) {\nfor (let j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n: Int) -> Int {\nvar count = 0\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor _ in 0 ..< n {\nfor _ in 0 ..< n {\ncount += 1\n}\n}\nreturn count\n}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) i32 {\nvar count: i32 = 0;\nvar i: i32 = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nwhile (i < n) : (i += 1) {\nvar j: i32 = 0;\nwhile (j < n) : (j += 1) {\ncount += 1;\n}\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\nint count = 0;\n// \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u5e73\u65b9\u5173\u7cfb\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < n; j++) {\ncount++;\n}\n}\nreturn count;\n}\n

    Fig. \u5e38\u6570\u9636\u3001\u7ebf\u6027\u9636\u3001\u5e73\u65b9\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \u4ee5\u300c\u5192\u6ce1\u6392\u5e8f\u300d\u4e3a\u4f8b\uff0c\u5916\u5c42\u5faa\u73af\u6267\u884c \\(n - 1\\) \u6b21\uff0c\u5185\u5c42\u5faa\u73af\u6267\u884c \\(n-1, n-2, \\cdots, 2, 1\\) \u6b21\uff0c\u5e73\u5747\u4e3a \\(\\frac{n}{2}\\) \u6b21\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    \\[ O((n - 1) \\frac{n}{2}) = O(n^2) \\] JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int[] nums) {\nint count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(vector<int> &nums) {\nint count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.size() - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.py
    def bubble_sort(nums: list[int]) -> int:\n\"\"\"\u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\"\"\"\ncount = 0  # \u8ba1\u6570\u5668\n# \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in range(len(nums) - 1, 0, -1):\n# \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor j in range(i):\nif nums[j] > nums[j + 1]:\n# \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\ntmp: int = nums[j]\nnums[j] = nums[j + 1]\nnums[j + 1] = tmp\ncount += 3  # \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\nreturn count\n
    time_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums []int) int {\ncount := 0 // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i := len(nums) - 1; i > 0; i-- {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef\nfor j := 0; j < i; j++ {\nif nums[j] > nums[j+1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\ntmp := nums[j]\nnums[j] = nums[j+1]\nnums[j+1] = tmp\ncount += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums) {\nlet count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums: number[]): number {\nlet count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int *nums, int n) {\nint count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = n - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int[] nums) {\nint count = 0;  // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.Length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums: inout [Int]) -> Int {\nvar count = 0 // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in stride(from: nums.count - 1, to: 0, by: -1) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor j in 0 ..< i {\nif nums[j] > nums[j + 1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j]\nnums[j] = nums[j + 1]\nnums[j + 1] = tmp\ncount += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count\n}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\nfn bubbleSort(nums: []i32) i32 {\nvar count: i32 = 0;  // \u8ba1\u6570\u5668 \n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nvar i: i32 = @as(i32, @intCast(nums.len)) - 1;\nwhile (i > 0) : (i -= 1) {\nvar j: usize = 0;\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nwhile (j < i) : (j += 1) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nvar tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(List<int> nums) {\nint count = 0; // \u8ba1\u6570\u5668\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (var i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef\nfor (var j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\ncount += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n}\n}\n}\nreturn count;\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#o2n","title":"\u6307\u6570\u9636 \\(O(2^n)\\)","text":"

    Note

    \u751f\u7269\u5b66\u7684\u201c\u7ec6\u80de\u5206\u88c2\u201d\u662f\u6307\u6570\u9636\u589e\u957f\u7684\u5178\u578b\u4f8b\u5b50\uff1a\u521d\u59cb\u72b6\u6001\u4e3a \\(1\\) \u4e2a\u7ec6\u80de\uff0c\u5206\u88c2\u4e00\u8f6e\u540e\u53d8\u4e3a \\(2\\) \u4e2a\uff0c\u5206\u88c2\u4e24\u8f6e\u540e\u53d8\u4e3a \\(4\\) \u4e2a\uff0c\u4ee5\u6b64\u7c7b\u63a8\uff0c\u5206\u88c2 \\(n\\) \u8f6e\u540e\u6709 \\(2^n\\) \u4e2a\u7ec6\u80de\u3002

    \u6307\u6570\u9636\u589e\u957f\u975e\u5e38\u8fc5\u901f\uff0c\u5728\u5b9e\u9645\u5e94\u7528\u4e2d\u901a\u5e38\u662f\u4e0d\u53ef\u63a5\u53d7\u7684\u3002\u82e5\u4e00\u4e2a\u95ee\u9898\u4f7f\u7528\u300c\u66b4\u529b\u679a\u4e3e\u300d\u6c42\u89e3\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \uff0c\u90a3\u4e48\u901a\u5e38\u9700\u8981\u4f7f\u7528\u300c\u52a8\u6001\u89c4\u5212\u300d\u6216\u300c\u8d2a\u5fc3\u7b97\u6cd5\u300d\u7b49\u65b9\u6cd5\u6765\u89e3\u51b3\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\nint count = 0, base = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < base; j++) {\ncount++;\n}\nbase *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\nint count = 0, base = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < base; j++) {\ncount++;\n}\nbase *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.py
    def exponential(n: int) -> int:\n\"\"\"\u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\ncount = 0\nbase = 1\n# cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor _ in range(n):\nfor _ in range(base):\ncount += 1\nbase *= 2\n# count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc exponential(n int) int {\ncount, base := 0, 1\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor i := 0; i < n; i++ {\nfor j := 0; j < base; j++ {\ncount++\n}\nbase *= 2\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n) {\nlet count = 0,\nbase = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (let i = 0; i < n; i++) {\nfor (let j = 0; j < base; j++) {\ncount++;\n}\nbase *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n: number): number {\nlet count = 0,\nbase = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (let i = 0; i < n; i++) {\nfor (let j = 0; j < base; j++) {\ncount++;\n}\nbase *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\nint count = 0;\nint bas = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < bas; j++) {\ncount++;\n}\nbas *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\nint count = 0, bas = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (int i = 0; i < n; i++) {\nfor (int j = 0; j < bas; j++) {\ncount++;\n}\nbas *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc exponential(n: Int) -> Int {\nvar count = 0\nvar base = 1\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor _ in 0 ..< n {\nfor _ in 0 ..< base {\ncount += 1\n}\nbase *= 2\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count\n}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn exponential(n: i32) i32 {\nvar count: i32 = 0;\nvar bas: i32 = 1;\nvar i: i32 = 0;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nwhile (i < n) : (i += 1) {\nvar j: i32 = 0;\nwhile (j < bas) : (j += 1) {\ncount += 1;\n}\nbas *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n
    time_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\nint count = 0, base = 1;\n// cell \u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\nfor (var i = 0; i < n; i++) {\nfor (var j = 0; j < base; j++) {\ncount++;\n}\nbase *= 2;\n}\n// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\nreturn count;\n}\n

    Fig. \u6307\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \u5728\u5b9e\u9645\u7b97\u6cd5\u4e2d\uff0c\u6307\u6570\u9636\u5e38\u51fa\u73b0\u4e8e\u9012\u5f52\u51fd\u6570\u3002\u4f8b\u5982\u4ee5\u4e0b\u4ee3\u7801\uff0c\u4e0d\u65ad\u5730\u4e00\u5206\u4e3a\u4e8c\uff0c\u7ecf\u8fc7 \\(n\\) \u6b21\u5206\u88c2\u540e\u505c\u6b62\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\nif (n == 1)\nreturn 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\nif (n == 1)\nreturn 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.py
    def exp_recur(n: int) -> int:\n\"\"\"\u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\nif n == 1:\nreturn 1\nreturn exp_recur(n - 1) + exp_recur(n - 1) + 1\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc expRecur(n int) int {\nif n == 1 {\nreturn 1\n}\nreturn expRecur(n-1) + expRecur(n-1) + 1\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction expRecur(n) {\nif (n == 1) return 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.ts
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction expRecur(n: number): number {\nif (n == 1) return 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\nif (n == 1)\nreturn 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.cs
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\nif (n == 1) return 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.swift
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc expRecur(n: Int) -> Int {\nif n == 1 {\nreturn 1\n}\nreturn expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn expRecur(n: i32) i32 {\nif (n == 1) return 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.dart
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\nif (n == 1) return 1;\nreturn expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#olog-n","title":"\u5bf9\u6570\u9636 \\(O(\\log n)\\)","text":"

    \u4e0e\u6307\u6570\u9636\u76f8\u53cd\uff0c\u5bf9\u6570\u9636\u53cd\u6620\u4e86\u201c\u6bcf\u8f6e\u7f29\u51cf\u5230\u4e00\u534a\u7684\u60c5\u51b5\u201d\u3002\u5bf9\u6570\u9636\u4ec5\u6b21\u4e8e\u5e38\u6570\u9636\uff0c\u65f6\u95f4\u589e\u957f\u7f13\u6162\uff0c\u662f\u7406\u60f3\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u3002

    \u5bf9\u6570\u9636\u5e38\u51fa\u73b0\u4e8e\u300c\u4e8c\u5206\u67e5\u627e\u300d\u548c\u300c\u5206\u6cbb\u7b97\u6cd5\u300d\u4e2d\uff0c\u4f53\u73b0\u4e86\u201c\u4e00\u5206\u4e3a\u591a\u201d\u548c\u201c\u5316\u7e41\u4e3a\u7b80\u201d\u7684\u7b97\u6cd5\u601d\u60f3\u3002

    \u8bbe\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u7531\u4e8e\u6bcf\u8f6e\u7f29\u51cf\u5230\u4e00\u534a\uff0c\u56e0\u6b64\u5faa\u73af\u6b21\u6570\u662f \\(\\log_2 n\\) \uff0c\u5373 \\(2^n\\) \u7684\u53cd\u51fd\u6570\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(float n) {\nint count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(float n) {\nint count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.py
    def logarithmic(n: float) -> int:\n\"\"\"\u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\ncount = 0\nwhile n > 1:\nn = n / 2\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc logarithmic(n float64) int {\ncount := 0\nfor n > 1 {\nn = n / 2\ncount++\n}\nreturn count\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n) {\nlet count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n: number): number {\nlet count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(float n) {\nint count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(float n) {\nint count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc logarithmic(n: Double) -> Int {\nvar count = 0\nvar n = n\nwhile n > 1 {\nn = n / 2\ncount += 1\n}\nreturn count\n}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn logarithmic(n: f32) i32 {\nvar count: i32 = 0;\nvar n_var = n;\nwhile (n_var > 1)\n{\nn_var = n_var / 2;\ncount +=1;\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(num n) {\nint count = 0;\nwhile (n > 1) {\nn = n / 2;\ncount++;\n}\nreturn count;\n}\n

    Fig. \u5bf9\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \u4e0e\u6307\u6570\u9636\u7c7b\u4f3c\uff0c\u5bf9\u6570\u9636\u4e5f\u5e38\u51fa\u73b0\u4e8e\u9012\u5f52\u51fd\u6570\u3002\u4ee5\u4e0b\u4ee3\u7801\u5f62\u6210\u4e86\u4e00\u4e2a\u9ad8\u5ea6\u4e3a \\(\\log_2 n\\) \u7684\u9012\u5f52\u6811\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(float n) {\nif (n <= 1)\nreturn 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(float n) {\nif (n <= 1)\nreturn 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.py
    def log_recur(n: float) -> int:\n\"\"\"\u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\nif n <= 1:\nreturn 0\nreturn log_recur(n / 2) + 1\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc logRecur(n float64) int {\nif n <= 1 {\nreturn 0\n}\nreturn logRecur(n/2) + 1\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n) {\nif (n <= 1) return 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n: number): number {\nif (n <= 1) return 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(float n) {\nif (n <= 1)\nreturn 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(float n) {\nif (n <= 1) return 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc logRecur(n: Double) -> Int {\nif n <= 1 {\nreturn 0\n}\nreturn logRecur(n: n / 2) + 1\n}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn logRecur(n: f32) i32 {\nif (n <= 1) return 0;\nreturn logRecur(n / 2) + 1;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(num n) {\nif (n <= 1) return 0;\nreturn logRecur(n / 2) + 1;\n}\n
    "},{"location":"chapter_computational_complexity/time_complexity/#on-log-n","title":"\u7ebf\u6027\u5bf9\u6570\u9636 \\(O(n \\log n)\\)","text":"

    \u7ebf\u6027\u5bf9\u6570\u9636\u5e38\u51fa\u73b0\u4e8e\u5d4c\u5957\u5faa\u73af\u4e2d\uff0c\u4e24\u5c42\u5faa\u73af\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u522b\u4e3a \\(O(\\log n)\\) \u548c \\(O(n)\\) \u3002

    \u4e3b\u6d41\u6392\u5e8f\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u901a\u5e38\u4e3a \\(O(n \\log n)\\) \uff0c\u4f8b\u5982\u5feb\u901f\u6392\u5e8f\u3001\u5f52\u5e76\u6392\u5e8f\u3001\u5806\u6392\u5e8f\u7b49\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(float n) {\nif (n <= 1)\nreturn 1;\nint count = linearLogRecur(n / 2) +\nlinearLogRecur(n / 2);\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(float n) {\nif (n <= 1)\nreturn 1;\nint count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.py
    def linear_log_recur(n: float) -> int:\n\"\"\"\u7ebf\u6027\u5bf9\u6570\u9636\"\"\"\nif n <= 1:\nreturn 1\ncount: int = linear_log_recur(n // 2) + linear_log_recur(n // 2)\nfor _ in range(n):\ncount += 1\nreturn count\n
    time_complexity.go
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n float64) int {\nif n <= 1 {\nreturn 1\n}\ncount := linearLogRecur(n/2) +\nlinearLogRecur(n/2)\nfor i := 0.0; i < n; i++ {\ncount++\n}\nreturn count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n) {\nif (n <= 1) return 1;\nlet count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\nfor (let i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n: number): number {\nif (n <= 1) return 1;\nlet count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\nfor (let i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(float n) {\nif (n <= 1)\nreturn 1;\nint count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(float n) {\nif (n <= 1) return 1;\nint count = linearLogRecur(n / 2) +\nlinearLogRecur(n / 2);\nfor (int i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n: Double) -> Int {\nif n <= 1 {\nreturn 1\n}\nvar count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\nfor _ in stride(from: 0, to: n, by: 1) {\ncount += 1\n}\nreturn count\n}\n
    time_complexity.zig
    // \u7ebf\u6027\u5bf9\u6570\u9636\nfn linearLogRecur(n: f32) i32 {\nif (n <= 1) return 1;\nvar count: i32 = linearLogRecur(n / 2) +\nlinearLogRecur(n / 2);\nvar i: f32 = 0;\nwhile (i < n) : (i += 1) {\ncount += 1;\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(num n) {\nif (n <= 1) return 1;\nint count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\nfor (var i = 0; i < n; i++) {\ncount++;\n}\nreturn count;\n}\n

    Fig. \u7ebf\u6027\u5bf9\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/time_complexity/#on_1","title":"\u9636\u4e58\u9636 \\(O(n!)\\)","text":"

    \u9636\u4e58\u9636\u5bf9\u5e94\u6570\u5b66\u4e0a\u7684\u300c\u5168\u6392\u5217\u300d\u95ee\u9898\u3002\u7ed9\u5b9a \\(n\\) \u4e2a\u4e92\u4e0d\u91cd\u590d\u7684\u5143\u7d20\uff0c\u6c42\u5176\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u65b9\u6848\uff0c\u65b9\u6848\u6570\u91cf\u4e3a\uff1a

    \\[ n! = n \\times (n - 1) \\times (n - 2) \\times \\cdots \\times 2 \\times 1 \\]

    \u9636\u4e58\u901a\u5e38\u4f7f\u7528\u9012\u5f52\u5b9e\u73b0\u3002\u4f8b\u5982\u4ee5\u4e0b\u4ee3\u7801\uff0c\u7b2c\u4e00\u5c42\u5206\u88c2\u51fa \\(n\\) \u4e2a\uff0c\u7b2c\u4e8c\u5c42\u5206\u88c2\u51fa \\(n - 1\\) \u4e2a\uff0c\u4ee5\u6b64\u7c7b\u63a8\uff0c\u76f4\u81f3\u7b2c \\(n\\) \u5c42\u65f6\u7ec8\u6b62\u5206\u88c2\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart time_complexity.java
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\nif (n == 0)\nreturn 1;\nint count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (int i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.cpp
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\nif (n == 0)\nreturn 1;\nint count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (int i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.py
    def factorial_recur(n: int) -> int:\n\"\"\"\u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\nif n == 0:\nreturn 1\ncount = 0\n# \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor _ in range(n):\ncount += factorial_recur(n - 1)\nreturn count\n
    time_complexity.go
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n int) int {\nif n == 0 {\nreturn 1\n}\ncount := 0\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor i := 0; i < n; i++ {\ncount += factorialRecur(n - 1)\n}\nreturn count\n}\n
    time_complexity.js
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n) {\nif (n == 0) return 1;\nlet count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (let i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.ts
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n: number): number {\nif (n == 0) return 1;\nlet count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (let i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.c
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\nif (n == 0)\nreturn 1;\nint count = 0;\nfor (int i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.cs
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\nif (n == 0) return 1;\nint count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (int i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.swift
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n: Int) -> Int {\nif n == 0 {\nreturn 1\n}\nvar count = 0\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor _ in 0 ..< n {\ncount += factorialRecur(n: n - 1)\n}\nreturn count\n}\n
    time_complexity.zig
    // \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn factorialRecur(n: i32) i32 {\nif (n == 0) return 1;\nvar count: i32 = 0;\nvar i: i32 = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nwhile (i < n) : (i += 1) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n
    time_complexity.dart
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\nif (n == 0) return 1;\nint count = 0;\n// \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\nfor (var i = 0; i < n; i++) {\ncount += factorialRecur(n - 1);\n}\nreturn count;\n}\n

    Fig. \u9636\u4e58\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/time_complexity/#226","title":"2.2.6. \u00a0 \u6700\u5dee\u3001\u6700\u4f73\u3001\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6","text":"

    \u67d0\u4e9b\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u662f\u56fa\u5b9a\u7684\uff0c\u800c\u662f\u4e0e\u8f93\u5165\u6570\u636e\u7684\u5206\u5e03\u6709\u5173\u3002\u4f8b\u5982\uff0c\u5047\u8bbe\u8f93\u5165\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4 nums \uff0c\u5176\u4e2d nums \u7531\u4ece \\(1\\) \u81f3 \\(n\\) \u7684\u6570\u5b57\u7ec4\u6210\uff0c\u4f46\u5143\u7d20\u987a\u5e8f\u662f\u968f\u673a\u6253\u4e71\u7684\uff1b\u7b97\u6cd5\u7684\u4efb\u52a1\u662f\u8fd4\u56de\u5143\u7d20 \\(1\\) \u7684\u7d22\u5f15\u3002\u6211\u4eec\u53ef\u4ee5\u5f97\u51fa\u4ee5\u4e0b\u7ed3\u8bba\uff1a

    • \u5f53 nums = [?, ?, ..., 1] \uff0c\u5373\u5f53\u672b\u5c3e\u5143\u7d20\u662f \\(1\\) \u65f6\uff0c\u9700\u8981\u5b8c\u6574\u904d\u5386\u6570\u7ec4\uff0c\u6b64\u65f6\u8fbe\u5230 \u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n)\\)\uff1b
    • \u5f53 nums = [1, ?, ?, ...] \uff0c\u5373\u5f53\u9996\u4e2a\u6570\u5b57\u4e3a \\(1\\) \u65f6\uff0c\u65e0\u8bba\u6570\u7ec4\u591a\u957f\u90fd\u4e0d\u9700\u8981\u7ee7\u7eed\u904d\u5386\uff0c\u6b64\u65f6\u8fbe\u5230 \u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 \\(\\Omega(1)\\)\uff1b

    \u201c\u51fd\u6570\u6e10\u8fd1\u4e0a\u754c\u201d\u4f7f\u7528\u5927 \\(O\\) \u8bb0\u53f7\u8868\u793a\uff0c\u4ee3\u8868\u300c\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u300d\u3002\u76f8\u5e94\u5730\uff0c\u201c\u51fd\u6570\u6e10\u8fd1\u4e0b\u754c\u201d\u7528 \\(\\Omega\\) \u8bb0\u53f7\u6765\u8868\u793a\uff0c\u4ee3\u8868\u300c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u300d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart worst_best_time_complexity.java
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nint[] randomNumbers(int n) {\nInteger[] nums = new Integer[n];\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (int i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nCollections.shuffle(Arrays.asList(nums));\n// Integer[] -> int[]\nint[] res = new int[n];\nfor (int i = 0; i < n; i++) {\nres[i] = nums[i];\n}\nreturn res;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int[] nums) {\nfor (int i = 0; i < nums.length; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] == 1)\nreturn i;\n}\nreturn -1;\n}\n
    worst_best_time_complexity.cpp
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nvector<int> randomNumbers(int n) {\nvector<int> nums(n);\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (int i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u4f7f\u7528\u7cfb\u7edf\u65f6\u95f4\u751f\u6210\u968f\u673a\u79cd\u5b50\nunsigned seed = chrono::system_clock::now().time_since_epoch().count();\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nshuffle(nums.begin(), nums.end(), default_random_engine(seed));\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(vector<int> &nums) {\nfor (int i = 0; i < nums.size(); i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] == 1)\nreturn i;\n}\nreturn -1;\n}\n
    worst_best_time_complexity.py
    def random_numbers(n: int) -> list[int]:\n\"\"\"\u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a: 1, 2, ..., n \uff0c\u987a\u5e8f\u88ab\u6253\u4e71\"\"\"\n# \u751f\u6210\u6570\u7ec4 nums =: 1, 2, 3, ..., n\nnums = [i for i in range(1, n + 1)]\n# \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nrandom.shuffle(nums)\nreturn nums\ndef find_one(nums: list[int]) -> int:\n\"\"\"\u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\"\"\"\nfor i in range(len(nums)):\n# \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n# \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif nums[i] == 1:\nreturn i\nreturn -1\n
    worst_best_time_complexity.go
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfunc randomNumbers(n int) []int {\nnums := make([]int, n)\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor i := 0; i < n; i++ {\nnums[i] = i + 1\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nrand.Shuffle(len(nums), func(i, j int) {\nnums[i], nums[j] = nums[j], nums[i]\n})\nreturn nums\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums []int) int {\nfor i := 0; i < len(nums); i++ {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif nums[i] == 1 {\nreturn i\n}\n}\nreturn -1\n}\n
    worst_best_time_complexity.js
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfunction randomNumbers(n) {\nconst nums = Array(n);\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (let i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nfor (let i = 0; i < n; i++) {\nconst r = Math.floor(Math.random() * (i + 1));\nconst temp = nums[i];\nnums[i] = nums[r];\nnums[r] = temp;\n}\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums) {\nfor (let i = 0; i < nums.length; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] === 1) {\nreturn i;\n}\n}\nreturn -1;\n}\n
    worst_best_time_complexity.ts
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfunction randomNumbers(n: number): number[] {\nconst nums = Array(n);\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (let i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nfor (let i = 0; i < n; i++) {\nconst r = Math.floor(Math.random() * (i + 1));\nconst temp = nums[i];\nnums[i] = nums[r];\nnums[r] = temp;\n}\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums: number[]): number {\nfor (let i = 0; i < nums.length; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] === 1) {\nreturn i;\n}\n}\nreturn -1;\n}\n
    worst_best_time_complexity.c
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nint *randomNumbers(int n) {\n// \u5206\u914d\u5806\u533a\u5185\u5b58\uff08\u521b\u5efa\u4e00\u7ef4\u53ef\u53d8\u957f\u6570\u7ec4\uff1a\u6570\u7ec4\u4e2d\u5143\u7d20\u6570\u91cf\u4e3an\uff0c\u5143\u7d20\u7c7b\u578b\u4e3aint\uff09\nint *nums = (int *)malloc(n * sizeof(int));\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (int i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nfor (int i = n - 1; i > 0; i--) {\nint j = rand() % (i + 1);\nint temp = nums[i];\nnums[i] = nums[j];\nnums[j] = temp;\n}\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int *nums, int n) {\nfor (int i = 0; i < n; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] == 1)\nreturn i;\n}\nreturn -1;\n}\n
    worst_best_time_complexity.cs
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nint[] randomNumbers(int n) {\nint[] nums = new int[n];\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (int i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nfor (int i = 0; i < nums.Length; i++) {\nvar index = new Random().Next(i, nums.Length);\nvar tmp = nums[i];\nvar ran = nums[index];\nnums[i] = ran;\nnums[index] = tmp;\n}\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int[] nums) {\nfor (int i = 0; i < nums.Length; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] == 1)\nreturn i;\n}\nreturn -1;\n}\n
    worst_best_time_complexity.swift
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfunc randomNumbers(n: Int) -> [Int] {\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nvar nums = Array(1 ... n)\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nnums.shuffle()\nreturn nums\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums: [Int]) -> Int {\nfor i in nums.indices {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif nums[i] == 1 {\nreturn i\n}\n}\nreturn -1\n}\n
    worst_best_time_complexity.zig
    // \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71\npub fn randomNumbers(comptime n: usize) [n]i32 {\nvar nums: [n]i32 = undefined;\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (nums) |*num, i| {\nnum.* = @intCast(i32, i) + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nconst rand = std.crypto.random;\nrand.shuffle(i32, &nums);\nreturn nums;\n}\n// \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\npub fn findOne(nums: []i32) i32 {\nfor (nums) |num, i| {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (num == 1) return @intCast(i32, i);\n}\nreturn -1;\n}\n
    worst_best_time_complexity.dart
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nList<int> randomNumbers(int n) {\nfinal nums = List.filled(n, 0);\n// \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\nfor (var i = 0; i < n; i++) {\nnums[i] = i + 1;\n}\n// \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\nnums.shuffle();\nreturn nums;\n}\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(List<int> nums) {\nfor (var i = 0; i < nums.length; i++) {\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5934\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 O(1)\n// \u5f53\u5143\u7d20 1 \u5728\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u8fbe\u5230\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nif (nums[i] == 1) return i;\n}\nreturn -1;\n}\n

    Tip

    \u5b9e\u9645\u5e94\u7528\u4e2d\u6211\u4eec\u5f88\u5c11\u4f7f\u7528\u300c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u300d\uff0c\u56e0\u4e3a\u901a\u5e38\u53ea\u6709\u5728\u5f88\u5c0f\u6982\u7387\u4e0b\u624d\u80fd\u8fbe\u5230\uff0c\u53ef\u80fd\u4f1a\u5e26\u6765\u4e00\u5b9a\u7684\u8bef\u5bfc\u6027\u3002\u76f8\u53cd\uff0c\u300c\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u300d\u66f4\u4e3a\u5b9e\u7528\uff0c\u56e0\u4e3a\u5b83\u7ed9\u51fa\u4e86\u4e00\u4e2a\u201c\u6548\u7387\u5b89\u5168\u503c\u201d\uff0c\u8ba9\u6211\u4eec\u53ef\u4ee5\u653e\u5fc3\u5730\u4f7f\u7528\u7b97\u6cd5\u3002

    \u4ece\u4e0a\u8ff0\u793a\u4f8b\u53ef\u4ee5\u770b\u51fa\uff0c\u6700\u5dee\u6216\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u53ea\u51fa\u73b0\u5728\u201c\u7279\u6b8a\u5206\u5e03\u7684\u6570\u636e\u201d\u4e2d\uff0c\u8fd9\u4e9b\u60c5\u51b5\u7684\u51fa\u73b0\u6982\u7387\u53ef\u80fd\u5f88\u5c0f\uff0c\u56e0\u6b64\u5e76\u4e0d\u80fd\u6700\u771f\u5b9e\u5730\u53cd\u6620\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u3002\u76f8\u8f83\u4e4b\u4e0b\uff0c\u300c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u300d\u53ef\u4ee5\u4f53\u73b0\u7b97\u6cd5\u5728\u968f\u673a\u8f93\u5165\u6570\u636e\u4e0b\u7684\u8fd0\u884c\u6548\u7387\uff0c\u7528 \\(\\Theta\\) \u8bb0\u53f7\u6765\u8868\u793a\u3002

    \u5bf9\u4e8e\u90e8\u5206\u7b97\u6cd5\uff0c\u6211\u4eec\u53ef\u4ee5\u7b80\u5355\u5730\u63a8\u7b97\u51fa\u968f\u673a\u6570\u636e\u5206\u5e03\u4e0b\u7684\u5e73\u5747\u60c5\u51b5\u3002\u6bd4\u5982\u4e0a\u8ff0\u793a\u4f8b\uff0c\u7531\u4e8e\u8f93\u5165\u6570\u7ec4\u662f\u88ab\u6253\u4e71\u7684\uff0c\u56e0\u6b64\u5143\u7d20 \\(1\\) \u51fa\u73b0\u5728\u4efb\u610f\u7d22\u5f15\u7684\u6982\u7387\u90fd\u662f\u76f8\u7b49\u7684\uff0c\u90a3\u4e48\u7b97\u6cd5\u7684\u5e73\u5747\u5faa\u73af\u6b21\u6570\u5219\u662f\u6570\u7ec4\u957f\u5ea6\u7684\u4e00\u534a \\(\\frac{n}{2}\\) \uff0c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(\\Theta(\\frac{n}{2}) = \\Theta(n)\\) \u3002

    \u4f46\u5728\u5b9e\u9645\u5e94\u7528\u4e2d\uff0c\u5c24\u5176\u662f\u8f83\u4e3a\u590d\u6742\u7684\u7b97\u6cd5\uff0c\u8ba1\u7b97\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u6bd4\u8f83\u56f0\u96be\uff0c\u56e0\u4e3a\u5f88\u96be\u7b80\u4fbf\u5730\u5206\u6790\u51fa\u5728\u6570\u636e\u5206\u5e03\u4e0b\u7684\u6574\u4f53\u6570\u5b66\u671f\u671b\u3002\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u901a\u5e38\u4f7f\u7528\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4f5c\u4e3a\u7b97\u6cd5\u6548\u7387\u7684\u8bc4\u5224\u6807\u51c6\u3002

    \u4e3a\u4ec0\u4e48\u5f88\u5c11\u770b\u5230 \\(\\Theta\\) \u7b26\u53f7\uff1f

    \u53ef\u80fd\u7531\u4e8e \\(O\\) \u7b26\u53f7\u8fc7\u4e8e\u6717\u6717\u4e0a\u53e3\uff0c\u6211\u4eec\u5e38\u5e38\u4f7f\u7528\u5b83\u6765\u8868\u793a\u300c\u5e73\u5747\u590d\u6742\u5ea6\u300d\uff0c\u4f46\u4ece\u4e25\u683c\u610f\u4e49\u4e0a\u770b\uff0c\u8fd9\u79cd\u505a\u6cd5\u5e76\u4e0d\u89c4\u8303\u3002\u5728\u672c\u4e66\u548c\u5176\u4ed6\u8d44\u6599\u4e2d\uff0c\u82e5\u9047\u5230\u7c7b\u4f3c\u201c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n)\\)\u201d\u7684\u8868\u8ff0\uff0c\u8bf7\u5c06\u5176\u76f4\u63a5\u7406\u89e3\u4e3a \\(\\Theta(n)\\) \u3002

    "},{"location":"chapter_data_structure/","title":"3. \u00a0 \u6570\u636e\u7ed3\u6784","text":""},{"location":"chapter_data_structure/basic_data_types/","title":"3.2. \u00a0 \u57fa\u672c\u6570\u636e\u7c7b\u578b","text":"

    \u8c08\u53ca\u8ba1\u7b97\u673a\u4e2d\u7684\u6570\u636e\uff0c\u6211\u4eec\u4f1a\u60f3\u5230\u6587\u672c\u3001\u56fe\u7247\u3001\u89c6\u9891\u3001\u8bed\u97f3\u30013D \u6a21\u578b\u7b49\u5404\u79cd\u5f62\u5f0f\u3002\u5c3d\u7ba1\u8fd9\u4e9b\u6570\u636e\u7684\u7ec4\u7ec7\u5f62\u5f0f\u5404\u5f02\uff0c\u4f46\u5b83\u4eec\u90fd\u7531\u5404\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6784\u6210\u3002

    \u57fa\u672c\u6570\u636e\u7c7b\u578b\u662f CPU \u53ef\u4ee5\u76f4\u63a5\u8fdb\u884c\u8fd0\u7b97\u7684\u7c7b\u578b\uff0c\u5728\u7b97\u6cd5\u4e2d\u76f4\u63a5\u88ab\u4f7f\u7528\u3002\u5b83\u5305\u62ec\uff1a

    • \u6574\u6570\u7c7b\u578b byte , short , int , long \uff1b
    • \u6d6e\u70b9\u6570\u7c7b\u578b float , double \uff0c\u7528\u4e8e\u8868\u793a\u5c0f\u6570\uff1b
    • \u5b57\u7b26\u7c7b\u578b char \uff0c\u7528\u4e8e\u8868\u793a\u5404\u79cd\u8bed\u8a00\u7684\u5b57\u6bcd\u3001\u6807\u70b9\u7b26\u53f7\u3001\u751a\u81f3\u8868\u60c5\u7b26\u53f7\u7b49\uff1b
    • \u5e03\u5c14\u7c7b\u578b bool \uff0c\u7528\u4e8e\u8868\u793a\u201c\u662f\u201d\u4e0e\u201c\u5426\u201d\u5224\u65ad\uff1b

    \u6240\u6709\u57fa\u672c\u6570\u636e\u7c7b\u578b\u90fd\u4ee5\u4e8c\u8fdb\u5236\u7684\u5f62\u5f0f\u5b58\u50a8\u5728\u8ba1\u7b97\u673a\u4e2d\u3002\u5728\u8ba1\u7b97\u673a\u4e2d\uff0c\u6211\u4eec\u5c06 \\(1\\) \u4e2a\u4e8c\u8fdb\u5236\u4f4d\u79f0\u4e3a \\(1\\) \u6bd4\u7279\uff0c\u5e76\u89c4\u5b9a \\(1\\) \u5b57\u8282\uff08byte\uff09\u7531 \\(8\\) \u6bd4\u7279\uff08bits\uff09\u7ec4\u6210\u3002\u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u53d6\u503c\u8303\u56f4\u53d6\u51b3\u4e8e\u5176\u5360\u7528\u7684\u7a7a\u95f4\u5927\u5c0f\uff0c\u4f8b\u5982\uff1a

    • \u6574\u6570\u7c7b\u578b byte \u5360\u7528 \\(1\\) byte = \\(8\\) bits \uff0c\u53ef\u4ee5\u8868\u793a \\(2^{8}\\) \u4e2a\u4e0d\u540c\u7684\u6570\u5b57\uff1b
    • \u6574\u6570\u7c7b\u578b int \u5360\u7528 \\(4\\) bytes = \\(32\\) bits \uff0c\u53ef\u4ee5\u8868\u793a \\(2^{32}\\) \u4e2a\u6570\u5b57\uff1b

    \u4e0b\u8868\u5217\u4e3e\u4e86\u5404\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u5360\u7528\u7a7a\u95f4\u3001\u53d6\u503c\u8303\u56f4\u548c\u9ed8\u8ba4\u503c\u3002\u6b64\u8868\u683c\u65e0\u9700\u786c\u80cc\uff0c\u5927\u81f4\u7406\u89e3\u5373\u53ef\uff0c\u9700\u8981\u65f6\u53ef\u4ee5\u901a\u8fc7\u67e5\u8868\u6765\u56de\u5fc6\u3002

    \u7c7b\u578b \u7b26\u53f7 \u5360\u7528\u7a7a\u95f4 \u6700\u5c0f\u503c \u6700\u5927\u503c \u9ed8\u8ba4\u503c \u6574\u6570 byte 1 byte \\(-2^7\\) (\\(-128\\)) \\(2^7 - 1\\) (\\(127\\)) \\(0\\) short 2 bytes \\(-2^{15}\\) \\(2^{15} - 1\\) \\(0\\) int 4 bytes \\(-2^{31}\\) \\(2^{31} - 1\\) \\(0\\) long 8 bytes \\(-2^{63}\\) \\(2^{63} - 1\\) \\(0\\) \u6d6e\u70b9\u6570 float 4 bytes \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0 f\\) double 8 bytes \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) \\(0.0\\) \u5b57\u7b26 char 2 bytes / 1 byte \\(0\\) \\(2^{16} - 1\\) \\(0\\) \u5e03\u5c14 bool 1 byte \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\)

    Tip

    \u5b57\u7b26\u7684\u5360\u7528\u7a7a\u95f4\u5927\u5c0f\u53d6\u51b3\u4e8e\u7f16\u7a0b\u8bed\u8a00\u91c7\u7528\u7684\u5b57\u7b26\u7f16\u7801\u65b9\u6cd5\uff0c\u8be6\u89c1\u300c\u5b57\u7b26\u7f16\u7801\u300d\u7ae0\u8282\u3002

    \u73b0\u4ee3\u8ba1\u7b97\u673a CPU \u901a\u5e38\u5c06 1 \u5b57\u8282\u4f5c\u4e3a\u6700\u5c0f\u5bfb\u5740\u5185\u5b58\u5355\u5143\u3002\u56e0\u6b64\uff0c\u5373\u4f7f\u8868\u793a\u5e03\u5c14\u91cf\u4ec5\u9700 1 \u4f4d\uff08\\(0\\) \u6216 \\(1\\)\uff09\uff0c\u5b83\u5728\u5185\u5b58\u4e2d\u901a\u5e38\u88ab\u5b58\u50a8\u4e3a 1 \u5b57\u8282\u3002

    \u90a3\u4e48\uff0c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u4e0e\u6570\u636e\u7ed3\u6784\u4e4b\u95f4\u6709\u4ec0\u4e48\u8054\u7cfb\u4e0e\u533a\u522b\u5462\uff1f\u6211\u4eec\u77e5\u9053\uff0c\u6570\u636e\u7ed3\u6784\u662f\u5728\u8ba1\u7b97\u673a\u4e2d\u7ec4\u7ec7\u4e0e\u5b58\u50a8\u6570\u636e\u7684\u65b9\u5f0f\u3002\u5b83\u7684\u4e3b\u8bed\u662f\u201c\u7ed3\u6784\u201d\uff0c\u800c\u975e\u201c\u6570\u636e\u201d\u3002\u5982\u679c\u60f3\u8981\u8868\u793a\u201c\u4e00\u6392\u6570\u5b57\u201d\uff0c\u6211\u4eec\u81ea\u7136\u4f1a\u60f3\u5230\u4f7f\u7528\u6570\u7ec4\u3002\u8fd9\u662f\u56e0\u4e3a\u6570\u7ec4\u7684\u7ebf\u6027\u7ed3\u6784\u53ef\u4ee5\u8868\u793a\u6570\u5b57\u7684\u76f8\u90bb\u5173\u7cfb\u548c\u987a\u5e8f\u5173\u7cfb\uff0c\u4f46\u81f3\u4e8e\u5b58\u50a8\u7684\u5185\u5bb9\u662f\u6574\u6570 int \u3001\u5c0f\u6570 float \u3001\u8fd8\u662f\u5b57\u7b26 char \uff0c\u5219\u4e0e\u201c\u6570\u636e\u7ed3\u6784\u201d\u65e0\u5173\u3002

    \u6362\u53e5\u8bdd\u8bf4\uff0c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u63d0\u4f9b\u4e86\u6570\u636e\u7684\u201c\u5185\u5bb9\u7c7b\u578b\u201d\uff0c\u800c\u6570\u636e\u7ed3\u6784\u63d0\u4f9b\u4e86\u6570\u636e\u7684\u201c\u7ec4\u7ec7\u65b9\u5f0f\u201d\u3002\u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4e0d\u540c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] booleans = new boolean[5];\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool booleans[5];\n
    # Python \u7684 list \u53ef\u4ee5\u81ea\u7531\u5b58\u50a8\u5404\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u548c\u5bf9\u8c61\nlist = [0, 0.0, 'a', False]\n
    // \u4f7f\u7528\u591a\u79cd\u300c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u300d\u6765\u521d\u59cb\u5316\u300c\u6570\u7ec4\u300d\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar booleans = [5]bool{}\n
    // JavaScript \u7684\u6570\u7ec4\u53ef\u4ee5\u81ea\u7531\u5b58\u50a8\u5404\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u548c\u5bf9\u8c61\nconst array = [0, 0.0, 'a', false];\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst booleans: boolean[] = [];\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool booleans[10];\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] booleans = new bool[5];\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nlet numbers = Array(repeating: Int(), count: 5)\nlet decimals = Array(repeating: Double(), count: 5)\nlet characters = Array(repeating: Character(\"a\"), count: 5)\nlet booleans = Array(repeating: Bool(), count: 5)\n
    \n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nList<int> numbers = List.filled(5, 0);\nList<double> decimals = List.filled(5, 0.0);\nList<String> characters = List.filled(5, 'a');\nList<bool> booleans = List.filled(5, false);\n
    "},{"location":"chapter_data_structure/character_encoding/","title":"3.4. \u00a0 \u5b57\u7b26\u7f16\u7801 *","text":"

    \u5728\u8ba1\u7b97\u673a\u4e2d\uff0c\u6240\u6709\u6570\u636e\u90fd\u662f\u4ee5\u4e8c\u8fdb\u5236\u6570\u7684\u5f62\u5f0f\u5b58\u50a8\u7684\uff0c\u5b57\u7b26 char \u4e5f\u4e0d\u4f8b\u5916\u3002\u4e3a\u4e86\u8868\u793a\u5b57\u7b26\uff0c\u6211\u4eec\u9700\u8981\u5efa\u7acb\u4e00\u5957\u300c\u5b57\u7b26\u96c6\u300d\uff0c\u89c4\u5b9a\u6bcf\u4e2a\u5b57\u7b26\u548c\u4e8c\u8fdb\u5236\u6570\u4e4b\u95f4\u7684\u4e00\u4e00\u5bf9\u5e94\u5173\u7cfb\u3002\u6709\u4e86\u5b57\u7b26\u96c6\u4e4b\u540e\uff0c\u8ba1\u7b97\u673a\u5c31\u53ef\u4ee5\u901a\u8fc7\u67e5\u8868\u5b8c\u6210\u4e8c\u8fdb\u5236\u6570\u5230\u5b57\u7b26\u7684\u8f6c\u6362\u3002

    "},{"location":"chapter_data_structure/character_encoding/#341-ascii","title":"3.4.1. \u00a0 ASCII \u5b57\u7b26\u96c6","text":"

    \u300cASCII \u7801\u300d\u662f\u6700\u65e9\u51fa\u73b0\u7684\u5b57\u7b26\u96c6\uff0c\u5168\u79f0\u4e3a\u201c\u7f8e\u56fd\u6807\u51c6\u4fe1\u606f\u4ea4\u6362\u4ee3\u7801\u201d\u3002\u5b83\u4f7f\u7528 7 \u4f4d\u4e8c\u8fdb\u5236\u6570\uff08\u5373\u4e00\u4e2a\u5b57\u8282\u7684\u4f4e 7 \u4f4d\uff09\u8868\u793a\u4e00\u4e2a\u5b57\u7b26\uff0c\u6700\u591a\u80fd\u591f\u8868\u793a 128 \u4e2a\u4e0d\u540c\u7684\u5b57\u7b26\u3002\u8fd9\u5305\u62ec\u82f1\u6587\u5b57\u6bcd\u7684\u5927\u5c0f\u5199\u3001\u6570\u5b57 0-9 \u3001\u4e00\u4e9b\u6807\u70b9\u7b26\u53f7\uff0c\u4ee5\u53ca\u4e00\u4e9b\u63a7\u5236\u5b57\u7b26\uff08\u5982\u6362\u884c\u7b26\u548c\u5236\u8868\u7b26\uff09\u3002

    Fig. ASCII \u7801

    \u7136\u800c\uff0cASCII \u7801\u4ec5\u80fd\u591f\u8868\u793a\u82f1\u6587\u3002\u968f\u7740\u8ba1\u7b97\u673a\u7684\u5168\u7403\u5316\uff0c\u8bde\u751f\u4e86\u4e00\u79cd\u80fd\u591f\u8868\u793a\u66f4\u591a\u8bed\u8a00\u7684\u5b57\u7b26\u96c6\u300cEASCII\u300d\u3002\u5b83\u5728 ASCII \u7684 7 \u4f4d\u57fa\u7840\u4e0a\u6269\u5c55\u5230 8 \u4f4d\uff0c\u80fd\u591f\u8868\u793a 256 \u4e2a\u4e0d\u540c\u7684\u5b57\u7b26\u3002\u5728\u4e16\u754c\u8303\u56f4\u5185\uff0c\u9646\u7eed\u51fa\u73b0\u4e86\u4e00\u6279\u9002\u7528\u4e8e\u4e0d\u540c\u5730\u533a\u7684 EASCII \u5b57\u7b26\u96c6\u3002\u8fd9\u4e9b\u5b57\u7b26\u96c6\u7684\u524d 128 \u4e2a\u5b57\u7b26\u7edf\u4e00\u4e3a ASCII \u7801\uff0c\u540e 128 \u4e2a\u5b57\u7b26\u5b9a\u4e49\u4e0d\u540c\uff0c\u4ee5\u9002\u5e94\u4e0d\u540c\u8bed\u8a00\u7684\u9700\u6c42\u3002

    "},{"location":"chapter_data_structure/character_encoding/#342-gbk","title":"3.4.2. \u00a0 GBK \u5b57\u7b26\u96c6","text":"

    \u540e\u6765\u4eba\u4eec\u53d1\u73b0\uff0cEASCII \u7801\u4ecd\u7136\u65e0\u6cd5\u6ee1\u8db3\u8bb8\u591a\u8bed\u8a00\u7684\u5b57\u7b26\u6570\u91cf\u8981\u6c42\u3002\u4f8b\u5982\uff0c\u6c49\u5b57\u5927\u7ea6\u6709\u8fd1\u5341\u4e07\u4e2a\uff0c\u5149\u65e5\u5e38\u4f7f\u7528\u7684\u5c31\u6709\u51e0\u5343\u4e2a\u3002\u4e2d\u56fd\u56fd\u5bb6\u6807\u51c6\u603b\u5c40\u4e8e 1980 \u5e74\u53d1\u5e03\u4e86\u300cGB2312\u300d\u5b57\u7b26\u96c6\uff0c\u5176\u6536\u5f55\u4e86 6763 \u4e2a\u6c49\u5b57\uff0c\u57fa\u672c\u6ee1\u8db3\u4e86\u6c49\u5b57\u7684\u8ba1\u7b97\u673a\u5904\u7406\u9700\u8981\u3002

    \u7136\u800c\uff0cGB2312 \u65e0\u6cd5\u5904\u7406\u90e8\u5206\u7684\u7f55\u89c1\u5b57\u548c\u7e41\u4f53\u5b57\u3002\u4e4b\u540e\u5728 GB2312 \u7684\u57fa\u7840\u4e0a\uff0c\u6269\u5c55\u5f97\u5230\u4e86\u300cGBK\u300d\u5b57\u7b26\u96c6\uff0c\u5b83\u5171\u6536\u5f55\u4e86 21886 \u4e2a\u6c49\u5b57\u3002\u5728 GBK \u7f16\u7801\u65b9\u6848\u4e2d\uff0cASCII \u5b57\u7b26\u4f7f\u7528\u4e00\u4e2a\u5b57\u8282\u8868\u793a\uff0c\u6c49\u5b57\u4f7f\u7528\u4e24\u4e2a\u5b57\u8282\u8868\u793a\u3002

    "},{"location":"chapter_data_structure/character_encoding/#343-unicode","title":"3.4.3. \u00a0 Unicode \u5b57\u7b26\u96c6","text":"

    \u968f\u7740\u8ba1\u7b97\u673a\u7684\u84ec\u52c3\u53d1\u5c55\uff0c\u5b57\u7b26\u96c6\u4e0e\u7f16\u7801\u6807\u51c6\u767e\u82b1\u9f50\u653e\uff0c\u800c\u8fd9\u5e26\u6765\u4e86\u8bb8\u591a\u95ee\u9898\u3002\u4e00\u65b9\u9762\uff0c\u8fd9\u4e9b\u5b57\u7b26\u96c6\u4e00\u822c\u53ea\u5b9a\u4e49\u4e86\u7279\u5b9a\u8bed\u8a00\u7684\u5b57\u7b26\uff0c\u65e0\u6cd5\u5728\u591a\u8bed\u8a00\u73af\u5883\u4e0b\u6b63\u5e38\u5de5\u4f5c\uff1b\u53e6\u4e00\u65b9\u9762\uff0c\u540c\u4e00\u79cd\u8bed\u8a00\u4e5f\u5b58\u5728\u591a\u79cd\u5b57\u7b26\u96c6\u6807\u51c6\uff0c\u5982\u679c\u4e24\u53f0\u7535\u8111\u5b89\u88c5\u7684\u662f\u4e0d\u540c\u7684\u7f16\u7801\u6807\u51c6\uff0c\u5219\u5728\u4fe1\u606f\u4f20\u9012\u65f6\u5c31\u4f1a\u51fa\u73b0\u4e71\u7801\u3002

    \u90a3\u4e2a\u65f6\u4ee3\u7684\u4eba\u4eec\u5c31\u5728\u60f3\uff1a\u5982\u679c\u63a8\u51fa\u4e00\u4e2a\u8db3\u591f\u5b8c\u6574\u7684\u5b57\u7b26\u96c6\uff0c\u5c06\u4e16\u754c\u8303\u56f4\u5185\u7684\u6240\u6709\u8bed\u8a00\u548c\u7b26\u53f7\u90fd\u6536\u5f55\u5176\u4e2d\uff0c\u4e0d\u5c31\u53ef\u4ee5\u89e3\u51b3\u8de8\u8bed\u8a00\u73af\u5883\u548c\u4e71\u7801\u95ee\u9898\u4e86\u5417\uff1f\u5728\u8fd9\u79cd\u60f3\u6cd5\u7684\u9a71\u52a8\u4e0b\uff0c\u4e00\u4e2a\u5927\u800c\u5168\u7684\u5b57\u7b26\u96c6 Unicode \u5e94\u8fd0\u800c\u751f\u3002

    \u300cUnicode\u300d\u7684\u5168\u79f0\u4e3a\u201c\u7edf\u4e00\u5b57\u7b26\u7f16\u7801\u201d\uff0c\u7406\u8bba\u4e0a\u80fd\u5bb9\u7eb3\u4e00\u767e\u591a\u4e07\u4e2a\u5b57\u7b26\u3002\u5b83\u81f4\u529b\u4e8e\u5c06\u5168\u7403\u8303\u56f4\u5185\u7684\u5b57\u7b26\u7eb3\u5165\u5230\u7edf\u4e00\u7684\u5b57\u7b26\u96c6\u4e4b\u4e2d\uff0c\u63d0\u4f9b\u4e00\u79cd\u901a\u7528\u7684\u5b57\u7b26\u96c6\u6765\u5904\u7406\u548c\u663e\u793a\u5404\u79cd\u8bed\u8a00\u6587\u5b57\uff0c\u51cf\u5c11\u56e0\u4e3a\u7f16\u7801\u6807\u51c6\u4e0d\u540c\u800c\u4ea7\u751f\u7684\u4e71\u7801\u95ee\u9898\u3002

    \u81ea 1991 \u5e74\u53d1\u5e03\u4ee5\u6765\uff0cUnicode \u4e0d\u65ad\u6269\u5145\u65b0\u7684\u8bed\u8a00\u4e0e\u5b57\u7b26\u3002\u622a\u6b62 2022 \u5e74 9 \u6708\uff0cUnicode \u5df2\u7ecf\u5305\u542b 149186 \u4e2a\u5b57\u7b26\uff0c\u5305\u62ec\u5404\u79cd\u8bed\u8a00\u7684\u5b57\u7b26\u3001\u7b26\u53f7\u3001\u751a\u81f3\u662f\u8868\u60c5\u7b26\u53f7\u7b49\u3002\u5728\u5e9e\u5927\u7684 Unicode \u5b57\u7b26\u96c6\u4e2d\uff0c\u5e38\u7528\u7684\u5b57\u7b26\u5360\u7528 2 \u5b57\u8282\uff0c\u6709\u4e9b\u751f\u50fb\u7684\u5b57\u7b26\u5360 3 \u5b57\u8282\u751a\u81f3 4 \u5b57\u8282\u3002

    Unicode \u662f\u4e00\u79cd\u5b57\u7b26\u96c6\u6807\u51c6\uff0c\u672c\u8d28\u4e0a\u662f\u7ed9\u6bcf\u4e2a\u5b57\u7b26\u5206\u914d\u4e00\u4e2a\u7f16\u53f7\uff08\u79f0\u4e3a\u201c\u7801\u70b9\u201d\uff09\uff0c\u4f46\u5b83\u5e76\u6ca1\u6709\u89c4\u5b9a\u5728\u8ba1\u7b97\u673a\u4e2d\u5982\u4f55\u5b58\u50a8\u8fd9\u4e9b\u5b57\u7b26\u7801\u70b9\u3002\u6211\u4eec\u4e0d\u7981\u4f1a\u95ee\uff1a\u5f53\u591a\u79cd\u957f\u5ea6\u7684 Unicode \u7801\u70b9\u540c\u65f6\u51fa\u73b0\u5728\u540c\u4e00\u4e2a\u6587\u672c\u4e2d\u65f6\uff0c\u7cfb\u7edf\u5982\u4f55\u89e3\u6790\u5b57\u7b26\uff1f\u4f8b\u5982\uff0c\u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a 2 \u5b57\u8282\u7684\u7f16\u7801\uff0c\u7cfb\u7edf\u5982\u4f55\u786e\u8ba4\u5b83\u662f\u4e00\u4e2a 2 \u5b57\u8282\u7684\u5b57\u7b26\u8fd8\u662f\u4e24\u4e2a 1 \u5b57\u8282\u7684\u5b57\u7b26\uff1f

    \u5bf9\u4e8e\u4ee5\u4e0a\u95ee\u9898\uff0c\u4e00\u79cd\u76f4\u63a5\u7684\u89e3\u51b3\u65b9\u6848\u662f\u5c06\u6240\u6709\u5b57\u7b26\u5b58\u50a8\u4e3a\u7b49\u957f\u7684\u7f16\u7801\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u201cHello\u201d\u4e2d\u7684\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 1 \u5b57\u8282\uff0c\u201c\u7b97\u6cd5\u201d\u4e2d\u7684\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 2 \u5b57\u8282\u3002\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u9ad8\u4f4d\u586b 0 \uff0c\u5c06\u201cHello \u7b97\u6cd5\u201d\u4e2d\u7684\u6240\u6709\u5b57\u7b26\u90fd\u7f16\u7801\u4e3a 2 \u5b57\u8282\u957f\u5ea6\u3002\u8fd9\u6837\u7cfb\u7edf\u5c31\u53ef\u4ee5\u6bcf\u9694 2 \u5b57\u8282\u89e3\u6790\u4e00\u4e2a\u5b57\u7b26\uff0c\u6062\u590d\u51fa\u8fd9\u4e2a\u77ed\u8bed\u7684\u5185\u5bb9\u4e86\u3002

    Fig. Unicode \u7f16\u7801\u793a\u4f8b

    \u7136\u800c\uff0cASCII \u7801\u5df2\u7ecf\u5411\u6211\u4eec\u8bc1\u660e\uff0c\u7f16\u7801\u82f1\u6587\u53ea\u9700\u8981 1 \u5b57\u8282\u3002\u82e5\u91c7\u7528\u4e0a\u8ff0\u65b9\u6848\uff0c\u82f1\u6587\u6587\u672c\u5360\u7528\u7a7a\u95f4\u7684\u5927\u5c0f\u5c06\u4f1a\u662f ASCII \u7f16\u7801\u4e0b\u5927\u5c0f\u7684 2 \u500d\uff0c\u975e\u5e38\u6d6a\u8d39\u5185\u5b58\u7a7a\u95f4\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u9700\u8981\u4e00\u79cd\u66f4\u52a0\u9ad8\u6548\u7684 Unicode \u7f16\u7801\u65b9\u6cd5\u3002

    "},{"location":"chapter_data_structure/character_encoding/#344-utf-8","title":"3.4.4. \u00a0 UTF-8 \u7f16\u7801","text":"

    \u76ee\u524d\uff0cUTF-8 \u5df2\u6210\u4e3a\u56fd\u9645\u4e0a\u4f7f\u7528\u6700\u5e7f\u6cdb\u7684 Unicode \u7f16\u7801\u65b9\u6cd5\u3002\u5b83\u662f\u4e00\u79cd\u53ef\u53d8\u957f\u7684\u7f16\u7801\uff0c\u4f7f\u7528 1 \u5230 4 \u4e2a\u5b57\u8282\u6765\u8868\u793a\u4e00\u4e2a\u5b57\u7b26\uff0c\u6839\u636e\u5b57\u7b26\u7684\u590d\u6742\u6027\u800c\u53d8\u3002ASCII \u5b57\u7b26\u53ea\u9700\u8981 1 \u4e2a\u5b57\u8282\uff0c\u62c9\u4e01\u5b57\u6bcd\u548c\u5e0c\u814a\u5b57\u6bcd\u9700\u8981 2 \u4e2a\u5b57\u8282\uff0c\u5e38\u7528\u7684\u4e2d\u6587\u5b57\u7b26\u9700\u8981 3 \u4e2a\u5b57\u8282\uff0c\u5176\u4ed6\u7684\u4e00\u4e9b\u751f\u50fb\u5b57\u7b26\u9700\u8981 4 \u4e2a\u5b57\u8282\u3002

    UTF-8 \u7684\u7f16\u7801\u89c4\u5219\u5e76\u4e0d\u590d\u6742\uff0c\u5206\u4e3a\u4e24\u79cd\u60c5\u51b5\uff1a

    • \u5bf9\u4e8e\u957f\u5ea6\u4e3a 1 \u5b57\u8282\u7684\u5b57\u7b26\uff0c\u5c06\u6700\u9ad8\u4f4d\u8bbe\u7f6e\u4e3a \\(0\\) \u3001\u5176\u4f59 7 \u4f4d\u8bbe\u7f6e\u4e3a Unicode \u7801\u70b9\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0cASCII \u5b57\u7b26\u5728 Unicode \u5b57\u7b26\u96c6\u4e2d\u5360\u636e\u4e86\u524d 128 \u4e2a\u7801\u70b9\u3002\u4e5f\u5c31\u662f\u8bf4\uff0cUTF-8 \u7f16\u7801\u53ef\u4ee5\u5411\u4e0b\u517c\u5bb9 ASCII \u7801\u3002\u8fd9\u610f\u5473\u7740\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528 UTF-8 \u6765\u89e3\u6790\u5e74\u4ee3\u4e45\u8fdc\u7684 ASCII \u7801\u6587\u672c\u3002
    • \u5bf9\u4e8e\u957f\u5ea6\u4e3a \\(n\\) \u5b57\u8282\u7684\u5b57\u7b26\uff08\u5176\u4e2d \\(n > 1\\)\uff09\uff0c\u5c06\u9996\u4e2a\u5b57\u8282\u7684\u9ad8 \\(n\\) \u4f4d\u90fd\u8bbe\u7f6e\u4e3a \\(1\\) \u3001\u7b2c \\(n + 1\\) \u4f4d\u8bbe\u7f6e\u4e3a \\(0\\) \uff1b\u4ece\u7b2c\u4e8c\u4e2a\u5b57\u8282\u5f00\u59cb\uff0c\u5c06\u6bcf\u4e2a\u5b57\u8282\u7684\u9ad8 2 \u4f4d\u90fd\u8bbe\u7f6e\u4e3a \\(10\\) \uff1b\u5176\u4f59\u6240\u6709\u4f4d\u7528\u4e8e\u586b\u5145\u5b57\u7b26\u7684 Unicode \u7801\u70b9\u3002

    \u4e0b\u56fe\u5c55\u793a\u4e86\u201cHello\u7b97\u6cd5\u201d\u5bf9\u5e94\u7684 UTF-8 \u7f16\u7801\u3002\u5c06\u6700\u9ad8 \\(n\\) \u4f4d\u8bbe\u7f6e\u4e3a \\(1\\) \u6bd4\u8f83\u5bb9\u6613\u7406\u89e3\uff0c\u53ef\u4ee5\u5411\u7cfb\u7edf\u6307\u51fa\u5b57\u7b26\u7684\u957f\u5ea6\u4e3a \\(n\\) \u3002\u90a3\u4e48\uff0c\u4e3a\u4ec0\u4e48\u8981\u5c06\u5176\u4f59\u6240\u6709\u5b57\u8282\u7684\u9ad8 2 \u4f4d\u90fd\u8bbe\u7f6e\u4e3a \\(10\\) \u5462\uff1f\u5b9e\u9645\u4e0a\uff0c\u8fd9\u4e2a \\(10\\) \u80fd\u591f\u8d77\u5230\u6821\u9a8c\u7b26\u7684\u4f5c\u7528\uff0c\u56e0\u4e3a\u5728 UTF-8 \u7f16\u7801\u89c4\u5219\u4e0b\uff0c\u4e0d\u53ef\u80fd\u6709\u5b57\u7b26\u7684\u6700\u9ad8\u4e24\u4f4d\u662f \\(10\\) \u3002\u8fd9\u662f\u56e0\u4e3a\u957f\u5ea6\u4e3a 1 \u5b57\u8282\u7684\u5b57\u7b26\u7684\u6700\u9ad8\u4e00\u4f4d\u662f \\(0\\) \u3002\u5047\u8bbe\u7cfb\u7edf\u4ece\u4e00\u4e2a\u9519\u8bef\u7684\u5b57\u8282\u5f00\u59cb\u89e3\u6790\u6587\u672c\uff0c\u5b57\u8282\u5934\u90e8\u7684 \\(10\\) \u80fd\u591f\u5e2e\u52a9\u7cfb\u7edf\u5feb\u901f\u7684\u5224\u65ad\u51fa\u5f02\u5e38\u3002

    Fig. UTF-8 \u7f16\u7801\u793a\u4f8b

    \u9664\u4e86 UTF-8 \u4e4b\u5916\uff0c\u5e38\u89c1\u7684\u7f16\u7801\u65b9\u5f0f\u8fd8\u5305\u62ec UTF-16 \u548c UTF-32 \u3002\u5b83\u4eec\u4e3a Unicode \u5b57\u7b26\u96c6\u63d0\u4f9b\u4e86\u4e0d\u540c\u7684\u7f16\u7801\u65b9\u6cd5\u3002

    • UTF-16 \u7f16\u7801\uff1a\u4f7f\u7528 2 \u6216 4 \u4e2a\u5b57\u8282\u6765\u8868\u793a\u4e00\u4e2a\u5b57\u7b26\u3002\u6240\u6709\u7684 ASCII \u5b57\u7b26\u548c\u5f88\u591a\u5e38\u7528\u7684\u975e\u82f1\u6587\u5b57\u7b26\uff0c\u90fd\u7528 2 \u4e2a\u5b57\u8282\u8868\u793a\uff1b\u5c11\u6570\u5b57\u7b26\u9700\u8981\u7528\u5230 4 \u4e2a\u5b57\u8282\u8868\u793a\u3002\u5bf9\u4e8e 2 \u5b57\u8282\u7684\u5b57\u7b26\uff0cUTF-16 \u7f16\u7801\u4e0e Unicode \u7801\u70b9\u76f8\u7b49\u3002
    • UTF-32 \u7f16\u7801\uff1a\u6bcf\u4e2a\u5b57\u7b26\u90fd\u4f7f\u7528 4 \u4e2a\u5b57\u8282\u3002\u8fd9\u610f\u5473\u7740 UTF-32 \u4f1a\u6bd4 UTF-8 \u548c UTF-16 \u66f4\u5360\u7528\u7a7a\u95f4\uff0c\u7279\u522b\u662f\u5bf9\u4e8e\u4e3b\u8981\u4f7f\u7528 ASCII \u5b57\u7b26\u7684\u6587\u672c\u3002

    \u4ece\u5b58\u50a8\u7a7a\u95f4\u7684\u89d2\u5ea6\u770b\uff0c\u4f7f\u7528 UTF-8 \u8868\u793a\u82f1\u6587\u5b57\u7b26\u975e\u5e38\u9ad8\u6548\uff0c\u56e0\u4e3a\u5b83\u4ec5\u9700 1 \u4e2a\u5b57\u8282\uff1b\u4f7f\u7528 UTF-16 \u7f16\u7801\u67d0\u4e9b\u975e\u82f1\u6587\u5b57\u7b26\uff08\u4f8b\u5982\u4e2d\u6587\uff09\u4f1a\u66f4\u52a0\u9ad8\u6548\uff0c\u56e0\u4e3a\u5b83\u53ea\u9700\u8981 2 \u4e2a\u5b57\u8282\uff0c\u800c UTF-8 \u53ef\u80fd\u9700\u8981 3 \u4e2a\u5b57\u8282\u3002\u4ece\u517c\u5bb9\u6027\u7684\u89d2\u5ea6\u770b\uff0cUTF-8 \u7684\u901a\u7528\u6027\u6700\u4f73\uff0c\u8bb8\u591a\u5de5\u5177\u548c\u5e93\u90fd\u4f18\u5148\u652f\u6301 UTF-8 \u3002

    "},{"location":"chapter_data_structure/character_encoding/#345","title":"3.4.5. \u00a0 \u7f16\u7a0b\u8bed\u8a00\u7684\u5b57\u7b26\u7f16\u7801","text":"

    \u5bf9\u4e8e\u4ee5\u5f80\u7684\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\uff0c\u7a0b\u5e8f\u8fd0\u884c\u4e2d\u7684\u5b57\u7b26\u4e32\u90fd\u91c7\u7528 UTF-16 \u6216 UTF-32 \u8fd9\u7c7b\u7b49\u957f\u7684\u7f16\u7801\u3002\u8fd9\u662f\u56e0\u4e3a\u5728\u7b49\u957f\u7f16\u7801\u4e0b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5b57\u7b26\u4e32\u770b\u4f5c\u6570\u7ec4\u6765\u5904\u7406\uff0c\u5177\u4f53\u6765\u8bf4\uff1a

    • \u968f\u673a\u8bbf\u95ee: UTF-16 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u53ef\u4ee5\u5f88\u5bb9\u6613\u5730\u8fdb\u884c\u968f\u673a\u8bbf\u95ee\u3002UTF-8 \u662f\u4e00\u79cd\u53d8\u957f\u7f16\u7801\uff0c\u8981\u627e\u5230\u7b2c \\(i\\) \u4e2a\u5b57\u7b26\uff0c\u6211\u4eec\u9700\u8981\u4ece\u5b57\u7b26\u4e32\u7684\u5f00\u59cb\u5904\u904d\u5386\u5230\u7b2c \\(i\\) \u4e2a\u5b57\u7b26\uff0c\u8fd9\u9700\u8981 \\(O(n)\\) \u7684\u65f6\u95f4\u3002
    • \u5b57\u7b26\u8ba1\u6570: \u4e0e\u968f\u673a\u8bbf\u95ee\u7c7b\u4f3c\uff0c\u8ba1\u7b97 UTF-16 \u5b57\u7b26\u4e32\u7684\u957f\u5ea6\u4e5f\u662f \\(O(1)\\) \u7684\u64cd\u4f5c\u3002\u4f46\u662f\uff0c\u8ba1\u7b97 UTF-8 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u7684\u957f\u5ea6\u9700\u8981\u904d\u5386\u6574\u4e2a\u5b57\u7b26\u4e32\u3002
    • \u5b57\u7b26\u4e32\u64cd\u4f5c: \u5728 UTF-16 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u4e2d\uff0c\u5f88\u591a\u5b57\u7b26\u4e32\u64cd\u4f5c\uff08\u5982\u5206\u5272\u3001\u8fde\u63a5\u3001\u63d2\u5165\u3001\u5220\u9664\u7b49\uff09\u90fd\u66f4\u5bb9\u6613\u8fdb\u884c\u3002\u5728 UTF-8 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u4e0a\u8fdb\u884c\u8fd9\u4e9b\u64cd\u4f5c\u901a\u5e38\u9700\u8981\u989d\u5916\u7684\u8ba1\u7b97\uff0c\u4ee5\u786e\u4fdd\u4e0d\u4f1a\u4ea7\u751f\u65e0\u6548\u7684 UTF-8 \u7f16\u7801\u3002

    \u7f16\u7a0b\u8bed\u8a00\u7684\u5b57\u7b26\u7f16\u7801\u65b9\u6848\u8bbe\u8ba1\u662f\u4e00\u4e2a\u5f88\u6709\u8da3\u7684\u8bdd\u9898\uff0c\u6d89\u53ca\u5230\u8bb8\u591a\u56e0\u7d20\uff1a

    • Java \u7684 String \u7c7b\u578b\u4f7f\u7528 UTF-16 \u7f16\u7801\uff0c\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 2 \u5b57\u8282\u3002\u8fd9\u662f\u56e0\u4e3a Java \u8bed\u8a00\u8bbe\u8ba1\u4e4b\u521d\uff0c\u4eba\u4eec\u8ba4\u4e3a 16 \u4f4d\u8db3\u4ee5\u8868\u793a\u6240\u6709\u53ef\u80fd\u7684\u5b57\u7b26\u3002\u7136\u800c\uff0c\u8fd9\u662f\u4e00\u4e2a\u4e0d\u6b63\u786e\u7684\u5224\u65ad\u3002\u540e\u6765 Unicode \u89c4\u8303\u6269\u5c55\u5230\u4e86\u8d85\u8fc7 16 \u4f4d\uff0c\u6240\u4ee5 Java \u4e2d\u7684\u5b57\u7b26\u73b0\u5728\u53ef\u80fd\u7531\u4e00\u5bf9 16 \u4f4d\u7684\u503c\uff08\u79f0\u4e3a\u201c\u4ee3\u7406\u5bf9\u201d\uff09\u8868\u793a\u3002
    • JavaScript \u548c TypeScript \u7684\u5b57\u7b26\u4e32\u4f7f\u7528 UTF-16 \u7f16\u7801\u7684\u539f\u56e0\u4e0e Java \u7c7b\u4f3c\u3002\u5f53 JavaScript \u8bed\u8a00\u5728 1995 \u5e74\u88ab Netscape \u516c\u53f8\u9996\u6b21\u5f15\u5165\u65f6\uff0cUnicode \u8fd8\u5904\u4e8e\u76f8\u5bf9\u65e9\u671f\u7684\u9636\u6bb5\uff0c\u90a3\u65f6\u5019\u4f7f\u7528 16 \u4f4d\u7684\u7f16\u7801\u5c31\u8db3\u591f\u8868\u793a\u6240\u6709\u7684 Unicode \u5b57\u7b26\u4e86\u3002
    • C# \u4f7f\u7528 UTF-16 \u7f16\u7801\uff0c\u4e3b\u8981\u56e0\u4e3a .NET \u5e73\u53f0\u662f\u7531 Microsoft \u8bbe\u8ba1\u7684\uff0c\u800c Microsoft \u7684\u5f88\u591a\u6280\u672f\uff0c\u5305\u62ec Windows \u64cd\u4f5c\u7cfb\u7edf\uff0c\u90fd\u5e7f\u6cdb\u5730\u4f7f\u7528 UTF-16 \u7f16\u7801\u3002

    \u7531\u4e8e\u4ee5\u4e0a\u7f16\u7a0b\u8bed\u8a00\u5bf9\u5b57\u7b26\u6570\u91cf\u7684\u4f4e\u4f30\uff0c\u5b83\u4eec\u4e0d\u5f97\u4e0d\u91c7\u53d6\u201c\u4ee3\u7406\u5bf9\u201d\u7684\u65b9\u5f0f\u6765\u8868\u793a\u8d85\u8fc7 16 \u4f4d\u957f\u5ea6\u7684 Unicode \u5b57\u7b26\u3002\u8fd9\u662f\u4e00\u4e2a\u4e0d\u5f97\u5df2\u4e3a\u4e4b\u7684\u65e0\u5948\u4e4b\u4e3e\u3002\u4e00\u65b9\u9762\uff0c\u5305\u542b\u4ee3\u7406\u5bf9\u7684\u5b57\u7b26\u4e32\u4e2d\uff0c\u4e00\u4e2a\u5b57\u7b26\u53ef\u80fd\u5360\u7528 2 \u5b57\u8282\u6216 4 \u5b57\u8282\uff0c\u56e0\u6b64\u4e27\u5931\u4e86\u7b49\u957f\u7f16\u7801\u7684\u4f18\u52bf\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u5904\u7406\u4ee3\u7406\u5bf9\u9700\u8981\u589e\u52a0\u989d\u5916\u4ee3\u7801\uff0c\u8fd9\u589e\u52a0\u4e86\u7f16\u7a0b\u7684\u590d\u6742\u6027\u548c Debug \u96be\u5ea6\u3002

    \u51fa\u4e8e\u4ee5\u4e0a\u539f\u56e0\uff0c\u90e8\u5206\u7f16\u7a0b\u8bed\u8a00\u63d0\u51fa\u4e86\u4e0d\u540c\u7684\u7f16\u7801\u65b9\u6848\uff1a

    • Python 3 \u4f7f\u7528\u4e00\u79cd\u7075\u6d3b\u7684\u5b57\u7b26\u4e32\u8868\u793a\uff0c\u5b58\u50a8\u7684\u5b57\u7b26\u957f\u5ea6\u53d6\u51b3\u4e8e\u5b57\u7b26\u4e32\u4e2d\u6700\u5927\u7684 Unicode \u7801\u70b9\u3002\u5bf9\u4e8e\u5168\u90e8\u662f ASCII \u5b57\u7b26\u7684\u5b57\u7b26\u4e32\uff0c\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 1 \u4e2a\u5b57\u8282\uff1b\u5982\u679c\u5b57\u7b26\u4e32\u4e2d\u5305\u542b\u7684\u5b57\u7b26\u8d85\u51fa\u4e86 ASCII \u8303\u56f4\uff0c\u4f46\u5168\u90e8\u5728\u57fa\u672c\u591a\u8bed\u8a00\u5e73\u9762\uff08BMP\uff09\u5185\uff0c\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 2 \u4e2a\u5b57\u8282\uff1b\u5982\u679c\u5b57\u7b26\u4e32\u4e2d\u6709\u8d85\u51fa BMP \u7684\u5b57\u7b26\uff0c\u90a3\u4e48\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 4 \u4e2a\u5b57\u8282\u3002
    • Go \u8bed\u8a00\u7684 string \u7c7b\u578b\u5728\u5185\u90e8\u4f7f\u7528 UTF-8 \u7f16\u7801\u3002Go \u8bed\u8a00\u8fd8\u63d0\u4f9b\u4e86 rune \u7c7b\u578b\uff0c\u5b83\u7528\u4e8e\u8868\u793a\u5355\u4e2a Unicode \u7801\u70b9\u3002
    • Rust \u8bed\u8a00\u7684 str \u548c String \u7c7b\u578b\u5728\u5185\u90e8\u4f7f\u7528 UTF-8 \u7f16\u7801\u3002Rust \u4e5f\u63d0\u4f9b\u4e86 char \u7c7b\u578b\uff0c\u7528\u4e8e\u8868\u793a\u5355\u4e2a Unicode \u7801\u70b9\u3002

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u4ee5\u4e0a\u8ba8\u8bba\u7684\u90fd\u662f\u5b57\u7b26\u4e32\u5728\u7f16\u7a0b\u8bed\u8a00\u4e2d\u7684\u5b58\u50a8\u65b9\u5f0f\uff0c\u8fd9\u548c\u5b57\u7b26\u4e32\u5982\u4f55\u5728\u6587\u4ef6\u4e2d\u5b58\u50a8\u6216\u5728\u7f51\u7edc\u4e2d\u4f20\u8f93\u662f\u4e24\u4e2a\u4e0d\u540c\u7684\u95ee\u9898\u3002\u5728\u6587\u4ef6\u5b58\u50a8\u6216\u7f51\u7edc\u4f20\u8f93\u4e2d\uff0c\u6211\u4eec\u4e00\u822c\u4f1a\u5c06\u5b57\u7b26\u4e32\u7f16\u7801\u4e3a UTF-8 \u683c\u5f0f\uff0c\u4ee5\u8fbe\u5230\u6700\u4f18\u7684\u517c\u5bb9\u6027\u548c\u7a7a\u95f4\u6548\u7387\u3002

    "},{"location":"chapter_data_structure/classification_of_data_structure/","title":"3.1. \u00a0 \u6570\u636e\u7ed3\u6784\u5206\u7c7b","text":"

    \u6570\u636e\u7ed3\u6784\u53ef\u4ee5\u4ece\u903b\u8f91\u7ed3\u6784\u548c\u7269\u7406\u7ed3\u6784\u4e24\u4e2a\u7ef4\u5ea6\u8fdb\u884c\u5206\u7c7b\u3002

    "},{"location":"chapter_data_structure/classification_of_data_structure/#311","title":"3.1.1. \u00a0 \u903b\u8f91\u7ed3\u6784\uff1a\u7ebf\u6027\u4e0e\u975e\u7ebf\u6027","text":"

    \u300c\u903b\u8f91\u7ed3\u6784\u300d\u63ed\u793a\u4e86\u6570\u636e\u5143\u7d20\u4e4b\u95f4\u7684\u903b\u8f91\u5173\u7cfb\u3002\u5728\u6570\u7ec4\u548c\u94fe\u8868\u4e2d\uff0c\u6570\u636e\u6309\u7167\u987a\u5e8f\u4f9d\u6b21\u6392\u5217\uff0c\u4f53\u73b0\u4e86\u6570\u636e\u4e4b\u95f4\u7684\u7ebf\u6027\u5173\u7cfb\uff1b\u800c\u5728\u6811\u4e2d\uff0c\u6570\u636e\u4ece\u9876\u90e8\u5411\u4e0b\u6309\u5c42\u6b21\u6392\u5217\uff0c\u8868\u73b0\u51fa\u7956\u5148\u4e0e\u540e\u4ee3\u4e4b\u95f4\u7684\u6d3e\u751f\u5173\u7cfb\uff1b\u56fe\u5219\u7531\u8282\u70b9\u548c\u8fb9\u6784\u6210\uff0c\u53cd\u6620\u4e86\u590d\u6742\u7684\u7f51\u7edc\u5173\u7cfb\u3002

    \u903b\u8f91\u7ed3\u6784\u901a\u5e38\u5206\u4e3a\u201c\u7ebf\u6027\u201d\u548c\u201c\u975e\u7ebf\u6027\u201d\u4e24\u7c7b\u3002\u7ebf\u6027\u7ed3\u6784\u6bd4\u8f83\u76f4\u89c2\uff0c\u6307\u6570\u636e\u5728\u903b\u8f91\u5173\u7cfb\u4e0a\u5448\u7ebf\u6027\u6392\u5217\uff1b\u975e\u7ebf\u6027\u7ed3\u6784\u5219\u76f8\u53cd\uff0c\u5448\u975e\u7ebf\u6027\u6392\u5217\u3002

    • \u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff1a\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\uff1b
    • \u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff1a\u6811\u3001\u5806\u3001\u56fe\u3001\u54c8\u5e0c\u8868\uff1b

    Fig. \u7ebf\u6027\u4e0e\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784

    \u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\u53ef\u4ee5\u8fdb\u4e00\u6b65\u88ab\u5212\u5206\u4e3a\u6811\u5f62\u7ed3\u6784\u548c\u7f51\u72b6\u7ed3\u6784\u3002

    • \u7ebf\u6027\u7ed3\u6784\uff1a\u6570\u7ec4\u3001\u94fe\u8868\u3001\u961f\u5217\u3001\u6808\u3001\u54c8\u5e0c\u8868\uff0c\u5143\u7d20\u5b58\u5728\u4e00\u5bf9\u4e00\u7684\u987a\u5e8f\u5173\u7cfb\uff1b
    • \u6811\u5f62\u7ed3\u6784\uff1a\u6811\u3001\u5806\u3001\u54c8\u5e0c\u8868\uff0c\u5143\u7d20\u5b58\u5728\u4e00\u5bf9\u591a\u7684\u5173\u7cfb\uff1b
    • \u7f51\u72b6\u7ed3\u6784\uff1a\u56fe\uff0c\u5143\u7d20\u5b58\u5728\u591a\u5bf9\u591a\u7684\u5173\u7cfb\uff1b
    "},{"location":"chapter_data_structure/classification_of_data_structure/#312","title":"3.1.2. \u00a0 \u7269\u7406\u7ed3\u6784\uff1a\u8fde\u7eed\u4e0e\u79bb\u6563","text":"

    \u5728\u8ba1\u7b97\u673a\u4e2d\uff0c\u5185\u5b58\u548c\u786c\u76d8\u662f\u4e24\u79cd\u4e3b\u8981\u7684\u5b58\u50a8\u786c\u4ef6\u8bbe\u5907\u3002\u786c\u76d8\u4e3b\u8981\u7528\u4e8e\u957f\u671f\u5b58\u50a8\u6570\u636e\uff0c\u5bb9\u91cf\u8f83\u5927\uff08\u901a\u5e38\u53ef\u8fbe\u5230 TB \u7ea7\u522b\uff09\u3001\u901f\u5ea6\u8f83\u6162\u3002\u5185\u5b58\u7528\u4e8e\u8fd0\u884c\u7a0b\u5e8f\u65f6\u6682\u5b58\u6570\u636e\uff0c\u901f\u5ea6\u8f83\u5feb\uff0c\u4f46\u5bb9\u91cf\u8f83\u5c0f\uff08\u901a\u5e38\u4e3a GB \u7ea7\u522b\uff09\u3002

    \u5728\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\uff0c\u76f8\u5173\u6570\u636e\u90fd\u5b58\u50a8\u5728\u5185\u5b58\u4e2d\u3002\u4e0b\u56fe\u5c55\u793a\u4e86\u4e00\u4e2a\u8ba1\u7b97\u673a\u5185\u5b58\u6761\uff0c\u5176\u4e2d\u6bcf\u4e2a\u9ed1\u8272\u65b9\u5757\u90fd\u5305\u542b\u4e00\u5757\u5185\u5b58\u7a7a\u95f4\u3002\u6211\u4eec\u53ef\u4ee5\u5c06\u5185\u5b58\u60f3\u8c61\u6210\u4e00\u4e2a\u5de8\u5927\u7684 Excel \u8868\u683c\uff0c\u5176\u4e2d\u6bcf\u4e2a\u5355\u5143\u683c\u90fd\u53ef\u4ee5\u5b58\u50a8 1 byte \u7684\u6570\u636e\uff0c\u5728\u7b97\u6cd5\u8fd0\u884c\u65f6\uff0c\u6240\u6709\u6570\u636e\u90fd\u88ab\u5b58\u50a8\u5728\u8fd9\u4e9b\u5355\u5143\u683c\u4e2d\u3002

    \u7cfb\u7edf\u901a\u8fc7\u300c\u5185\u5b58\u5730\u5740 Memory Location\u300d\u6765\u8bbf\u95ee\u76ee\u6807\u5185\u5b58\u4f4d\u7f6e\u7684\u6570\u636e\u3002\u8ba1\u7b97\u673a\u6839\u636e\u7279\u5b9a\u89c4\u5219\u4e3a\u8868\u683c\u4e2d\u7684\u6bcf\u4e2a\u5355\u5143\u683c\u5206\u914d\u7f16\u53f7\uff0c\u786e\u4fdd\u6bcf\u4e2a\u5185\u5b58\u7a7a\u95f4\u90fd\u6709\u552f\u4e00\u7684\u5185\u5b58\u5730\u5740\u3002\u6709\u4e86\u8fd9\u4e9b\u5730\u5740\uff0c\u7a0b\u5e8f\u4fbf\u53ef\u4ee5\u8bbf\u95ee\u5185\u5b58\u4e2d\u7684\u6570\u636e\u3002

    Fig. \u5185\u5b58\u6761\u3001\u5185\u5b58\u7a7a\u95f4\u3001\u5185\u5b58\u5730\u5740

    \u5185\u5b58\u662f\u6240\u6709\u7a0b\u5e8f\u7684\u5171\u4eab\u8d44\u6e90\uff0c\u5f53\u5185\u5b58\u88ab\u67d0\u4e2a\u7a0b\u5e8f\u5360\u7528\u65f6\uff0c\u5176\u4ed6\u7a0b\u5e8f\u65e0\u6cd5\u540c\u65f6\u4f7f\u7528\u3002\u56e0\u6b64\uff0c\u5728\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u8bbe\u8ba1\u4e2d\uff0c\u5185\u5b58\u8d44\u6e90\u662f\u4e00\u4e2a\u91cd\u8981\u7684\u8003\u8651\u56e0\u7d20\u3002\u4f8b\u5982\uff0c\u7b97\u6cd5\u6240\u5360\u7528\u7684\u5185\u5b58\u5cf0\u503c\u4e0d\u5e94\u8d85\u8fc7\u7cfb\u7edf\u5269\u4f59\u7a7a\u95f2\u5185\u5b58\uff1b\u5982\u679c\u8fd0\u884c\u7684\u7a0b\u5e8f\u5f88\u591a\u5e76\u4e14\u7f3a\u5c11\u5927\u91cf\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\uff0c\u90a3\u4e48\u6240\u9009\u7528\u7684\u6570\u636e\u7ed3\u6784\u5fc5\u987b\u80fd\u591f\u5b58\u50a8\u5728\u79bb\u6563\u7684\u5185\u5b58\u7a7a\u95f4\u5185\u3002

    \u300c\u7269\u7406\u7ed3\u6784\u300d\u53cd\u6620\u4e86\u6570\u636e\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u7684\u5b58\u50a8\u65b9\u5f0f\uff0c\u53ef\u5206\u4e3a\u6570\u7ec4\u7684\u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u548c\u94fe\u8868\u7684\u79bb\u6563\u7a7a\u95f4\u5b58\u50a8\u3002\u7269\u7406\u7ed3\u6784\u4ece\u5e95\u5c42\u51b3\u5b9a\u4e86\u6570\u636e\u7684\u8bbf\u95ee\u3001\u66f4\u65b0\u3001\u589e\u5220\u7b49\u64cd\u4f5c\u65b9\u6cd5\uff0c\u540c\u65f6\u5728\u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u65b9\u9762\u5448\u73b0\u51fa\u4e92\u8865\u7684\u7279\u70b9\u3002

    Fig. \u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u4e0e\u79bb\u6563\u7a7a\u95f4\u5b58\u50a8

    \u6240\u6709\u6570\u636e\u7ed3\u6784\u90fd\u662f\u57fa\u4e8e\u6570\u7ec4\u3001\u94fe\u8868\u6216\u4e8c\u8005\u7684\u7ec4\u5408\u5b9e\u73b0\u7684\u3002\u4f8b\u5982\uff0c\u6808\u548c\u961f\u5217\u65e2\u53ef\u4ee5\u4f7f\u7528\u6570\u7ec4\u5b9e\u73b0\uff0c\u4e5f\u53ef\u4ee5\u4f7f\u7528\u94fe\u8868\u5b9e\u73b0\uff1b\u800c\u54c8\u5e0c\u8868\u7684\u5b9e\u73b0\u53ef\u80fd\u540c\u65f6\u5305\u542b\u6570\u7ec4\u548c\u94fe\u8868\u3002

    • \u57fa\u4e8e\u6570\u7ec4\u53ef\u5b9e\u73b0\uff1a\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\u3001\u77e9\u9635\u3001\u5f20\u91cf\uff08\u7ef4\u5ea6 \\(\\geq 3\\) \u7684\u6570\u7ec4\uff09\u7b49\uff1b
    • \u57fa\u4e8e\u94fe\u8868\u53ef\u5b9e\u73b0\uff1a\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\u7b49\uff1b

    \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u4e5f\u88ab\u79f0\u4e3a\u201c\u9759\u6001\u6570\u636e\u7ed3\u6784\u201d\uff0c\u8fd9\u610f\u5473\u7740\u6b64\u7c7b\u6570\u636e\u7ed3\u6784\u5728\u521d\u59cb\u5316\u540e\u957f\u5ea6\u4e0d\u53ef\u53d8\u3002\u76f8\u5bf9\u5e94\u5730\uff0c\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u88ab\u79f0\u4e3a\u201c\u52a8\u6001\u6570\u636e\u7ed3\u6784\u201d\uff0c\u8fd9\u7c7b\u6570\u636e\u7ed3\u6784\u5728\u521d\u59cb\u5316\u540e\uff0c\u4ecd\u53ef\u4ee5\u5728\u7a0b\u5e8f\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u5bf9\u5176\u957f\u5ea6\u8fdb\u884c\u8c03\u6574\u3002

    Tip

    \u5982\u82e5\u611f\u89c9\u7406\u89e3\u7269\u7406\u7ed3\u6784\u6709\u56f0\u96be\uff0c\u5efa\u8bae\u5148\u9605\u8bfb\u4e0b\u4e00\u7ae0\u201c\u6570\u7ec4\u4e0e\u94fe\u8868\u201d\uff0c\u7136\u540e\u518d\u56de\u5934\u7406\u89e3\u7269\u7406\u7ed3\u6784\u7684\u542b\u4e49\u3002\u6570\u7ec4\u4e0e\u94fe\u8868\u662f\u5176\u4ed6\u6240\u6709\u6570\u636e\u7ed3\u6784\u7684\u57fa\u77f3\uff0c\u5efa\u8bae\u4f60\u6295\u5165\u66f4\u591a\u65f6\u95f4\u6df1\u5165\u4e86\u89e3\u8fd9\u4e24\u79cd\u57fa\u672c\u6570\u636e\u7ed3\u6784\u3002

    "},{"location":"chapter_data_structure/number_encoding/","title":"3.3. \u00a0 \u6570\u5b57\u7f16\u7801 *","text":"

    Note

    \u5728\u672c\u4e66\u4e2d\uff0c\u6807\u9898\u5e26\u6709\u7684 * \u7b26\u53f7\u7684\u662f\u9009\u8bfb\u7ae0\u8282\u3002\u5982\u679c\u4f60\u65f6\u95f4\u6709\u9650\u6216\u611f\u5230\u7406\u89e3\u56f0\u96be\uff0c\u5efa\u8bae\u5148\u8df3\u8fc7\uff0c\u7b49\u5b66\u5b8c\u5fc5\u8bfb\u7ae0\u8282\u540e\u518d\u5355\u72ec\u653b\u514b\u3002

    "},{"location":"chapter_data_structure/number_encoding/#331","title":"3.3.1. \u00a0 \u539f\u7801\u3001\u53cd\u7801\u548c\u8865\u7801","text":"

    \u4ece\u4e0a\u4e00\u8282\u7684\u8868\u683c\u4e2d\u6211\u4eec\u53d1\u73b0\uff0c\u6240\u6709\u6574\u6570\u7c7b\u578b\u80fd\u591f\u8868\u793a\u7684\u8d1f\u6570\u90fd\u6bd4\u6b63\u6570\u591a\u4e00\u4e2a\u3002\u4f8b\u5982\uff0cbyte \u7684\u53d6\u503c\u8303\u56f4\u662f \\([-128, 127]\\) \u3002\u8fd9\u4e2a\u73b0\u8c61\u6bd4\u8f83\u53cd\u76f4\u89c9\uff0c\u5b83\u7684\u5185\u5728\u539f\u56e0\u6d89\u53ca\u5230\u539f\u7801\u3001\u53cd\u7801\u3001\u8865\u7801\u7684\u76f8\u5173\u77e5\u8bc6\u3002\u5728\u5c55\u5f00\u5206\u6790\u4e4b\u524d\uff0c\u6211\u4eec\u9996\u5148\u7ed9\u51fa\u4e09\u8005\u7684\u5b9a\u4e49\uff1a

    • \u539f\u7801\uff1a\u6211\u4eec\u5c06\u6570\u5b57\u7684\u4e8c\u8fdb\u5236\u8868\u793a\u7684\u6700\u9ad8\u4f4d\u89c6\u4e3a\u7b26\u53f7\u4f4d\uff0c\u5176\u4e2d \\(0\\) \u8868\u793a\u6b63\u6570\uff0c\\(1\\) \u8868\u793a\u8d1f\u6570\uff0c\u5176\u4f59\u4f4d\u8868\u793a\u6570\u5b57\u7684\u503c\u3002
    • \u53cd\u7801\uff1a\u6b63\u6570\u7684\u53cd\u7801\u4e0e\u5176\u539f\u7801\u76f8\u540c\uff0c\u8d1f\u6570\u7684\u53cd\u7801\u662f\u5bf9\u5176\u539f\u7801\u9664\u7b26\u53f7\u4f4d\u5916\u7684\u6240\u6709\u4f4d\u53d6\u53cd\u3002
    • \u8865\u7801\uff1a\u6b63\u6570\u7684\u8865\u7801\u4e0e\u5176\u539f\u7801\u76f8\u540c\uff0c\u8d1f\u6570\u7684\u8865\u7801\u662f\u5728\u5176\u53cd\u7801\u7684\u57fa\u7840\u4e0a\u52a0 \\(1\\) \u3002

    Fig. \u539f\u7801\u3001\u53cd\u7801\u4e0e\u8865\u7801\u4e4b\u95f4\u7684\u76f8\u4e92\u8f6c\u6362

    \u663e\u7136\uff0c\u300c\u539f\u7801\u300d\u6700\u4e3a\u76f4\u89c2\uff0c\u7136\u800c\u6570\u5b57\u5374\u662f\u4ee5\u300c\u8865\u7801\u300d\u7684\u5f62\u5f0f\u5b58\u50a8\u5728\u8ba1\u7b97\u673a\u4e2d\u7684\u3002\u8fd9\u662f\u56e0\u4e3a\u539f\u7801\u5b58\u5728\u4e00\u4e9b\u5c40\u9650\u6027\u3002

    \u4e00\u65b9\u9762\uff0c\u8d1f\u6570\u7684\u539f\u7801\u4e0d\u80fd\u76f4\u63a5\u7528\u4e8e\u8fd0\u7b97\u3002\u4f8b\u5982\uff0c\u6211\u4eec\u5728\u539f\u7801\u4e0b\u8ba1\u7b97 \\(1 + (-2)\\) \uff0c\u5f97\u5230\u7684\u7ed3\u679c\u662f \\(-3\\) \uff0c\u8fd9\u663e\u7136\u662f\u4e0d\u5bf9\u7684\u3002

    \\[ \\begin{aligned} & 1 + (-2) \\newline & = 0000 \\space 0001 + 1000 \\space 0010 \\newline & = 1000 \\space 0011 \\newline & = -3 \\end{aligned} \\]

    \u4e3a\u4e86\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u8ba1\u7b97\u673a\u5f15\u5165\u4e86\u300c\u53cd\u7801\u300d\u3002\u4f8b\u5982\uff0c\u6211\u4eec\u5148\u5c06\u539f\u7801\u8f6c\u6362\u4e3a\u53cd\u7801\uff0c\u5e76\u5728\u53cd\u7801\u4e0b\u8ba1\u7b97 \\(1 + (-2)\\) \uff0c\u5e76\u5c06\u7ed3\u679c\u4ece\u53cd\u7801\u8f6c\u5316\u56de\u539f\u7801\uff0c\u5219\u53ef\u5f97\u5230\u6b63\u786e\u7ed3\u679c \\(-1\\) \u3002

    \\[ \\begin{aligned} & 1 + (-2) \\newline & = 0000 \\space 0001 \\space \\text{(\u539f\u7801)} + 1000 \\space 0010 \\space \\text{(\u539f\u7801)} \\newline & = 0000 \\space 0001 \\space \\text{(\u53cd\u7801)} + 1111 \\space 1101 \\space \\text{(\u53cd\u7801)} \\newline & = 1111 \\space 1110 \\space \\text{(\u53cd\u7801)} \\newline & = 1000 \\space 0001 \\space \\text{(\u539f\u7801)} \\newline & = -1 \\end{aligned} \\]

    \u53e6\u4e00\u65b9\u9762\uff0c\u6570\u5b57\u96f6\u7684\u539f\u7801\u6709 \\(+0\\) \u548c \\(-0\\) \u4e24\u79cd\u8868\u793a\u65b9\u5f0f\u3002\u8fd9\u610f\u5473\u7740\u6570\u5b57\u96f6\u5bf9\u5e94\u7740\u4e24\u4e2a\u4e0d\u540c\u7684\u4e8c\u8fdb\u5236\u7f16\u7801\uff0c\u800c\u8fd9\u53ef\u80fd\u4f1a\u5e26\u6765\u6b67\u4e49\u95ee\u9898\u3002\u4f8b\u5982\uff0c\u5728\u6761\u4ef6\u5224\u65ad\u4e2d\uff0c\u5982\u679c\u6ca1\u6709\u533a\u5206\u6b63\u96f6\u548c\u8d1f\u96f6\uff0c\u53ef\u80fd\u4f1a\u5bfc\u81f4\u9519\u8bef\u7684\u5224\u65ad\u7ed3\u679c\u3002\u5982\u679c\u6211\u4eec\u60f3\u8981\u5904\u7406\u6b63\u96f6\u548c\u8d1f\u96f6\u6b67\u4e49\uff0c\u5219\u9700\u8981\u5f15\u5165\u989d\u5916\u7684\u5224\u65ad\u64cd\u4f5c\uff0c\u5176\u53ef\u80fd\u4f1a\u964d\u4f4e\u8ba1\u7b97\u673a\u7684\u8fd0\u7b97\u6548\u7387\u3002

    \\[ \\begin{aligned} +0 & = 0000 \\space 0000 \\newline -0 & = 1000 \\space 0000 \\end{aligned} \\]

    \u4e0e\u539f\u7801\u4e00\u6837\uff0c\u53cd\u7801\u4e5f\u5b58\u5728\u6b63\u8d1f\u96f6\u6b67\u4e49\u95ee\u9898\u3002\u4e3a\u6b64\uff0c\u8ba1\u7b97\u673a\u8fdb\u4e00\u6b65\u5f15\u5165\u4e86\u300c\u8865\u7801\u300d\u3002\u90a3\u4e48\uff0c\u8865\u7801\u6709\u4ec0\u4e48\u4f5c\u7528\u5462\uff1f\u6211\u4eec\u5148\u6765\u5206\u6790\u4e00\u4e0b\u8d1f\u96f6\u7684\u8865\u7801\u7684\u8ba1\u7b97\u8fc7\u7a0b\uff1a

    \\[ \\begin{aligned} -0 = \\space & 1000 \\space 0000 \\space \\text{(\u539f\u7801)} \\newline = \\space & 1111 \\space 1111 \\space \\text{(\u53cd\u7801)} \\newline = 1 \\space & 0000 \\space 0000 \\space \\text{(\u8865\u7801)} \\newline \\end{aligned} \\]

    \u5728\u8d1f\u96f6\u7684\u53cd\u7801\u57fa\u7840\u4e0a\u52a0 \\(1\\) \u4f1a\u4ea7\u751f\u8fdb\u4f4d\uff0c\u800c\u7531\u4e8e byte \u7684\u957f\u5ea6\u53ea\u6709 8 \u4f4d\uff0c\u56e0\u6b64\u6ea2\u51fa\u5230\u7b2c 9 \u4f4d\u7684 \\(1\\) \u4f1a\u88ab\u820d\u5f03\u3002\u4ece\u800c\u5f97\u5230\u8d1f\u96f6\u7684\u8865\u7801\u4e3a \\(0000 \\space 0000\\) \uff0c\u4e0e\u6b63\u96f6\u7684\u8865\u7801\u76f8\u540c\u3002\u8fd9\u610f\u5473\u7740\u5728\u8865\u7801\u8868\u793a\u4e2d\u53ea\u5b58\u5728\u4e00\u4e2a\u96f6\uff0c\u4ece\u800c\u89e3\u51b3\u4e86\u6b63\u8d1f\u96f6\u6b67\u4e49\u95ee\u9898\u3002

    \u8fd8\u5269\u4f59\u6700\u540e\u4e00\u4e2a\u7591\u60d1\uff1abyte \u7684\u53d6\u503c\u8303\u56f4\u662f \\([-128, 127]\\) \uff0c\u591a\u51fa\u6765\u7684\u4e00\u4e2a\u8d1f\u6570 \\(-128\\) \u662f\u5982\u4f55\u5f97\u5230\u7684\u5462\uff1f\u6211\u4eec\u6ce8\u610f\u5230\uff0c\u533a\u95f4 \\([-127, +127]\\) \u5185\u7684\u6240\u6709\u6574\u6570\u90fd\u6709\u5bf9\u5e94\u7684\u539f\u7801\u3001\u53cd\u7801\u548c\u8865\u7801\uff0c\u5e76\u4e14\u539f\u7801\u548c\u8865\u7801\u4e4b\u95f4\u662f\u53ef\u4ee5\u4e92\u76f8\u8f6c\u6362\u7684\u3002

    \u7136\u800c\uff0c\u8865\u7801 \\(1000 \\space 0000\\) \u662f\u4e00\u4e2a\u4f8b\u5916\uff0c\u5b83\u5e76\u6ca1\u6709\u5bf9\u5e94\u7684\u539f\u7801\u3002\u6839\u636e\u8f6c\u6362\u65b9\u6cd5\uff0c\u6211\u4eec\u5f97\u5230\u8be5\u8865\u7801\u7684\u539f\u7801\u4e3a \\(0000 \\space 0000\\) \u3002\u8fd9\u663e\u7136\u662f\u77db\u76fe\u7684\uff0c\u56e0\u4e3a\u8be5\u539f\u7801\u8868\u793a\u6570\u5b57 \\(0\\) \uff0c\u5b83\u7684\u8865\u7801\u5e94\u8be5\u662f\u81ea\u8eab\u3002\u8ba1\u7b97\u673a\u89c4\u5b9a\u8fd9\u4e2a\u7279\u6b8a\u7684\u8865\u7801 \\(1000 \\space 0000\\) \u4ee3\u8868 \\(-128\\) \u3002\u5b9e\u9645\u4e0a\uff0c\\((-1) + (-127)\\) \u5728\u8865\u7801\u4e0b\u7684\u8ba1\u7b97\u7ed3\u679c\u5c31\u662f \\(-128\\) \u3002

    \\[ \\begin{aligned} & (-127) + (-1) \\newline & = 1111 \\space 1111 \\space \\text{(\u539f\u7801)} + 1000 \\space 0001 \\space \\text{(\u539f\u7801)} \\newline & = 1000 \\space 0000 \\space \\text{(\u53cd\u7801)} + 1111 \\space 1110 \\space \\text{(\u53cd\u7801)} \\newline & = 1000 \\space 0001 \\space \\text{(\u8865\u7801)} + 1111 \\space 1111 \\space \\text{(\u8865\u7801)} \\newline & = 1000 \\space 0000 \\space \\text{(\u8865\u7801)} \\newline & = -128 \\end{aligned} \\]

    \u4f60\u53ef\u80fd\u5df2\u7ecf\u53d1\u73b0\uff0c\u4e0a\u8ff0\u7684\u6240\u6709\u8ba1\u7b97\u90fd\u662f\u52a0\u6cd5\u8fd0\u7b97\u3002\u8fd9\u6697\u793a\u7740\u4e00\u4e2a\u91cd\u8981\u4e8b\u5b9e\uff1a\u8ba1\u7b97\u673a\u5185\u90e8\u7684\u786c\u4ef6\u7535\u8def\u4e3b\u8981\u662f\u57fa\u4e8e\u52a0\u6cd5\u8fd0\u7b97\u8bbe\u8ba1\u7684\u3002\u8fd9\u662f\u56e0\u4e3a\u52a0\u6cd5\u8fd0\u7b97\u76f8\u5bf9\u4e8e\u5176\u4ed6\u8fd0\u7b97\uff08\u6bd4\u5982\u4e58\u6cd5\u3001\u9664\u6cd5\u548c\u51cf\u6cd5\uff09\u6765\u8bf4\uff0c\u786c\u4ef6\u5b9e\u73b0\u8d77\u6765\u66f4\u7b80\u5355\uff0c\u66f4\u5bb9\u6613\u8fdb\u884c\u5e76\u884c\u5316\u5904\u7406\uff0c\u4ece\u800c\u63d0\u9ad8\u8fd0\u7b97\u901f\u5ea6\u3002

    \u7136\u800c\uff0c\u8fd9\u5e76\u4e0d\u610f\u5473\u7740\u8ba1\u7b97\u673a\u53ea\u80fd\u505a\u52a0\u6cd5\u3002\u901a\u8fc7\u5c06\u52a0\u6cd5\u4e0e\u4e00\u4e9b\u57fa\u672c\u903b\u8f91\u8fd0\u7b97\u7ed3\u5408\uff0c\u8ba1\u7b97\u673a\u80fd\u591f\u5b9e\u73b0\u5404\u79cd\u5176\u4ed6\u7684\u6570\u5b66\u8fd0\u7b97\u3002\u4f8b\u5982\uff0c\u8ba1\u7b97\u51cf\u6cd5 \\(a - b\\) \u53ef\u4ee5\u8f6c\u6362\u4e3a\u8ba1\u7b97\u52a0\u6cd5 \\(a + (-b)\\) \uff1b\u8ba1\u7b97\u4e58\u6cd5\u548c\u9664\u6cd5\u53ef\u4ee5\u8f6c\u6362\u4e3a\u8ba1\u7b97\u591a\u6b21\u52a0\u6cd5\u6216\u51cf\u6cd5\u3002

    \u73b0\u5728\uff0c\u6211\u4eec\u53ef\u4ee5\u603b\u7ed3\u51fa\u8ba1\u7b97\u673a\u4f7f\u7528\u8865\u7801\u7684\u539f\u56e0\uff1a\u57fa\u4e8e\u8865\u7801\u8868\u793a\uff0c\u8ba1\u7b97\u673a\u53ef\u4ee5\u7528\u540c\u6837\u7684\u7535\u8def\u548c\u64cd\u4f5c\u6765\u5904\u7406\u6b63\u6570\u548c\u8d1f\u6570\u7684\u52a0\u6cd5\uff0c\u4e0d\u9700\u8981\u8bbe\u8ba1\u7279\u6b8a\u7684\u786c\u4ef6\u7535\u8def\u6765\u5904\u7406\u51cf\u6cd5\uff0c\u5e76\u4e14\u65e0\u9700\u7279\u522b\u5904\u7406\u6b63\u8d1f\u96f6\u7684\u6b67\u4e49\u95ee\u9898\u3002\u8fd9\u5927\u5927\u7b80\u5316\u4e86\u786c\u4ef6\u8bbe\u8ba1\uff0c\u5e76\u63d0\u9ad8\u4e86\u8fd0\u7b97\u6548\u7387\u3002

    \u8865\u7801\u7684\u8bbe\u8ba1\u975e\u5e38\u7cbe\u5999\uff0c\u7531\u4e8e\u7bc7\u5e45\u5173\u7cfb\u6211\u4eec\u5148\u4ecb\u7ecd\u5230\u8fd9\u91cc\u3002\u5efa\u8bae\u6709\u5174\u8da3\u7684\u8bfb\u8005\u8fdb\u4e00\u6b65\u6df1\u5ea6\u4e86\u89e3\u3002

    "},{"location":"chapter_data_structure/number_encoding/#332","title":"3.3.2. \u00a0 \u6d6e\u70b9\u6570\u7f16\u7801","text":"

    \u7ec6\u5fc3\u7684\u4f60\u53ef\u80fd\u4f1a\u53d1\u73b0\uff1aint \u548c float \u957f\u5ea6\u76f8\u540c\uff0c\u90fd\u662f 4 bytes\uff0c\u4f46\u4e3a\u4ec0\u4e48 float \u7684\u53d6\u503c\u8303\u56f4\u8fdc\u5927\u4e8e int \uff1f\u8fd9\u975e\u5e38\u53cd\u76f4\u89c9\uff0c\u56e0\u4e3a\u6309\u7406\u8bf4 float \u9700\u8981\u8868\u793a\u5c0f\u6570\uff0c\u53d6\u503c\u8303\u56f4\u5e94\u8be5\u53d8\u5c0f\u624d\u5bf9\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8fd9\u662f\u56e0\u4e3a\u6d6e\u70b9\u6570 float \u91c7\u7528\u4e86\u4e0d\u540c\u7684\u8868\u793a\u65b9\u5f0f\u3002\u6839\u636e IEEE 754 \u6807\u51c6\uff0c32-bit \u957f\u5ea6\u7684 float \u7531\u4ee5\u4e0b\u90e8\u5206\u6784\u6210\uff1a

    • \u7b26\u53f7\u4f4d \\(\\mathrm{S}\\) \uff1a\u5360 1 bit \uff1b
    • \u6307\u6570\u4f4d \\(\\mathrm{E}\\) \uff1a\u5360 8 bits \uff1b
    • \u5206\u6570\u4f4d \\(\\mathrm{N}\\) \uff1a\u5360 24 bits \uff0c\u5176\u4e2d 23 \u4f4d\u663e\u5f0f\u5b58\u50a8\uff1b

    \u8bbe 32-bit \u4e8c\u8fdb\u5236\u6570\u7684\u7b2c \\(i\\) \u4f4d\u4e3a \\(b_i\\) \uff0c\u5219 float \u503c\u7684\u8ba1\u7b97\u65b9\u6cd5\u5b9a\u4e49\u4e3a\uff1a

    \\[ \\text { val } = (-1)^{b_{31}} \\times 2^{\\left(b_{30} b_{29} \\ldots b_{23}\\right)_2-127} \\times\\left(1 . b_{22} b_{21} \\ldots b_0\\right)_2 \\]

    \u8f6c\u5316\u5230\u5341\u8fdb\u5236\u4e0b\u7684\u8ba1\u7b97\u516c\u5f0f\u4e3a

    \\[ \\text { val }=(-1)^{\\mathrm{S}} \\times 2^{\\mathrm{E} -127} \\times (1 + \\mathrm{N}) \\]

    \u5176\u4e2d\u5404\u9879\u7684\u53d6\u503c\u8303\u56f4\u4e3a

    \\[ \\begin{aligned} \\mathrm{S} \\in & \\{ 0, 1\\} , \\quad \\mathrm{E} \\in \\{ 1, 2, \\dots, 254 \\} \\newline (1 + \\mathrm{N}) = & (1 + \\sum_{i=1}^{23} b_{23-i} 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\]

    Fig. IEEE 754 \u6807\u51c6\u4e0b\u7684 float \u8868\u793a\u65b9\u5f0f

    \u4ee5\u4e0a\u56fe\u4e3a\u4f8b\uff0c\\(\\mathrm{S} = 0\\) \uff0c \\(\\mathrm{E} = 124\\) \uff0c\\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\) \uff0c\u6613\u5f97

    \\[ \\text { val } = (-1)^0 \\times 2^{124 - 127} \\times (1 + 0.375) = 0.171875 \\]

    \u73b0\u5728\u6211\u4eec\u53ef\u4ee5\u56de\u7b54\u6700\u521d\u7684\u95ee\u9898\uff1afloat \u7684\u8868\u793a\u65b9\u5f0f\u5305\u542b\u6307\u6570\u4f4d\uff0c\u5bfc\u81f4\u5176\u53d6\u503c\u8303\u56f4\u8fdc\u5927\u4e8e int \u3002\u6839\u636e\u4ee5\u4e0a\u8ba1\u7b97\uff0cfloat \u53ef\u8868\u793a\u7684\u6700\u5927\u6b63\u6570\u4e3a \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\) \uff0c\u5207\u6362\u7b26\u53f7\u4f4d\u4fbf\u53ef\u5f97\u5230\u6700\u5c0f\u8d1f\u6570\u3002

    \u5c3d\u7ba1\u6d6e\u70b9\u6570 float \u6269\u5c55\u4e86\u53d6\u503c\u8303\u56f4\uff0c\u4f46\u5176\u526f\u4f5c\u7528\u662f\u727a\u7272\u4e86\u7cbe\u5ea6\u3002\u6574\u6570\u7c7b\u578b int \u5c06\u5168\u90e8 32 \u4f4d\u7528\u4e8e\u8868\u793a\u6570\u5b57\uff0c\u6570\u5b57\u662f\u5747\u5300\u5206\u5e03\u7684\uff1b\u800c\u7531\u4e8e\u6307\u6570\u4f4d\u7684\u5b58\u5728\uff0c\u6d6e\u70b9\u6570 float \u7684\u6570\u503c\u8d8a\u5927\uff0c\u76f8\u90bb\u4e24\u4e2a\u6570\u5b57\u4e4b\u95f4\u7684\u5dee\u503c\u5c31\u4f1a\u8d8b\u5411\u8d8a\u5927\u3002

    \u8fdb\u4e00\u6b65\u5730\uff0c\u6307\u6570\u4f4d \\(E = 0\\) \u548c \\(E = 255\\) \u5177\u6709\u7279\u6b8a\u542b\u4e49\uff0c\u7528\u4e8e\u8868\u793a\u96f6\u3001\u65e0\u7a77\u5927\u3001\\(\\mathrm{NaN}\\) \u7b49\u3002

    \u6307\u6570\u4f4d E \u5206\u6570\u4f4d \\(\\mathrm{N} = 0\\) \u5206\u6570\u4f4d \\(\\mathrm{N} \\ne 0\\) \u8ba1\u7b97\u516c\u5f0f \\(0\\) \\(\\pm 0\\) \u6b21\u6b63\u89c4\u6570 \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) \u6b63\u89c4\u6570 \u6b63\u89c4\u6570 \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\)

    \u7279\u522b\u5730\uff0c\u6b21\u6b63\u89c4\u6570\u663e\u8457\u63d0\u5347\u4e86\u6d6e\u70b9\u6570\u7684\u7cbe\u5ea6\uff0c\u8fd9\u662f\u56e0\u4e3a\uff1a

    • \u6700\u5c0f\u6b63\u6b63\u89c4\u6570\u4e3a \\(2^{-126} \\approx 1.18 \\times 10^{-38}\\) \uff1b
    • \u6700\u5c0f\u6b63\u6b21\u6b63\u89c4\u6570\u4e3a \\(2^{-126} \\times 2^{-23} \\approx 1.4 \\times 10^{-45}\\) \uff1b

    \u53cc\u7cbe\u5ea6 double \u4e5f\u91c7\u7528\u7c7b\u4f3c float \u7684\u8868\u793a\u65b9\u6cd5\uff0c\u6b64\u5904\u4e0d\u518d\u8be6\u8ff0\u3002

    "},{"location":"chapter_data_structure/summary/","title":"3.5. \u00a0 \u5c0f\u7ed3","text":"

    \u6570\u636e\u7ed3\u6784\u5206\u7c7b

    • \u6570\u636e\u7ed3\u6784\u53ef\u4ee5\u4ece\u903b\u8f91\u7ed3\u6784\u548c\u7269\u7406\u7ed3\u6784\u4e24\u4e2a\u89d2\u5ea6\u8fdb\u884c\u5206\u7c7b\u3002\u903b\u8f91\u7ed3\u6784\u63cf\u8ff0\u4e86\u6570\u636e\u5143\u7d20\u4e4b\u95f4\u7684\u903b\u8f91\u5173\u7cfb\uff0c\u800c\u7269\u7406\u7ed3\u6784\u63cf\u8ff0\u4e86\u6570\u636e\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u7684\u5b58\u50a8\u65b9\u5f0f\u3002
    • \u5e38\u89c1\u7684\u903b\u8f91\u7ed3\u6784\u5305\u62ec\u7ebf\u6027\u3001\u6811\u72b6\u548c\u7f51\u72b6\u7b49\u3002\u901a\u5e38\u6211\u4eec\u6839\u636e\u903b\u8f91\u7ed3\u6784\u5c06\u6570\u636e\u7ed3\u6784\u5206\u4e3a\u7ebf\u6027\uff08\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\uff09\u548c\u975e\u7ebf\u6027\uff08\u6811\u3001\u56fe\u3001\u5806\uff09\u4e24\u79cd\u3002\u54c8\u5e0c\u8868\u7684\u5b9e\u73b0\u53ef\u80fd\u540c\u65f6\u5305\u542b\u7ebf\u6027\u548c\u975e\u7ebf\u6027\u7ed3\u6784\u3002
    • \u5f53\u7a0b\u5e8f\u8fd0\u884c\u65f6\uff0c\u6570\u636e\u88ab\u5b58\u50a8\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u3002\u6bcf\u4e2a\u5185\u5b58\u7a7a\u95f4\u90fd\u62e5\u6709\u5bf9\u5e94\u7684\u5185\u5b58\u5730\u5740\uff0c\u7a0b\u5e8f\u901a\u8fc7\u8fd9\u4e9b\u5185\u5b58\u5730\u5740\u8bbf\u95ee\u6570\u636e\u3002
    • \u7269\u7406\u7ed3\u6784\u4e3b\u8981\u5206\u4e3a\u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\uff08\u6570\u7ec4\uff09\u548c\u79bb\u6563\u7a7a\u95f4\u5b58\u50a8\uff08\u94fe\u8868\uff09\u3002\u6240\u6709\u6570\u636e\u7ed3\u6784\u90fd\u662f\u7531\u6570\u7ec4\u3001\u94fe\u8868\u6216\u4e24\u8005\u7684\u7ec4\u5408\u5b9e\u73b0\u7684\u3002

    \u6570\u636e\u7c7b\u578b\u4e0e\u7f16\u7801

    • \u8ba1\u7b97\u673a\u4e2d\u7684\u57fa\u672c\u6570\u636e\u7c7b\u578b\u5305\u62ec\u6574\u6570 byte, short, int, long \u3001\u6d6e\u70b9\u6570 float, double \u3001\u5b57\u7b26 char \u548c\u5e03\u5c14 boolean \u3002\u5b83\u4eec\u7684\u53d6\u503c\u8303\u56f4\u53d6\u51b3\u4e8e\u5360\u7528\u7a7a\u95f4\u5927\u5c0f\u548c\u8868\u793a\u65b9\u5f0f\u3002
    • \u539f\u7801\u3001\u53cd\u7801\u548c\u8865\u7801\u662f\u5728\u8ba1\u7b97\u673a\u4e2d\u7f16\u7801\u6570\u5b57\u7684\u4e09\u79cd\u65b9\u6cd5\uff0c\u5b83\u4eec\u4e4b\u95f4\u662f\u53ef\u4ee5\u76f8\u4e92\u8f6c\u6362\u7684\u3002\u6574\u6570\u7684\u539f\u7801\u7684\u6700\u9ad8\u4f4d\u662f\u7b26\u53f7\u4f4d\uff0c\u5176\u4f59\u4f4d\u662f\u6570\u5b57\u7684\u503c\u3002
    • \u6574\u6570\u5728\u8ba1\u7b97\u673a\u4e2d\u662f\u4ee5\u8865\u7801\u7684\u5f62\u5f0f\u5b58\u50a8\u7684\u3002\u5728\u8865\u7801\u8868\u793a\u4e0b\uff0c\u8ba1\u7b97\u673a\u53ef\u4ee5\u5bf9\u6b63\u6570\u548c\u8d1f\u6570\u7684\u52a0\u6cd5\u4e00\u89c6\u540c\u4ec1\uff0c\u4e0d\u9700\u8981\u4e3a\u51cf\u6cd5\u64cd\u4f5c\u5355\u72ec\u8bbe\u8ba1\u7279\u6b8a\u7684\u786c\u4ef6\u7535\u8def\uff0c\u5e76\u4e14\u4e0d\u5b58\u5728\u6b63\u8d1f\u96f6\u6b67\u4e49\u7684\u95ee\u9898\u3002
    • \u6d6e\u70b9\u6570\u7684\u7f16\u7801\u7531 1 \u4f4d\u7b26\u53f7\u4f4d\u30018 \u4f4d\u6307\u6570\u4f4d\u548c 23 \u4f4d\u5206\u6570\u4f4d\u6784\u6210\u3002\u7531\u4e8e\u5b58\u5728\u6307\u6570\u4f4d\uff0c\u6d6e\u70b9\u6570\u7684\u53d6\u503c\u8303\u56f4\u8fdc\u5927\u4e8e\u6574\u6570\uff0c\u4ee3\u4ef7\u662f\u727a\u7272\u4e86\u7cbe\u5ea6\u3002
    • ASCII \u7801\u662f\u6700\u65e9\u51fa\u73b0\u7684\u82f1\u6587\u5b57\u7b26\u96c6\uff0c\u957f\u5ea6\u4e3a 1 \u5b57\u8282\uff0c\u5171\u6536\u5f55 127 \u4e2a\u5b57\u7b26\u3002GBK \u5b57\u7b26\u96c6\u662f\u5e38\u7528\u7684\u4e2d\u6587\u5b57\u7b26\u96c6\uff0c\u5171\u6536\u5f55\u4e24\u4e07\u591a\u4e2a\u6c49\u5b57\u3002Unicode \u81f4\u529b\u4e8e\u63d0\u4f9b\u4e00\u4e2a\u5b8c\u6574\u7684\u5b57\u7b26\u96c6\u6807\u51c6\uff0c\u6536\u5f55\u4e16\u754c\u5185\u5404\u79cd\u8bed\u8a00\u7684\u5b57\u7b26\uff0c\u4ece\u800c\u89e3\u51b3\u7531\u4e8e\u5b57\u7b26\u7f16\u7801\u65b9\u6cd5\u4e0d\u4e00\u81f4\u800c\u5bfc\u81f4\u7684\u4e71\u7801\u95ee\u9898\u3002
    • UTF-8 \u662f\u6700\u53d7\u6b22\u8fce\u7684 Unicode \u7f16\u7801\u65b9\u6cd5\uff0c\u901a\u7528\u6027\u975e\u5e38\u597d\u3002\u5b83\u662f\u4e00\u79cd\u53d8\u957f\u7684\u7f16\u7801\u65b9\u6cd5\uff0c\u5177\u6709\u5f88\u597d\u7684\u6269\u5c55\u6027\uff0c\u6709\u6548\u63d0\u5347\u4e86\u5b58\u50a8\u7a7a\u95f4\u7684\u4f7f\u7528\u6548\u7387\u3002UTF-16 \u548c UTF-32 \u662f\u7b49\u957f\u7684\u7f16\u7801\u65b9\u6cd5\u3002\u5728\u7f16\u7801\u4e2d\u6587\u65f6\uff0cUTF-16 \u6bd4 UTF-8 \u7684\u5360\u7528\u7a7a\u95f4\u66f4\u5c0f\u3002Java, C# \u7b49\u7f16\u7a0b\u8bed\u8a00\u9ed8\u8ba4\u4f7f\u7528 UTF-16 \u7f16\u7801\u3002
    "},{"location":"chapter_data_structure/summary/#351-q-a","title":"3.5.1. \u00a0 Q & A","text":"

    \u4e3a\u4ec0\u4e48\u54c8\u5e0c\u8868\u540c\u65f6\u5305\u542b\u7ebf\u6027\u6570\u636e\u7ed3\u6784\u548c\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff1f

    \u54c8\u5e0c\u8868\u5e95\u5c42\u662f\u6570\u7ec4\uff0c\u800c\u4e3a\u4e86\u89e3\u51b3\u54c8\u5e0c\u51b2\u7a81\uff0c\u6211\u4eec\u53ef\u80fd\u4f1a\u4f7f\u7528\u201c\u62c9\u94fe\u6cd5\u201d\uff08\u540e\u7eed\u6563\u5217\u8868\u7ae0\u8282\u4f1a\u8bb2\uff09\u3002\u5728\u62c9\u94fe\u6cd5\u4e2d\uff0c\u6570\u7ec4\u4e2d\u6bcf\u4e2a\u5730\u5740\uff08\u6876\uff09\u6307\u5411\u4e00\u4e2a\u94fe\u8868\uff1b\u5f53\u8fd9\u4e2a\u94fe\u8868\u957f\u5ea6\u8d85\u8fc7\u4e00\u5b9a\u9608\u503c\u65f6\uff0c\u53c8\u53ef\u80fd\u88ab\u8f6c\u5316\u4e3a\u6811\uff08\u901a\u5e38\u4e3a\u7ea2\u9ed1\u6811\uff09\u3002\u56e0\u6b64\uff0c\u54c8\u5e0c\u8868\u53ef\u80fd\u540c\u65f6\u5305\u542b\u7ebf\u6027\uff08\u6570\u7ec4\u3001\u94fe\u8868\uff09\u548c\u975e\u7ebf\u6027\uff08\u6811\uff09\u6570\u636e\u7ed3\u6784\u3002

    char \u7c7b\u578b\u7684\u957f\u5ea6\u662f 1 bytes \u5417\uff1f

    \u8fd9\u4e2a\u4e0e\u7f16\u7a0b\u8bed\u8a00\u91c7\u7528\u7684\u7f16\u7801\u65b9\u6cd5\u6709\u5173\u3002\u4f8b\u5982\uff0cJava, JS, TS, C# \u90fd\u91c7\u7528 UTF-16 \u7f16\u7801\uff08\u4fdd\u5b58 Unicode \u7801\u70b9\uff09\uff0c\u56e0\u6b64 char \u7c7b\u578b\u7684\u957f\u5ea6\u4e3a 2 bytes \u3002

    "},{"location":"chapter_dynamic_programming/","title":"13. \u00a0 \u52a8\u6001\u89c4\u5212","text":""},{"location":"chapter_dynamic_programming/dp_problem_features/","title":"13.2. \u00a0 \u52a8\u6001\u89c4\u5212\u95ee\u9898\u7279\u6027","text":"

    \u5728\u4e0a\u8282\u4e2d\uff0c\u6211\u4eec\u5b66\u4e60\u4e86\u52a8\u6001\u89c4\u5212\u95ee\u9898\u7684\u66b4\u529b\u89e3\u6cd5\uff0c\u4ece\u9012\u5f52\u6811\u4e2d\u89c2\u5bdf\u5230\u6d77\u91cf\u7684\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u4ee5\u53ca\u4e86\u89e3\u5230\u52a8\u6001\u89c4\u5212\u662f\u5982\u4f55\u901a\u8fc7\u8bb0\u5f55\u89e3\u6765\u4f18\u5316\u65f6\u95f4\u590d\u6742\u5ea6\u7684\u3002

    \u5b9e\u9645\u4e0a\uff0c\u52a8\u6001\u89c4\u5212\u6700\u5e38\u7528\u6765\u6c42\u89e3\u6700\u4f18\u65b9\u6848\u95ee\u9898\uff0c\u4f8b\u5982\u5bfb\u627e\u6700\u77ed\u8def\u5f84\u3001\u6700\u5927\u5229\u6da6\u3001\u6700\u5c11\u65f6\u95f4\u7b49\u3002\u8fd9\u7c7b\u95ee\u9898\u4e0d\u4ec5\u5305\u542b\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u5f80\u5f80\u8fd8\u5177\u6709\u53e6\u5916\u4e24\u5927\u7279\u6027\uff1a\u6700\u4f18\u5b50\u7ed3\u6784\u3001\u65e0\u540e\u6548\u6027\u3002

    "},{"location":"chapter_dynamic_programming/dp_problem_features/#1321","title":"13.2.1. \u00a0 \u6700\u4f18\u5b50\u7ed3\u6784","text":"

    \u6211\u4eec\u5bf9\u722c\u697c\u68af\u95ee\u9898\u7a0d\u4f5c\u6539\u52a8\uff0c\u4f7f\u4e4b\u66f4\u52a0\u9002\u5408\u5c55\u793a\u6700\u4f18\u5b50\u7ed3\u6784\u6982\u5ff5\u3002

    \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7

    \u7ed9\u5b9a\u4e00\u4e2a\u697c\u68af\uff0c\u4f60\u6bcf\u6b65\u53ef\u4ee5\u4e0a \\(1\\) \u9636\u6216\u8005 \\(2\\) \u9636\uff0c\u6bcf\u4e00\u9636\u697c\u68af\u4e0a\u90fd\u8d34\u6709\u4e00\u4e2a\u975e\u8d1f\u6574\u6570\uff0c\u8868\u793a\u4f60\u5728\u8be5\u53f0\u9636\u6240\u9700\u8981\u4ed8\u51fa\u7684\u4ee3\u4ef7\u3002\u7ed9\u5b9a\u4e00\u4e2a\u975e\u8d1f\u6574\u6570\u6570\u7ec4 \\(cost\\) \uff0c\u5176\u4e2d \\(cost[i]\\) \u8868\u793a\u5728\u7b2c \\(i\\) \u4e2a\u53f0\u9636\u9700\u8981\u4ed8\u51fa\u7684\u4ee3\u4ef7\uff0c\\(cost[0]\\) \u4e3a\u5730\u9762\u8d77\u59cb\u70b9\u3002\u8bf7\u8ba1\u7b97\u6700\u5c11\u9700\u8981\u4ed8\u51fa\u591a\u5c11\u4ee3\u4ef7\u624d\u80fd\u5230\u8fbe\u9876\u90e8\uff1f

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u82e5\u7b2c \\(1\\) , \\(2\\) , \\(3\\) \u9636\u7684\u4ee3\u4ef7\u5206\u522b\u4e3a \\(1\\) , \\(10\\) , \\(1\\) \uff0c\u5219\u4ece\u5730\u9762\u722c\u5230\u7b2c \\(3\\) \u9636\u7684\u6700\u5c0f\u4ee3\u4ef7\u4e3a \\(2\\) \u3002

    Fig. \u722c\u5230\u7b2c 3 \u9636\u7684\u6700\u5c0f\u4ee3\u4ef7

    \u8bbe \\(dp[i]\\) \u4e3a\u722c\u5230\u7b2c \\(i\\) \u9636\u7d2f\u8ba1\u4ed8\u51fa\u7684\u4ee3\u4ef7\uff0c\u7531\u4e8e\u7b2c \\(i\\) \u9636\u53ea\u53ef\u80fd\u4ece \\(i - 1\\) \u9636\u6216 \\(i - 2\\) \u9636\u8d70\u6765\uff0c\u56e0\u6b64 \\(dp[i]\\) \u53ea\u53ef\u80fd\u7b49\u4e8e \\(dp[i - 1] + cost[i]\\) \u6216 \\(dp[i - 2] + cost[i]\\) \u3002\u4e3a\u4e86\u5c3d\u53ef\u80fd\u51cf\u5c11\u4ee3\u4ef7\uff0c\u6211\u4eec\u5e94\u8be5\u9009\u62e9\u4e24\u8005\u4e2d\u8f83\u5c0f\u7684\u90a3\u4e00\u4e2a\uff0c\u5373\uff1a

    \\[ dp[i] = \\min(dp[i-1], dp[i-2]) + cost[i] \\]

    \u8fd9\u4fbf\u53ef\u4ee5\u5f15\u51fa\u300c\u6700\u4f18\u5b50\u7ed3\u6784\u300d\u7684\u542b\u4e49\uff1a\u539f\u95ee\u9898\u7684\u6700\u4f18\u89e3\u662f\u4ece\u5b50\u95ee\u9898\u7684\u6700\u4f18\u89e3\u6784\u5efa\u5f97\u6765\u7684\u3002\u5bf9\u4e8e\u672c\u9898\uff0c\u6211\u4eec\u4ece\u4e24\u4e2a\u5b50\u95ee\u9898\u6700\u4f18\u89e3 \\(dp[i-1]\\) , \\(dp[i-2]\\) \u4e2d\u6311\u9009\u51fa\u8f83\u4f18\u7684\u90a3\u4e00\u4e2a\uff0c\u5e76\u7528\u5b83\u6784\u5efa\u51fa\u539f\u95ee\u9898 \\(dp[i]\\) \u7684\u6700\u4f18\u89e3\u3002

    \u76f8\u8f83\u4e8e\u5206\u6cbb\u95ee\u9898\uff0c\u52a8\u6001\u89c4\u5212\u95ee\u9898\u7684\u89e3\u4e5f\u662f\u7531\u5176\u5b50\u95ee\u9898\u7684\u89e3\u6784\u6210\u7684\u3002\u4e0d\u540c\u7684\u662f\uff0c\u52a8\u6001\u89c4\u5212\u4e2d\u5b50\u95ee\u9898\u7684\u89e3\u4e0d\u4ec5\u63ed\u793a\u4e86\u95ee\u9898\u7684\u5c40\u90e8\u6700\u4f18\u89e3\uff0c\u800c\u4e14\u8fd8\u901a\u8fc7\u7279\u5b9a\u7684\u9012\u63a8\u5173\u7cfb\u94fe\u63a5\u8d77\u6765\uff0c\u5171\u540c\u6784\u5efa\u51fa\u539f\u95ee\u9898\u7684\u5168\u5c40\u6700\u4f18\u89e3\u3002

    \u90a3\u4e48\uff0c\u4e0a\u8282\u7684\u722c\u697c\u68af\u9898\u76ee\u6709\u6ca1\u6709\u6700\u4f18\u5b50\u7ed3\u6784\u5462\uff1f\u5b83\u8981\u6c42\u89e3\u7684\u662f\u65b9\u6848\u6570\u91cf\uff0c\u770b\u4f3c\u662f\u4e00\u4e2a\u8ba1\u6570\u95ee\u9898\uff0c\u4f46\u5982\u679c\u6362\u4e00\u79cd\u95ee\u6cd5\uff1a\u6c42\u89e3\u6700\u5927\u65b9\u6848\u6570\u91cf\u3002\u6211\u4eec\u610f\u5916\u5730\u53d1\u73b0\uff0c\u867d\u7136\u9898\u76ee\u4fee\u6539\u524d\u540e\u662f\u7b49\u4ef7\u7684\uff0c\u4f46\u6700\u4f18\u5b50\u7ed3\u6784\u6d6e\u73b0\u51fa\u6765\u4e86\uff1a\u7b2c \\(n\\) \u9636\u6700\u5927\u65b9\u6848\u6570\u91cf\u7b49\u4e8e\u7b2c \\(n-1\\) \u9636\u548c\u7b2c \\(n-2\\) \u9636\u6700\u5927\u65b9\u6848\u6570\u91cf\u4e4b\u548c\u3002\u6240\u4ee5\u8bf4\uff0c\u6700\u4f18\u5b50\u7ed3\u6784\u7684\u662f\u4e00\u4e2a\u6bd4\u8f83\u5bbd\u6cdb\u7684\u6982\u5ff5\uff0c\u5728\u4e0d\u540c\u95ee\u9898\u4e2d\u4f1a\u6709\u4e0d\u540c\u7684\u542b\u4e49\u3002

    \u6839\u636e\u4ee5\u4e0a\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff0c\u4ee5\u53ca\u521d\u59cb\u72b6\u6001 \\(dp[1] = cost[1]\\) , \\(dp[2] = cost[2]\\) \uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u51fa\u52a8\u6001\u89c4\u5212\u89e3\u9898\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_cost_climbing_stairs_dp.java
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(int[] cost) {\nint n = cost.length - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[] dp = new int[n + 1];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = cost[1];\ndp[2] = cost[2];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n}\nreturn dp[n];\n}\n
    min_cost_climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(vector<int> &cost) {\nint n = cost.size() - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nvector<int> dp(n + 1);\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = cost[1];\ndp[2] = cost[2];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n}\nreturn dp[n];\n}\n
    min_cost_climbing_stairs_dp.py
    def min_cost_climbing_stairs_dp(cost: list[int]) -> int:\n\"\"\"\u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(cost) - 1\nif n == 1 or n == 2:\nreturn cost[n]\n# \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\ndp = [0] * (n + 1)\n# \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1], dp[2] = cost[1], cost[2]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor i in range(3, n + 1):\ndp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\nreturn dp[n]\n
    min_cost_climbing_stairs_dp.go
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.js
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.ts
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.c
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(int[] cost) {\nint n = cost.Length - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[] dp = new int[n + 1];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = cost[1];\ndp[2] = cost[2];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n}\nreturn dp[n];\n}\n
    min_cost_climbing_stairs_dp.swift
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.zig
    [class]{}-[func]{minCostClimbingStairsDP}\n
    min_cost_climbing_stairs_dp.dart
    [class]{}-[func]{minCostClimbingStairsDP}\n

    Fig. \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \u8fd9\u9053\u9898\u540c\u6837\u4e5f\u53ef\u4ee5\u8fdb\u884c\u72b6\u6001\u538b\u7f29\uff0c\u5c06\u4e00\u7ef4\u538b\u7f29\u81f3\u96f6\u7ef4\uff0c\u4f7f\u5f97\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n)\\) \u964d\u4f4e\u81f3 \\(O(1)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_cost_climbing_stairs_dp.java
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(int[] cost) {\nint n = cost.length - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\nint a = cost[1], b = cost[2];\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = Math.min(a, tmp) + cost[i];\na = tmp;\n}\nreturn b;\n}\n
    min_cost_climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(vector<int> &cost) {\nint n = cost.size() - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\nint a = cost[1], b = cost[2];\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = min(a, tmp) + cost[i];\na = tmp;\n}\nreturn b;\n}\n
    min_cost_climbing_stairs_dp.py
    def min_cost_climbing_stairs_dp_comp(cost: list[int]) -> int:\n\"\"\"\u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(cost) - 1\nif n == 1 or n == 2:\nreturn cost[n]\na, b = cost[1], cost[2]\nfor i in range(3, n + 1):\na, b = b, min(a, b) + cost[i]\nreturn b\n
    min_cost_climbing_stairs_dp.go
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.js
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.ts
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.c
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(int[] cost) {\nint n = cost.Length - 1;\nif (n == 1 || n == 2)\nreturn cost[n];\nint a = cost[1], b = cost[2];\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = Math.Min(a, tmp) + cost[i];\na = tmp;\n}\nreturn b;\n}\n
    min_cost_climbing_stairs_dp.swift
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.zig
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    min_cost_climbing_stairs_dp.dart
    [class]{}-[func]{minCostClimbingStairsDPComp}\n
    "},{"location":"chapter_dynamic_programming/dp_problem_features/#1322","title":"13.2.2. \u00a0 \u65e0\u540e\u6548\u6027","text":"

    \u300c\u65e0\u540e\u6548\u6027\u300d\u662f\u52a8\u6001\u89c4\u5212\u80fd\u591f\u6709\u6548\u89e3\u51b3\u95ee\u9898\u7684\u91cd\u8981\u7279\u6027\u4e4b\u4e00\uff0c\u5b9a\u4e49\u4e3a\uff1a\u7ed9\u5b9a\u4e00\u4e2a\u786e\u5b9a\u7684\u72b6\u6001\uff0c\u5b83\u7684\u672a\u6765\u53d1\u5c55\u53ea\u4e0e\u5f53\u524d\u72b6\u6001\u6709\u5173\uff0c\u800c\u4e0e\u5f53\u524d\u72b6\u6001\u8fc7\u53bb\u6240\u7ecf\u5386\u8fc7\u7684\u6240\u6709\u72b6\u6001\u65e0\u5173\u3002

    \u4ee5\u722c\u697c\u68af\u95ee\u9898\u4e3a\u4f8b\uff0c\u7ed9\u5b9a\u72b6\u6001 \\(i\\) \uff0c\u5b83\u4f1a\u53d1\u5c55\u51fa\u72b6\u6001 \\(i+1\\) \u548c\u72b6\u6001 \\(i+2\\) \uff0c\u5206\u522b\u5bf9\u5e94\u8df3 \\(1\\) \u6b65\u548c\u8df3 \\(2\\) \u6b65\u3002\u5728\u505a\u51fa\u8fd9\u4e24\u79cd\u9009\u62e9\u65f6\uff0c\u6211\u4eec\u65e0\u9700\u8003\u8651\u72b6\u6001 \\(i\\) \u4e4b\u524d\u7684\u72b6\u6001\uff0c\u5373\u5b83\u4eec\u5bf9\u72b6\u6001 \\(i\\) \u7684\u672a\u6765\u6ca1\u6709\u5f71\u54cd\u3002

    \u7136\u800c\uff0c\u5982\u679c\u6211\u4eec\u5411\u722c\u697c\u68af\u95ee\u9898\u6dfb\u52a0\u4e00\u4e2a\u7ea6\u675f\uff0c\u60c5\u51b5\u5c31\u4e0d\u4e00\u6837\u4e86\u3002

    \u5e26\u7ea6\u675f\u722c\u697c\u68af

    \u7ed9\u5b9a\u4e00\u4e2a\u5171\u6709 \\(n\\) \u9636\u7684\u697c\u68af\uff0c\u4f60\u6bcf\u6b65\u53ef\u4ee5\u4e0a \\(1\\) \u9636\u6216\u8005 \\(2\\) \u9636\uff0c\u4f46\u4e0d\u80fd\u8fde\u7eed\u4e24\u8f6e\u8df3 \\(1\\) \u9636\uff0c\u8bf7\u95ee\u6709\u591a\u5c11\u79cd\u65b9\u6848\u53ef\u4ee5\u722c\u5230\u697c\u9876\u3002

    \u4f8b\u5982\uff0c\u722c\u4e0a\u7b2c \\(3\\) \u9636\u4ec5\u5269 \\(2\\) \u79cd\u53ef\u884c\u65b9\u6848\uff0c\u5176\u4e2d\u8fde\u7eed\u4e09\u6b21\u8df3 \\(1\\) \u9636\u7684\u65b9\u6848\u4e0d\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\uff0c\u56e0\u6b64\u88ab\u820d\u5f03\u3002

    Fig. \u5e26\u7ea6\u675f\u722c\u5230\u7b2c 3 \u9636\u7684\u65b9\u6848\u6570\u91cf

    \u5728\u8be5\u95ee\u9898\u4e2d\uff0c\u4e0b\u4e00\u6b65\u9009\u62e9\u4e0d\u80fd\u7531\u5f53\u524d\u72b6\u6001\uff08\u5f53\u524d\u697c\u68af\u9636\u6570\uff09\u72ec\u7acb\u51b3\u5b9a\uff0c\u8fd8\u548c\u524d\u4e00\u4e2a\u72b6\u6001\uff08\u4e0a\u8f6e\u697c\u68af\u9636\u6570\uff09\u6709\u5173\u3002\u5982\u679c\u4e0a\u4e00\u8f6e\u662f\u8df3 \\(1\\) \u9636\u4e0a\u6765\u7684\uff0c\u90a3\u4e48\u4e0b\u4e00\u8f6e\u5c31\u5fc5\u987b\u8df3 \\(2\\) \u9636\u3002

    \u4e0d\u96be\u53d1\u73b0\uff0c\u6b64\u95ee\u9898\u5df2\u4e0d\u6ee1\u8db3\u65e0\u540e\u6548\u6027\uff0c\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b \\(dp[i] = dp[i-1] + dp[i-2]\\) \u4e5f\u5931\u6548\u4e86\uff0c\u56e0\u4e3a \\(dp[i-1]\\) \u4ee3\u8868\u672c\u8f6e\u8df3 \\(1\\) \u9636\uff0c\u4f46\u5176\u4e2d\u5305\u542b\u4e86\u8bb8\u591a\u201c\u4e0a\u4e00\u8f6e\u8df3 \\(1\\) \u9636\u4e0a\u6765\u7684\u201d\u65b9\u6848\uff0c\u800c\u4e3a\u4e86\u6ee1\u8db3\u7ea6\u675f\uff0c\u6211\u4eec\u4e0d\u80fd\u5c06 \\(dp[i-1]\\) \u76f4\u63a5\u8ba1\u5165 \\(dp[i]\\) \u4e2d\u3002

    \u4e3a\u4e86\u89e3\u51b3\u8be5\u95ee\u9898\uff0c\u6211\u4eec\u9700\u8981\u6269\u5c55\u72b6\u6001\u5b9a\u4e49\uff1a\u72b6\u6001 \\([i, j]\\) \u8868\u793a\u5904\u5728\u7b2c \\(i\\) \u9636\u3001\u5e76\u4e14\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(j\\) \u9636\uff0c\u5176\u4e2d \\(j \\in \\{1, 2\\}\\) \u3002\u6b64\u72b6\u6001\u5b9a\u4e49\u6709\u6548\u5730\u533a\u5206\u4e86\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(1\\) \u9636\u8fd8\u662f \\(2\\) \u9636\uff0c\u6211\u4eec\u53ef\u4ee5\u636e\u6b64\u6765\u51b3\u5b9a\u4e0b\u4e00\u6b65\u8be5\u600e\u4e48\u8df3\uff1a

    • \u5f53 \\(j\\) \u7b49\u4e8e \\(1\\) \uff0c\u5373\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(1\\) \u9636\u65f6\uff0c\u8fd9\u4e00\u8f6e\u53ea\u80fd\u9009\u62e9\u8df3 \\(2\\) \u9636\uff1b
    • \u5f53 \\(j\\) \u7b49\u4e8e \\(2\\) \uff0c\u5373\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(2\\) \u9636\u65f6\uff0c\u8fd9\u4e00\u8f6e\u53ef\u9009\u62e9\u8df3 \\(1\\) \u9636\u6216\u8df3 \\(2\\) \u9636\uff1b

    \u5728\u8be5\u5b9a\u4e49\u4e0b\uff0c\\(dp[i, j]\\) \u8868\u793a\u72b6\u6001 \\([i, j]\\) \u5bf9\u5e94\u7684\u65b9\u6848\u6570\u3002\u7531\u6b64\uff0c\u6211\u4eec\u4fbf\u80fd\u63a8\u5bfc\u51fa\u4ee5\u4e0b\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff1a

    \\[ \\begin{cases} dp[i, 1] = dp[i-1, 2] \\\\ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2] \\end{cases} \\]

    Fig. \u8003\u8651\u7ea6\u675f\u4e0b\u7684\u9012\u63a8\u5173\u7cfb

    \u6700\u7ec8\uff0c\u8fd4\u56de \\(dp[n, 1] + dp[n, 2]\\) \u5373\u53ef\uff0c\u4e24\u8005\u4e4b\u548c\u4ee3\u8868\u722c\u5230\u7b2c \\(n\\) \u9636\u7684\u65b9\u6848\u603b\u6570\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_constraint_dp.java
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\nif (n == 1 || n == 2) {\nreturn n;\n}\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[][] dp = new int[n + 1][3];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1][1] = 1;\ndp[1][2] = 0;\ndp[2][1] = 0;\ndp[2][2] = 1;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i][1] = dp[i - 1][2];\ndp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n}\nreturn dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.cpp
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\nif (n == 1 || n == 2) {\nreturn n;\n}\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nvector<vector<int>> dp(n + 1, vector<int>(3, 0));\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1][1] = 1;\ndp[1][2] = 0;\ndp[2][1] = 0;\ndp[2][2] = 1;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i][1] = dp[i - 1][2];\ndp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n}\nreturn dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.py
    def climbing_stairs_constraint_dp(n: int) -> int:\n\"\"\"\u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nif n == 1 or n == 2:\nreturn n\n# \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\ndp = [[0] * 3 for _ in range(n + 1)]\n# \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1][1], dp[1][2] = 1, 0\ndp[2][1], dp[2][2] = 0, 1\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor i in range(3, n + 1):\ndp[i][1] = dp[i - 1][2]\ndp[i][2] = dp[i - 2][1] + dp[i - 2][2]\nreturn dp[n][1] + dp[n][2]\n
    climbing_stairs_constraint_dp.go
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.js
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.ts
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.c
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.cs
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\nif (n == 1 || n == 2) {\nreturn n;\n}\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[,] dp = new int[n + 1, 3];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1, 1] = 1;\ndp[1, 2] = 0;\ndp[2, 1] = 0;\ndp[2, 2] = 1;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i, 1] = dp[i - 1, 2];\ndp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n}\nreturn dp[n, 1] + dp[n, 2];\n}\n
    climbing_stairs_constraint_dp.swift
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.zig
    [class]{}-[func]{climbingStairsConstraintDP}\n
    climbing_stairs_constraint_dp.dart
    [class]{}-[func]{climbingStairsConstraintDP}\n

    \u5728\u4e0a\u9762\u7684\u6848\u4f8b\u4e2d\uff0c\u7531\u4e8e\u4ec5\u9700\u591a\u8003\u8651\u524d\u9762\u4e00\u4e2a\u72b6\u6001\uff0c\u6211\u4eec\u4ecd\u7136\u53ef\u4ee5\u901a\u8fc7\u6269\u5c55\u72b6\u6001\u5b9a\u4e49\uff0c\u4f7f\u5f97\u95ee\u9898\u6062\u590d\u65e0\u540e\u6548\u6027\u3002\u7136\u800c\uff0c\u8bb8\u591a\u95ee\u9898\u5177\u6709\u975e\u5e38\u4e25\u91cd\u7684\u201c\u6709\u540e\u6548\u6027\u201d\uff0c\u4f8b\u5982\uff1a

    \u722c\u697c\u68af\u4e0e\u969c\u788d\u751f\u6210

    \u7ed9\u5b9a\u4e00\u4e2a\u5171\u6709 \\(n\\) \u9636\u7684\u697c\u68af\uff0c\u4f60\u6bcf\u6b65\u53ef\u4ee5\u4e0a \\(1\\) \u9636\u6216\u8005 \\(2\\) \u9636\u3002\u89c4\u5b9a\u5f53\u722c\u5230\u7b2c \\(i\\) \u9636\u65f6\uff0c\u7cfb\u7edf\u81ea\u52a8\u4f1a\u7ed9\u7b2c \\(2i\\) \u9636\u4e0a\u653e\u4e0a\u969c\u788d\u7269\uff0c\u4e4b\u540e\u6240\u6709\u8f6e\u90fd\u4e0d\u5141\u8bb8\u8df3\u5230\u7b2c \\(2i\\) \u9636\u4e0a\u3002\u4f8b\u5982\uff0c\u524d\u4e24\u8f6e\u5206\u522b\u8df3\u5230\u4e86\u7b2c \\(2, 3\\) \u9636\u4e0a\uff0c\u5219\u4e4b\u540e\u5c31\u4e0d\u80fd\u8df3\u5230\u7b2c \\(4, 6\\) \u9636\u4e0a\u3002\u8bf7\u95ee\u6709\u591a\u5c11\u79cd\u65b9\u6848\u53ef\u4ee5\u722c\u5230\u697c\u9876\u3002

    \u5728\u8fd9\u4e2a\u95ee\u9898\u4e2d\uff0c\u4e0b\u6b21\u8df3\u8dc3\u4f9d\u8d56\u4e8e\u8fc7\u53bb\u6240\u6709\u7684\u72b6\u6001\uff0c\u56e0\u4e3a\u6bcf\u4e00\u6b21\u8df3\u8dc3\u90fd\u4f1a\u5728\u66f4\u9ad8\u7684\u9636\u68af\u4e0a\u8bbe\u7f6e\u969c\u788d\uff0c\u5e76\u5f71\u54cd\u672a\u6765\u7684\u8df3\u8dc3\u3002\u5bf9\u4e8e\u8fd9\u7c7b\u95ee\u9898\uff0c\u52a8\u6001\u89c4\u5212\u5f80\u5f80\u96be\u4ee5\u89e3\u51b3\uff0c\u6216\u662f\u56e0\u4e3a\u8ba1\u7b97\u590d\u6742\u5ea6\u8fc7\u9ad8\u800c\u96be\u4ee5\u5e94\u7528\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u7ec4\u5408\u4f18\u5316\u95ee\u9898\uff08\u4f8b\u5982\u8457\u540d\u7684\u65c5\u884c\u5546\u95ee\u9898\uff09\u90fd\u4e0d\u6ee1\u8db3\u65e0\u540e\u6548\u6027\u3002\u5bf9\u4e8e\u8fd9\u7c7b\u95ee\u9898\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u9009\u62e9\u4f7f\u7528\u5176\u4ed6\u65b9\u6cd5\uff0c\u4f8b\u5982\u542f\u53d1\u5f0f\u641c\u7d22\u3001\u9057\u4f20\u7b97\u6cd5\u3001\u5f3a\u5316\u5b66\u4e60\u7b49\uff0c\u4ece\u800c\u964d\u4f4e\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u5728\u6709\u9650\u65f6\u95f4\u5185\u5f97\u5230\u80fd\u591f\u63a5\u53d7\u7684\u5c40\u90e8\u6700\u4f18\u89e3\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","title":"13.3. \u00a0 \u52a8\u6001\u89c4\u5212\u89e3\u9898\u601d\u8def","text":"

    \u4e0a\u4e24\u8282\u4ecb\u7ecd\u4e86\u52a8\u6001\u89c4\u5212\u95ee\u9898\u7684\u4e3b\u8981\u7279\u5f81\uff0c\u63a5\u4e0b\u6765\u6211\u4eec\u4e00\u8d77\u63a2\u7a76\u4e24\u4e2a\u66f4\u52a0\u5b9e\u7528\u7684\u95ee\u9898\uff1a

    1. \u5982\u4f55\u5224\u65ad\u4e00\u4e2a\u95ee\u9898\u662f\u4e0d\u662f\u52a8\u6001\u89c4\u5212\u95ee\u9898\uff1f
    2. \u6c42\u89e3\u52a8\u6001\u89c4\u5212\u95ee\u9898\u8be5\u4ece\u4f55\u5904\u5165\u624b\uff0c\u5b8c\u6574\u6b65\u9aa4\u662f\u4ec0\u4e48\uff1f
    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1331","title":"13.3.1. \u00a0 \u95ee\u9898\u5224\u65ad","text":"

    \u603b\u7684\u6765\u8bf4\uff0c\u5982\u679c\u4e00\u4e2a\u95ee\u9898\u5305\u542b\u91cd\u53e0\u5b50\u95ee\u9898\u3001\u6700\u4f18\u5b50\u7ed3\u6784\uff0c\u5e76\u6ee1\u8db3\u65e0\u540e\u6548\u6027\uff0c\u90a3\u4e48\u5b83\u901a\u5e38\u5c31\u9002\u5408\u7528\u52a8\u6001\u89c4\u5212\u6c42\u89e3\uff0c\u4f46\u6211\u4eec\u5f88\u96be\u4ece\u95ee\u9898\u63cf\u8ff0\u4e0a\u76f4\u63a5\u63d0\u53d6\u51fa\u8fd9\u4e9b\u7279\u6027\u3002\u56e0\u6b64\u6211\u4eec\u901a\u5e38\u4f1a\u653e\u5bbd\u6761\u4ef6\uff0c\u5148\u89c2\u5bdf\u95ee\u9898\u662f\u5426\u9002\u5408\u4f7f\u7528\u56de\u6eaf\uff08\u7a77\u4e3e\uff09\u89e3\u51b3\u3002

    \u9002\u5408\u7528\u56de\u6eaf\u89e3\u51b3\u7684\u95ee\u9898\u901a\u5e38\u6ee1\u8db3\u201c\u51b3\u7b56\u6811\u6a21\u578b\u201d\uff0c\u8fd9\u79cd\u95ee\u9898\u53ef\u4ee5\u4f7f\u7528\u6811\u5f62\u7ed3\u6784\u6765\u63cf\u8ff0\uff0c\u5176\u4e2d\u6bcf\u4e00\u4e2a\u8282\u70b9\u4ee3\u8868\u4e00\u4e2a\u51b3\u7b56\uff0c\u6bcf\u4e00\u6761\u8def\u5f84\u4ee3\u8868\u4e00\u4e2a\u51b3\u7b56\u5e8f\u5217\u3002

    \u6362\u53e5\u8bdd\u8bf4\uff0c\u5982\u679c\u95ee\u9898\u5305\u542b\u660e\u786e\u7684\u51b3\u7b56\u6982\u5ff5\uff0c\u5e76\u4e14\u89e3\u662f\u901a\u8fc7\u4e00\u7cfb\u5217\u51b3\u7b56\u4ea7\u751f\u7684\uff0c\u90a3\u4e48\u5b83\u5c31\u6ee1\u8db3\u51b3\u7b56\u6811\u6a21\u578b\uff0c\u901a\u5e38\u53ef\u4ee5\u4f7f\u7528\u56de\u6eaf\u6765\u89e3\u51b3\u3002

    \u5728\u6b64\u57fa\u7840\u4e0a\uff0c\u8fd8\u6709\u4e00\u4e9b\u5224\u65ad\u95ee\u9898\u662f\u52a8\u6001\u89c4\u5212\u95ee\u9898\u7684\u201c\u52a0\u5206\u9879\u201d\uff0c\u5305\u62ec\uff1a

    • \u95ee\u9898\u5305\u542b\u6700\u5927\uff08\u5c0f\uff09\u6216\u6700\u591a\uff08\u5c11\uff09\u7b49\u6700\u4f18\u5316\u63cf\u8ff0\uff1b
    • \u95ee\u9898\u7684\u72b6\u6001\u80fd\u591f\u4f7f\u7528\u4e00\u4e2a\u5217\u8868\u3001\u591a\u7ef4\u77e9\u9635\u6216\u6811\u6765\u8868\u793a\uff0c\u5e76\u4e14\u4e00\u4e2a\u72b6\u6001\u4e0e\u5176\u5468\u56f4\u7684\u72b6\u6001\u5b58\u5728\u67d0\u79cd\u9012\u63a8\u5173\u7cfb\uff1b

    \u800c\u76f8\u5e94\u7684\u201c\u51cf\u5206\u9879\u201d\u5305\u62ec\uff1a

    • \u95ee\u9898\u7684\u76ee\u6807\u662f\u627e\u51fa\u6240\u6709\u53ef\u80fd\u7684\u89e3\u51b3\u65b9\u6848\uff0c\u800c\u4e0d\u662f\u627e\u51fa\u6700\u4f18\u89e3\u3002
    • \u95ee\u9898\u63cf\u8ff0\u4e2d\u6709\u660e\u663e\u7684\u6392\u5217\u7ec4\u5408\u7684\u7279\u5f81\uff0c\u9700\u8981\u8fd4\u56de\u5177\u4f53\u7684\u591a\u4e2a\u65b9\u6848\u3002

    \u5982\u679c\u4e00\u4e2a\u95ee\u9898\u6ee1\u8db3\u51b3\u7b56\u6811\u6a21\u578b\uff0c\u5e76\u5177\u6709\u8f83\u4e3a\u660e\u663e\u7684\u201c\u52a0\u5206\u9879\u201c\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5047\u8bbe\u5b83\u662f\u4e00\u4e2a\u52a8\u6001\u89c4\u5212\u95ee\u9898\uff0c\u5e76\u5c1d\u8bd5\u6c42\u89e3\u5b83\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1332","title":"13.3.2. \u00a0 \u95ee\u9898\u6c42\u89e3","text":"

    \u52a8\u6001\u89c4\u5212\u7684\u89e3\u9898\u6d41\u7a0b\u53ef\u80fd\u4f1a\u56e0\u95ee\u9898\u7684\u6027\u8d28\u548c\u96be\u5ea6\u800c\u6709\u6240\u4e0d\u540c\uff0c\u4f46\u901a\u5e38\u9075\u5faa\u4ee5\u4e0b\u6b65\u9aa4\uff1a\u63cf\u8ff0\u51b3\u7b56\uff0c\u5b9a\u4e49\u72b6\u6001\uff0c\u5efa\u7acb \\(dp\\) \u8868\uff0c\u63a8\u5bfc\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff0c\u786e\u5b9a\u8fb9\u754c\u6761\u4ef6\u7b49\u3002

    \u4e3a\u4e86\u66f4\u5f62\u8c61\u5730\u5c55\u793a\u89e3\u9898\u6b65\u9aa4\uff0c\u6211\u4eec\u4f7f\u7528\u4e00\u4e2a\u7ecf\u5178\u95ee\u9898\u300c\u6700\u5c0f\u8def\u5f84\u548c\u300d\u6765\u4e3e\u4f8b\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a \\(n \\times m\\) \u7684\u4e8c\u7ef4\u7f51\u683c grid \uff0c\u7f51\u683c\u4e2d\u7684\u6bcf\u4e2a\u5355\u5143\u683c\u5305\u542b\u4e00\u4e2a\u975e\u8d1f\u6574\u6570\uff0c\u8868\u793a\u8be5\u5355\u5143\u683c\u7684\u4ee3\u4ef7\u3002\u673a\u5668\u4eba\u4ee5\u5de6\u4e0a\u89d2\u5355\u5143\u683c\u4e3a\u8d77\u59cb\u70b9\uff0c\u6bcf\u6b21\u53ea\u80fd\u5411\u4e0b\u6216\u8005\u5411\u53f3\u79fb\u52a8\u4e00\u6b65\uff0c\u76f4\u81f3\u5230\u8fbe\u53f3\u4e0b\u89d2\u5355\u5143\u683c\u3002\u8bf7\u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230\u53f3\u4e0b\u89d2\u7684\u6700\u5c0f\u8def\u5f84\u548c\u3002

    \u4f8b\u5982\u4ee5\u4e0b\u793a\u4f8b\u6570\u636e\uff0c\u7ed9\u5b9a\u7f51\u683c\u7684\u6700\u5c0f\u8def\u5f84\u548c\u4e3a \\(13\\) \u3002

    Fig. \u6700\u5c0f\u8def\u5f84\u548c\u793a\u4f8b\u6570\u636e

    \u7b2c\u4e00\u6b65\uff1a\u601d\u8003\u6bcf\u8f6e\u7684\u51b3\u7b56\uff0c\u5b9a\u4e49\u72b6\u6001\uff0c\u4ece\u800c\u5f97\u5230 \\(dp\\) \u8868

    \u672c\u9898\u7684\u6bcf\u4e00\u8f6e\u7684\u51b3\u7b56\u5c31\u662f\u4ece\u5f53\u524d\u683c\u5b50\u5411\u4e0b\u6216\u5411\u53f3\u4e00\u6b65\u3002\u8bbe\u5f53\u524d\u683c\u5b50\u7684\u884c\u5217\u7d22\u5f15\u4e3a \\([i, j]\\) \uff0c\u5219\u5411\u4e0b\u6216\u5411\u53f3\u8d70\u4e00\u6b65\u540e\uff0c\u7d22\u5f15\u53d8\u4e3a \\([i+1, j]\\) \u6216 \\([i, j+1]\\) \u3002\u56e0\u6b64\uff0c\u72b6\u6001\u5e94\u5305\u542b\u884c\u7d22\u5f15\u548c\u5217\u7d22\u5f15\u4e24\u4e2a\u53d8\u91cf\uff0c\u8bb0\u4e3a \\([i, j]\\) \u3002

    \u72b6\u6001 \\([i, j]\\) \u5bf9\u5e94\u7684\u5b50\u95ee\u9898\u4e3a\uff1a\u4ece\u8d77\u59cb\u70b9 \\([0, 0]\\) \u8d70\u5230 \\([i, j]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c\uff0c\u89e3\u8bb0\u4e3a \\(dp[i, j]\\) \u3002

    \u81f3\u6b64\uff0c\u6211\u4eec\u5c31\u5f97\u5230\u4e86\u4e00\u4e2a\u4e8c\u7ef4 \\(dp\\) \u77e9\u9635\uff0c\u5176\u5c3a\u5bf8\u4e0e\u8f93\u5165\u7f51\u683c \\(grid\\) \u76f8\u540c\u3002

    Fig. \u72b6\u6001\u5b9a\u4e49\u4e0e dp \u8868

    Note

    \u52a8\u6001\u89c4\u5212\u548c\u56de\u6eaf\u901a\u5e38\u90fd\u4f1a\u88ab\u63cf\u8ff0\u4e3a\u4e00\u4e2a\u51b3\u7b56\u5e8f\u5217\uff0c\u800c\u72b6\u6001\u901a\u5e38\u7531\u6240\u6709\u51b3\u7b56\u53d8\u91cf\u6784\u6210\u3002\u5b83\u5e94\u5f53\u5305\u542b\u63cf\u8ff0\u89e3\u9898\u8fdb\u5ea6\u7684\u6240\u6709\u53d8\u91cf\uff0c\u5176\u5305\u542b\u4e86\u8db3\u591f\u7684\u4fe1\u606f\uff0c\u80fd\u591f\u7528\u6765\u63a8\u5bfc\u51fa\u4e0b\u4e00\u4e2a\u72b6\u6001\u3002

    \u6bcf\u4e2a\u72b6\u6001\u90fd\u5bf9\u5e94\u4e00\u4e2a\u5b50\u95ee\u9898\uff0c\u6211\u4eec\u4f1a\u5b9a\u4e49\u4e00\u4e2a \\(dp\\) \u8868\u6765\u5b58\u50a8\u6240\u6709\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u72b6\u6001\u7684\u6bcf\u4e2a\u72ec\u7acb\u53d8\u91cf\u90fd\u662f \\(dp\\) \u8868\u7684\u4e00\u4e2a\u7ef4\u5ea6\u3002\u672c\u8d28\u4e0a\u770b\uff0c\\(dp\\) \u8868\u662f\u5b50\u95ee\u9898\u7684\u89e3\u548c\u72b6\u6001\u4e4b\u95f4\u7684\u6620\u5c04\u3002

    \u7b2c\u4e8c\u6b65\uff1a\u627e\u51fa\u6700\u4f18\u5b50\u7ed3\u6784\uff0c\u8fdb\u800c\u63a8\u5bfc\u51fa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b

    \u5bf9\u4e8e\u72b6\u6001 \\([i, j]\\) \uff0c\u5b83\u53ea\u80fd\u4ece\u4e0a\u8fb9\u683c\u5b50 \\([i-1, j]\\) \u548c\u5de6\u8fb9\u683c\u5b50 \\([i, j-1]\\) \u8f6c\u79fb\u800c\u6765\u3002\u56e0\u6b64\u6700\u4f18\u5b50\u7ed3\u6784\u4e3a\uff1a\u5230\u8fbe \\([i, j]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c\u7531 \\([i, j-1]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c\u4e0e \\([i-1, j]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c\uff0c\u8fd9\u4e24\u8005\u8f83\u5c0f\u7684\u90a3\u4e00\u4e2a\u51b3\u5b9a\u3002

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u53ef\u63a8\u51fa\u4ee5\u4e0b\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff1a

    \\[ dp[i, j] = \\min(dp[i-1, j], dp[i, j-1]) + grid[i, j] \\]

    Fig. \u6700\u4f18\u5b50\u7ed3\u6784\u4e0e\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b

    Note

    \u57fa\u4e8e\u5b9a\u4e49\u597d\u7684 \\(dp\\) \u8868\uff0c\u6211\u4eec\u601d\u8003\u539f\u95ee\u9898\u548c\u5b50\u95ee\u9898\u7684\u5173\u7cfb\uff0c\u627e\u51fa\u5982\u4f55\u901a\u8fc7\u5b50\u95ee\u9898\u7684\u89e3\u6765\u6784\u9020\u539f\u95ee\u9898\u7684\u89e3\u3002

    \u6700\u4f18\u5b50\u7ed3\u6784\u63ed\u793a\u4e86\u539f\u95ee\u9898\u548c\u5b50\u95ee\u9898\u7684\u9012\u63a8\u5173\u7cfb\uff0c\u4e00\u65e6\u6211\u4eec\u627e\u5230\u4e86\u6700\u4f18\u5b50\u7ed3\u6784\uff0c\u5c31\u53ef\u4ee5\u4f7f\u7528\u5b83\u6765\u6784\u5efa\u51fa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u3002

    \u7b2c\u4e09\u6b65\uff1a\u786e\u5b9a\u8fb9\u754c\u6761\u4ef6\u548c\u72b6\u6001\u8f6c\u79fb\u987a\u5e8f

    \u5728\u672c\u9898\u4e2d\uff0c\u5f53 \\(i=0\\) \u6216 \\(j=0\\) \u65f6\u53ea\u6709\u4e00\u79cd\u53ef\u80fd\u7684\u8def\u5f84\uff0c\u5373\u53ea\u80fd\u5411\u53f3\u79fb\u52a8\u6216\u53ea\u80fd\u5411\u4e0b\u79fb\u52a8\uff0c\u56e0\u6b64\u9996\u884c\u548c\u9996\u5217\u662f\u8fb9\u754c\u6761\u4ef6\u3002

    \u6bcf\u4e2a\u683c\u5b50\u662f\u7531\u5176\u5de6\u65b9\u683c\u5b50\u548c\u4e0a\u65b9\u683c\u5b50\u8f6c\u79fb\u800c\u6765\uff0c\u56e0\u6b64\u6211\u4eec\u4f7f\u7528\u4e24\u5c42\u5faa\u73af\u6765\u904d\u5386\u77e9\u9635\u5373\u53ef\uff0c\u5373\u5916\u5faa\u73af\u6b63\u5e8f\u904d\u5386\u5404\u884c\u3001\u5185\u5faa\u73af\u6b63\u5e8f\u904d\u5386\u5404\u5217\u3002

    Fig. \u8fb9\u754c\u6761\u4ef6\u4e0e\u72b6\u6001\u8f6c\u79fb\u987a\u5e8f

    Note

    \u8fb9\u754c\u6761\u4ef6\u5373\u521d\u59cb\u72b6\u6001\uff0c\u5728\u641c\u7d22\u4e2d\u7528\u4e8e\u526a\u679d\uff0c\u5728\u52a8\u6001\u89c4\u5212\u4e2d\u7528\u4e8e\u521d\u59cb\u5316 \\(dp\\) \u8868\u3002\u72b6\u6001\u8f6c\u79fb\u987a\u5e8f\u7684\u6838\u5fc3\u662f\u8981\u4fdd\u8bc1\u5728\u8ba1\u7b97\u5f53\u524d\u95ee\u9898\u65f6\uff0c\u6240\u6709\u5b83\u4f9d\u8d56\u7684\u66f4\u5c0f\u5b50\u95ee\u9898\u90fd\u5df2\u7ecf\u88ab\u6b63\u786e\u5730\u8ba1\u7b97\u51fa\u6765\u3002

    \u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5b9e\u73b0\u52a8\u6001\u89c4\u5212\u4ee3\u7801\u4e86\u3002\u7136\u800c\uff0c\u7531\u4e8e\u5b50\u95ee\u9898\u5206\u89e3\u662f\u4e00\u79cd\u4ece\u9876\u81f3\u5e95\u7684\u601d\u60f3\uff0c\u56e0\u6b64\u6309\u7167\u201c\u66b4\u529b\u641c\u7d22 \\(\\rightarrow\\) \u8bb0\u5fc6\u5316\u641c\u7d22 \\(\\rightarrow\\) \u52a8\u6001\u89c4\u5212\u201d\u7684\u987a\u5e8f\u5b9e\u73b0\u66f4\u52a0\u7b26\u5408\u601d\u7ef4\u4e60\u60ef\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1333","title":"13.3.3. \u00a0 \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u641c\u7d22","text":"

    \u4ece\u72b6\u6001 \\([i, j]\\) \u5f00\u59cb\u641c\u7d22\uff0c\u4e0d\u65ad\u5206\u89e3\u4e3a\u66f4\u5c0f\u7684\u72b6\u6001 \\([i-1, j]\\) \u548c \\([i, j-1]\\) \uff0c\u5305\u62ec\u4ee5\u4e0b\u9012\u5f52\u8981\u7d20\uff1a

    • \u9012\u5f52\u53c2\u6570\uff1a\u72b6\u6001 \\([i, j]\\) \uff1b\u8fd4\u56de\u503c\uff1a\u4ece \\([0, 0]\\) \u5230 \\([i, j]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c \\(dp[i, j]\\) \uff1b
    • \u7ec8\u6b62\u6761\u4ef6\uff1a\u5f53 \\(i = 0\\) \u4e14 \\(j = 0\\) \u65f6\uff0c\u8fd4\u56de\u4ee3\u4ef7 \\(grid[0, 0]\\) \uff1b
    • \u526a\u679d\uff1a\u5f53 \\(i < 0\\) \u65f6\u6216 \\(j < 0\\) \u65f6\u7d22\u5f15\u8d8a\u754c\uff0c\u6b64\u65f6\u8fd4\u56de\u4ee3\u4ef7 \\(+\\infty\\) \uff0c\u4ee3\u8868\u4e0d\u53ef\u884c\uff1b
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nint minPathSumDFS(int[][] grid, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0) {\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn Integer.MAX_VALUE;\n}\n// \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFS(grid, i - 1, j);\nint up = minPathSumDFS(grid, i, j - 1);\n// \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nreturn Math.min(left, up) + grid[i][j];\n}\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nint minPathSumDFS(vector<vector<int>> &grid, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0) {\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn INT_MAX;\n}\n// \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFS(grid, i - 1, j);\nint up = minPathSumDFS(grid, i, j - 1);\n// \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nreturn min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n
    min_path_sum.py
    def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -> int:\n\"\"\"\u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22\"\"\"\n# \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif i == 0 and j == 0:\nreturn grid[0][0]\n# \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif i < 0 or j < 0:\nreturn inf\n# \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nleft = min_path_sum_dfs(grid, i - 1, j)\nup = min_path_sum_dfs(grid, i, j - 1)\n# \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nreturn min(left, up) + grid[i][j]\n
    min_path_sum.go
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.js
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.ts
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.c
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nint minPathSumDFS(int[][] grid, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0){\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn int.MaxValue;\n}\n// \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFS(grid, i - 1, j);\nint up = minPathSumDFS(grid, i, j - 1);\n// \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nreturn Math.Min(left, up) + grid[i][j];\n}\n
    min_path_sum.swift
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.zig
    [class]{}-[func]{minPathSumDFS}\n
    min_path_sum.dart
    [class]{}-[func]{minPathSumDFS}\n

    \u6211\u4eec\u5c1d\u8bd5\u753b\u51fa\u4ee5 \\(dp[2, 1]\\) \u4e3a\u6839\u8282\u70b9\u7684\u9012\u5f52\u6811\u3002\u89c2\u5bdf\u4e0b\u56fe\uff0c\u9012\u5f52\u6811\u5305\u542b\u4e00\u4e9b\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u5176\u6570\u91cf\u4f1a\u968f\u7740\u7f51\u683c grid \u7684\u5c3a\u5bf8\u53d8\u5927\u800c\u6025\u5267\u589e\u591a\u3002

    \u76f4\u89c2\u4e0a\u770b\uff0c\u5b58\u5728\u591a\u6761\u8def\u5f84\u53ef\u4ee5\u4ece\u5de6\u4e0a\u89d2\u5230\u8fbe\u540c\u4e00\u5355\u5143\u683c\uff0c\u8fd9\u4fbf\u662f\u8be5\u95ee\u9898\u5b58\u5728\u91cd\u53e0\u5b50\u95ee\u9898\u7684\u5185\u5728\u539f\u56e0\u3002

    Fig. \u66b4\u529b\u641c\u7d22\u9012\u5f52\u6811

    \u6bcf\u4e2a\u72b6\u6001\u90fd\u6709\u5411\u4e0b\u548c\u5411\u53f3\u4e24\u79cd\u9009\u62e9\uff0c\u4ece\u5de6\u4e0a\u89d2\u8d70\u5230\u53f3\u4e0b\u89d2\u603b\u5171\u9700\u8981 \\(m + n - 2\\) \u6b65\uff0c\u6240\u4ee5\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^{m + n})\\) \u3002\u8bf7\u6ce8\u610f\uff0c\u8fd9\u79cd\u8ba1\u7b97\u65b9\u5f0f\u672a\u8003\u8651\u4e34\u8fd1\u7f51\u683c\u8fb9\u754c\u7684\u60c5\u51b5\uff0c\u5f53\u5230\u8fbe\u7f51\u7edc\u8fb9\u754c\u65f6\u53ea\u5269\u4e0b\u4e00\u79cd\u9009\u62e9\u3002\u56e0\u6b64\u5b9e\u9645\u7684\u8def\u5f84\u6570\u91cf\u4f1a\u5c11\u4e00\u4e9b\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1334","title":"13.3.4. \u00a0 \u65b9\u6cd5\u4e8c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22","text":"

    \u4e3a\u4e86\u907f\u514d\u91cd\u590d\u8ba1\u7b97\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u6211\u4eec\u5f15\u5165\u4e00\u4e2a\u548c\u7f51\u683c grid \u76f8\u540c\u5c3a\u5bf8\u7684\u8bb0\u5fc6\u5217\u8868 mem \uff0c\u7528\u4e8e\u8bb0\u5f55\u5404\u4e2a\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u63d0\u5347\u641c\u7d22\u6548\u7387\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0) {\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn Integer.MAX_VALUE;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][j] != -1) {\nreturn mem[i][j];\n}\n// \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFSMem(grid, mem, i - 1, j);\nint up = minPathSumDFSMem(grid, mem, i, j - 1);\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nmem[i][j] = Math.min(left, up) + grid[i][j];\nreturn mem[i][j];\n}\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint minPathSumDFSMem(vector<vector<int>> &grid, vector<vector<int>> &mem, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0) {\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn INT_MAX;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][j] != -1) {\nreturn mem[i][j];\n}\n// \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFSMem(grid, mem, i - 1, j);\nint up = minPathSumDFSMem(grid, mem, i, j - 1);\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nmem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\nreturn mem[i][j];\n}\n
    min_path_sum.py
    def min_path_sum_dfs_mem(\ngrid: list[list[int]], mem: list[list[int]], i: int, j: int\n) -> int:\n\"\"\"\u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\"\"\"\n# \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif i == 0 and j == 0:\nreturn grid[0][0]\n# \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif i < 0 or j < 0:\nreturn inf\n# \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif mem[i][j] != -1:\nreturn mem[i][j]\n# \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nleft = min_path_sum_dfs_mem(grid, mem, i - 1, j)\nup = min_path_sum_dfs_mem(grid, mem, i, j - 1)\n# \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nmem[i][j] = min(left, up) + grid[i][j]\nreturn mem[i][j]\n
    min_path_sum.go
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.js
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.ts
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.c
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {\n// \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\nif (i == 0 && j == 0) {\nreturn grid[0][0];\n}\n// \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\nif (i < 0 || j < 0) {\nreturn int.MaxValue;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][j] != -1) {\nreturn mem[i][j];\n}\n// \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nint left = minPathSumDFSMem(grid, mem, i - 1, j);\nint up = minPathSumDFSMem(grid, mem, i, j - 1);\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\nmem[i][j] = Math.Min(left, up) + grid[i][j];\nreturn mem[i][j];\n}\n
    min_path_sum.swift
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.zig
    [class]{}-[func]{minPathSumDFSMem}\n
    min_path_sum.dart
    [class]{}-[func]{minPathSumDFSMem}\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5f15\u5165\u8bb0\u5fc6\u5316\u53ef\u4ee5\u6d88\u9664\u6240\u6709\u91cd\u590d\u8ba1\u7b97\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u72b6\u6001\u603b\u6570\uff0c\u5373\u7f51\u683c\u5c3a\u5bf8 \\(O(nm)\\) \u3002

    Fig. \u8bb0\u5fc6\u5316\u641c\u7d22\u9012\u5f52\u6811

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1335","title":"13.3.5. \u00a0 \u65b9\u6cd5\u4e09\uff1a\u52a8\u6001\u89c4\u5212","text":"

    \u52a8\u6001\u89c4\u5212\u4ee3\u7801\u662f\u4ece\u5e95\u81f3\u9876\u7684\uff0c\u4ec5\u9700\u5faa\u73af\u5373\u53ef\u5b9e\u73b0\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(int[][] grid) {\nint n = grid.length, m = grid[0].length;\n// \u521d\u59cb\u5316 dp \u8868\nint[][] dp = new int[n][m];\ndp[0][0] = grid[0][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\nfor (int j = 1; j < m; j++) {\ndp[0][j] = dp[0][j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\nfor (int i = 1; i < n; i++) {\ndp[i][0] = dp[i - 1][0] + grid[i][0];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u5217\nfor (int i = 1; i < n; i++) {\nfor (int j = 1; j < m; j++) {\ndp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n}\n}\nreturn dp[n - 1][m - 1];\n}\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(vector<vector<int>> &grid) {\nint n = grid.size(), m = grid[0].size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<vector<int>> dp(n, vector<int>(m));\ndp[0][0] = grid[0][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\nfor (int j = 1; j < m; j++) {\ndp[0][j] = dp[0][j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\nfor (int i = 1; i < n; i++) {\ndp[i][0] = dp[i - 1][0] + grid[i][0];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u5217\nfor (int i = 1; i < n; i++) {\nfor (int j = 1; j < m; j++) {\ndp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n}\n}\nreturn dp[n - 1][m - 1];\n}\n
    min_path_sum.py
    def min_path_sum_dp(grid: list[list[int]]) -> int:\n\"\"\"\u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nn, m = len(grid), len(grid[0])\n# \u521d\u59cb\u5316 dp \u8868\ndp = [[0] * m for _ in range(n)]\ndp[0][0] = grid[0][0]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\nfor j in range(1, m):\ndp[0][j] = dp[0][j - 1] + grid[0][j]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\nfor i in range(1, n):\ndp[i][0] = dp[i - 1][0] + grid[i][0]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u5217\nfor i in range(1, n):\nfor j in range(1, m):\ndp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\nreturn dp[n - 1][m - 1]\n
    min_path_sum.go
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.js
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.ts
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.c
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(int[][] grid) {\nint n = grid.Length, m = grid[0].Length;\n// \u521d\u59cb\u5316 dp \u8868\nint[,] dp = new int[n, m];\ndp[0, 0] = grid[0][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\nfor (int j = 1; j < m; j++) {\ndp[0, j] = dp[0, j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\nfor (int i = 1; i < n; i++) {\ndp[i, 0] = dp[i - 1, 0] + grid[i][0];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u5217\nfor (int i = 1; i < n; i++) {\nfor (int j = 1; j < m; j++) {\ndp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n}\n}\nreturn dp[n - 1, m - 1];\n}\n
    min_path_sum.swift
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.zig
    [class]{}-[func]{minPathSumDP}\n
    min_path_sum.dart
    [class]{}-[func]{minPathSumDP}\n

    \u4e0b\u56fe\u5c55\u793a\u4e86\u6700\u5c0f\u8def\u5f84\u548c\u7684\u72b6\u6001\u8f6c\u79fb\u8fc7\u7a0b\u3002\u8be5\u8fc7\u7a0b\u904d\u5386\u4e86\u6574\u4e2a\u7f51\u683c\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(nm)\\) \uff1b\u6570\u7ec4 dp \u4f7f\u7528 \\(O(nm)\\) \u7a7a\u95f4\u3002

    <1><2><3><4><5><6><7><8><9><10><11><12>

    \u5982\u679c\u5e0c\u671b\u8fdb\u4e00\u6b65\u8282\u7701\u7a7a\u95f4\u4f7f\u7528\uff0c\u53ef\u4ee5\u8003\u8651\u8fdb\u884c\u72b6\u6001\u538b\u7f29\u3002\u6bcf\u4e2a\u683c\u5b50\u53ea\u4e0e\u5de6\u8fb9\u548c\u4e0a\u8fb9\u7684\u683c\u5b50\u6709\u5173\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u53ea\u7528\u4e00\u4e2a\u5355\u884c\u6570\u7ec4\u6765\u5b9e\u73b0 \\(dp\\) \u8868\u3002

    \u7531\u4e8e\u6570\u7ec4 dp \u53ea\u80fd\u8868\u793a\u4e00\u884c\u7684\u72b6\u6001\uff0c\u56e0\u6b64\u6211\u4eec\u65e0\u6cd5\u63d0\u524d\u521d\u59cb\u5316\u9996\u5217\u72b6\u6001\uff0c\u800c\u662f\u5728\u904d\u5386\u6bcf\u884c\u4e2d\u66f4\u65b0\u5b83\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(int[][] grid) {\nint n = grid.length, m = grid[0].length;\n// \u521d\u59cb\u5316 dp \u8868\nint[] dp = new int[m];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\ndp[0] = grid[0][0];\nfor (int j = 1; j < m; j++) {\ndp[j] = dp[j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\nfor (int i = 1; i < n; i++) {\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\ndp[0] = dp[0] + grid[i][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\nfor (int j = 1; j < m; j++) {\ndp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n}\n}\nreturn dp[m - 1];\n}\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(vector<vector<int>> &grid) {\nint n = grid.size(), m = grid[0].size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<int> dp(m);\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\ndp[0] = grid[0][0];\nfor (int j = 1; j < m; j++) {\ndp[j] = dp[j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\nfor (int i = 1; i < n; i++) {\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\ndp[0] = dp[0] + grid[i][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\nfor (int j = 1; j < m; j++) {\ndp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n}\n}\nreturn dp[m - 1];\n}\n
    min_path_sum.py
    def min_path_sum_dp_comp(grid: list[list[int]]) -> int:\n\"\"\"\u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\nn, m = len(grid), len(grid[0])\n# \u521d\u59cb\u5316 dp \u8868\ndp = [0] * m\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\ndp[0] = grid[0][0]\nfor j in range(1, m):\ndp[j] = dp[j - 1] + grid[0][j]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\nfor i in range(1, n):\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\ndp[0] = dp[0] + grid[i][0]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\nfor j in range(1, m):\ndp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\nreturn dp[m - 1]\n
    min_path_sum.go
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.js
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.ts
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.c
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(int[][] grid) {\nint n = grid.Length, m = grid[0].Length;\n// \u521d\u59cb\u5316 dp \u8868\nint[] dp = new int[m];\ndp[0] = grid[0][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\nfor (int j = 1; j < m; j++) {\ndp[j] = dp[j - 1] + grid[0][j];\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\nfor (int i = 1; i < n; i++) {\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\ndp[0] = dp[0] + grid[i][0];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\nfor (int j = 1; j < m; j++) {\ndp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n}\n}\nreturn dp[m - 1];\n}\n
    min_path_sum.swift
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.zig
    [class]{}-[func]{minPathSumDPComp}\n
    min_path_sum.dart
    [class]{}-[func]{minPathSumDPComp}\n
    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","title":"13.1. \u00a0 \u521d\u63a2\u52a8\u6001\u89c4\u5212","text":"

    \u300c\u52a8\u6001\u89c4\u5212 Dynamic Programming\u300d\u662f\u4e00\u79cd\u901a\u8fc7\u5c06\u590d\u6742\u95ee\u9898\u5206\u89e3\u4e3a\u66f4\u7b80\u5355\u7684\u5b50\u95ee\u9898\u7684\u65b9\u5f0f\u6765\u6c42\u89e3\u95ee\u9898\u7684\u65b9\u6cd5\u3002\u5b83\u5c06\u4e00\u4e2a\u95ee\u9898\u5206\u89e3\u4e3a\u4e00\u7cfb\u5217\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\uff0c\u5e76\u901a\u8fc7\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\u6765\u907f\u514d\u91cd\u590d\u8ba1\u7b97\uff0c\u4ece\u800c\u5927\u5e45\u63d0\u5347\u65f6\u95f4\u6548\u7387\u3002

    \u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u4ece\u4e00\u4e2a\u7ecf\u5178\u4f8b\u9898\u5165\u624b\uff0c\u5148\u7ed9\u51fa\u5b83\u7684\u66b4\u529b\u56de\u6eaf\u89e3\u6cd5\uff0c\u89c2\u5bdf\u5176\u4e2d\u5305\u542b\u7684\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u518d\u9010\u6b65\u5bfc\u51fa\u66f4\u9ad8\u6548\u7684\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\u3002

    \u722c\u697c\u68af

    \u7ed9\u5b9a\u4e00\u4e2a\u5171\u6709 \\(n\\) \u9636\u7684\u697c\u68af\uff0c\u4f60\u6bcf\u6b65\u53ef\u4ee5\u4e0a \\(1\\) \u9636\u6216\u8005 \\(2\\) \u9636\uff0c\u8bf7\u95ee\u6709\u591a\u5c11\u79cd\u65b9\u6848\u53ef\u4ee5\u722c\u5230\u697c\u9876\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5bf9\u4e8e\u4e00\u4e2a \\(3\\) \u9636\u697c\u68af\uff0c\u5171\u6709 \\(3\\) \u79cd\u65b9\u6848\u53ef\u4ee5\u722c\u5230\u697c\u9876\u3002

    Fig. \u722c\u5230\u7b2c 3 \u9636\u7684\u65b9\u6848\u6570\u91cf

    \u672c\u9898\u7684\u76ee\u6807\u662f\u6c42\u89e3\u65b9\u6848\u6570\u91cf\uff0c\u6211\u4eec\u53ef\u4ee5\u8003\u8651\u901a\u8fc7\u56de\u6eaf\u6765\u7a77\u4e3e\u6240\u6709\u53ef\u80fd\u6027\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u5c06\u722c\u697c\u68af\u60f3\u8c61\u4e3a\u4e00\u4e2a\u591a\u8f6e\u9009\u62e9\u7684\u8fc7\u7a0b\uff1a\u4ece\u5730\u9762\u51fa\u53d1\uff0c\u6bcf\u8f6e\u9009\u62e9\u4e0a \\(1\\) \u9636\u6216 \\(2\\) \u9636\uff0c\u6bcf\u5f53\u5230\u8fbe\u697c\u68af\u9876\u90e8\u65f6\u5c31\u5c06\u65b9\u6848\u6570\u91cf\u52a0 \\(1\\) \uff0c\u5f53\u8d8a\u8fc7\u697c\u68af\u9876\u90e8\u65f6\u5c31\u5c06\u5176\u526a\u679d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_backtrack.java
    /* \u56de\u6eaf */\nvoid backtrack(List<Integer> choices, int state, int n, List<Integer> res) {\n// \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\nif (state == n)\nres.set(0, res.get(0) + 1);\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (Integer choice : choices) {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\nif (state + choice > n)\nbreak;\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nbacktrack(choices, state + choice, n, res);\n// \u56de\u9000\n}\n}\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\nList<Integer> choices = Arrays.asList(1, 2); // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u6216 2 \u9636\nint state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\nList<Integer> res = new ArrayList<>();\nres.add(0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\nbacktrack(choices, state, n, res);\nreturn res.get(0);\n}\n
    climbing_stairs_backtrack.cpp
    /* \u56de\u6eaf */\nvoid backtrack(vector<int> &choices, int state, int n, vector<int> &res) {\n// \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\nif (state == n)\nres[0]++;\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nfor (auto &choice : choices) {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\nif (state + choice > n)\nbreak;\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nbacktrack(choices, state + choice, n, res);\n// \u56de\u9000\n}\n}\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\nvector<int> choices = {1, 2}; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u6216 2 \u9636\nint state = 0;                // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\nvector<int> res = {0};        // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\nbacktrack(choices, state, n, res);\nreturn res[0];\n}\n
    climbing_stairs_backtrack.py
    def backtrack(choices: list[int], state: int, n: int, res: list[int]) -> int:\n\"\"\"\u56de\u6eaf\"\"\"\n# \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\nif state == n:\nres[0] += 1\n# \u904d\u5386\u6240\u6709\u9009\u62e9\nfor choice in choices:\n# \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\nif state + choice > n:\nbreak\n# \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nbacktrack(choices, state + choice, n, res)\n# \u56de\u9000\ndef climbing_stairs_backtrack(n: int) -> int:\n\"\"\"\u722c\u697c\u68af\uff1a\u56de\u6eaf\"\"\"\nchoices = [1, 2]  # \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u6216 2 \u9636\nstate = 0  # \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\nres = [0]  # \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\nbacktrack(choices, state, n, res)\nreturn res[0]\n
    climbing_stairs_backtrack.go
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.js
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.ts
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.c
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.cs
    /* \u56de\u6eaf */\nvoid backtrack(List<int> choices, int state, int n, List<int> res) {\n// \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\nif (state == n)\nres[0]++;\n// \u904d\u5386\u6240\u6709\u9009\u62e9\nforeach (int choice in choices) {\n// \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\nif (state + choice > n)\nbreak;\n// \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\nbacktrack(choices, state + choice, n, res);\n// \u56de\u9000\n}\n}\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\nList<int> choices = new List<int> { 1, 2 }; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u6216 2 \u9636\nint state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\nList<int> res = new List<int> { 0 }; // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\nbacktrack(choices, state, n, res);\nreturn res[0];\n}\n
    climbing_stairs_backtrack.swift
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.zig
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    climbing_stairs_backtrack.dart
    [class]{}-[func]{backtrack}\n[class]{}-[func]{climbingStairsBacktrack}\n
    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1311","title":"13.1.1. \u00a0 \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u641c\u7d22","text":"

    \u56de\u6eaf\u7b97\u6cd5\u901a\u5e38\u5e76\u4e0d\u663e\u5f0f\u5730\u5bf9\u95ee\u9898\u8fdb\u884c\u62c6\u89e3\uff0c\u800c\u662f\u5c06\u95ee\u9898\u770b\u4f5c\u4e00\u7cfb\u5217\u51b3\u7b56\u6b65\u9aa4\uff0c\u901a\u8fc7\u8bd5\u63a2\u548c\u526a\u679d\uff0c\u641c\u7d22\u6240\u6709\u53ef\u80fd\u7684\u89e3\u3002

    \u5bf9\u4e8e\u672c\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u5c1d\u8bd5\u5c06\u95ee\u9898\u62c6\u89e3\u4e3a\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\u3002\u8bbe\u722c\u5230\u7b2c \\(i\\) \u9636\u5171\u6709 \\(dp[i]\\) \u79cd\u65b9\u6848\uff0c\u90a3\u4e48 \\(dp[i]\\) \u5c31\u662f\u539f\u95ee\u9898\uff0c\u5176\u5b50\u95ee\u9898\u5305\u62ec:

    \\[ dp[i-1] , dp[i-2] , \\cdots , dp[2] , dp[1] \\]

    \u7531\u4e8e\u6bcf\u8f6e\u53ea\u80fd\u4e0a \\(1\\) \u9636\u6216 \\(2\\) \u9636\uff0c\u56e0\u6b64\u5f53\u6211\u4eec\u7ad9\u5728\u7b2c \\(i\\) \u9636\u697c\u68af\u4e0a\u65f6\uff0c\u4e0a\u4e00\u8f6e\u53ea\u53ef\u80fd\u7ad9\u5728\u7b2c \\(i - 1\\) \u9636\u6216\u7b2c \\(i - 2\\) \u9636\u4e0a\uff0c\u6362\u53e5\u8bdd\u8bf4\uff0c\u6211\u4eec\u53ea\u80fd\u4ece\u7b2c \\(i -1\\) \u9636\u6216\u7b2c \\(i - 2\\) \u9636\u524d\u5f80\u7b2c \\(i\\) \u9636\u3002\u56e0\u6b64\uff0c\u722c\u5230\u7b2c \\(i - 1\\) \u9636\u7684\u65b9\u6848\u6570\u52a0\u4e0a\u722c\u5230\u7b2c \\(i - 2\\) \u9636\u7684\u65b9\u6848\u6570\u5c31\u7b49\u4e8e\u722c\u5230\u7b2c \\(i\\) \u9636\u7684\u65b9\u6848\u6570\uff0c\u5373\uff1a

    \\[ dp[i] = dp[i-1] + dp[i-2] \\]

    Fig. \u65b9\u6848\u6570\u91cf\u9012\u63a8\u5173\u7cfb

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u5728\u722c\u697c\u68af\u95ee\u9898\u4e2d\uff0c\u5404\u4e2a\u5b50\u95ee\u9898\u4e4b\u95f4\u4e0d\u662f\u76f8\u4e92\u72ec\u7acb\u7684\uff0c\u539f\u95ee\u9898\u7684\u89e3\u53ef\u4ee5\u7531\u5b50\u95ee\u9898\u7684\u89e3\u6784\u6210\u3002

    \u6211\u4eec\u53ef\u4ee5\u57fa\u4e8e\u6b64\u9012\u63a8\u516c\u5f0f\u5199\u51fa\u66b4\u529b\u641c\u7d22\u4ee3\u7801\uff1a\u4ee5 \\(dp[n]\\) \u4e3a\u8d77\u59cb\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u5730\u5c06\u4e00\u4e2a\u8f83\u5927\u95ee\u9898\u62c6\u89e3\u4e3a\u4e24\u4e2a\u8f83\u5c0f\u95ee\u9898\u7684\u548c\uff0c\u76f4\u81f3\u5230\u8fbe\u6700\u5c0f\u5b50\u95ee\u9898 \\(dp[1]\\) \u548c \\(dp[2]\\) \u65f6\u8fd4\u56de\u3002\u5176\u4e2d\uff0c\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3 \\(dp[1] = 1\\) , \\(dp[2] = 2\\) \u662f\u5df2\u77e5\u7684\uff0c\u4ee3\u8868\u722c\u5230\u7b2c \\(1\\) , \\(2\\) \u9636\u5206\u522b\u6709 \\(1\\) , \\(2\\) \u79cd\u65b9\u6848\u3002

    \u89c2\u5bdf\u4ee5\u4e0b\u4ee3\u7801\uff0c\u5b83\u548c\u6807\u51c6\u56de\u6eaf\u4ee3\u7801\u90fd\u5c5e\u4e8e\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\uff0c\u4f46\u66f4\u52a0\u7b80\u6d01\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_dfs.java
    /* \u641c\u7d22 */\nint dfs(int i) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1) + dfs(i - 2);\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\nreturn dfs(n);\n}\n
    climbing_stairs_dfs.cpp
    /* \u641c\u7d22 */\nint dfs(int i) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1) + dfs(i - 2);\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\nreturn dfs(n);\n}\n
    climbing_stairs_dfs.py
    def dfs(i: int) -> int:\n\"\"\"\u641c\u7d22\"\"\"\n# \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif i == 1 or i == 2:\nreturn i\n# dp[i] = dp[i-1] + dp[i-2]\ncount = dfs(i - 1) + dfs(i - 2)\nreturn count\ndef climbing_stairs_dfs(n: int) -> int:\n\"\"\"\u722c\u697c\u68af\uff1a\u641c\u7d22\"\"\"\nreturn dfs(n)\n
    climbing_stairs_dfs.go
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.js
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.ts
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.c
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.cs
    /* \u641c\u7d22 */\nint dfs(int i) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1) + dfs(i - 2);\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\nreturn dfs(n);\n}\n
    climbing_stairs_dfs.swift
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.zig
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n
    climbing_stairs_dfs.dart
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFS}\n

    \u4e0b\u56fe\u5c55\u793a\u4e86\u66b4\u529b\u641c\u7d22\u5f62\u6210\u7684\u9012\u5f52\u6811\u3002\u5bf9\u4e8e\u95ee\u9898 \\(dp[n]\\) \uff0c\u5176\u9012\u5f52\u6811\u7684\u6df1\u5ea6\u4e3a \\(n\\) \uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \u3002\u6307\u6570\u9636\u7684\u8fd0\u884c\u65f6\u95f4\u589e\u957f\u5730\u975e\u5e38\u5feb\uff0c\u5982\u679c\u6211\u4eec\u8f93\u5165\u4e00\u4e2a\u6bd4\u8f83\u5927\u7684 \\(n\\) \uff0c\u5219\u4f1a\u9677\u5165\u6f2b\u957f\u7684\u7b49\u5f85\u4e4b\u4e2d\u3002

    Fig. \u722c\u697c\u68af\u5bf9\u5e94\u9012\u5f52\u6811

    \u5b9e\u9645\u4e0a\uff0c\u6307\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f\u7531\u4e8e\u300c\u91cd\u53e0\u5b50\u95ee\u9898\u300d\u5bfc\u81f4\u7684\u3002\u4f8b\u5982\uff0c\u95ee\u9898 \\(dp[9]\\) \u88ab\u5206\u89e3\u4e3a\u5b50\u95ee\u9898 \\(dp[8]\\) \u548c \\(dp[7]\\) \uff0c\u95ee\u9898 \\(dp[8]\\) \u88ab\u5206\u89e3\u4e3a\u5b50\u95ee\u9898 \\(dp[7]\\) \u548c \\(dp[6]\\) \uff0c\u4e24\u8005\u90fd\u5305\u542b\u5b50\u95ee\u9898 \\(dp[7]\\) \uff0c\u800c\u5b50\u95ee\u9898\u4e2d\u53c8\u5305\u542b\u66f4\u5c0f\u7684\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u5b50\u5b50\u5b59\u5b59\u65e0\u7a77\u5c3d\u4e5f\uff0c\u7edd\u5927\u90e8\u5206\u8ba1\u7b97\u8d44\u6e90\u90fd\u6d6a\u8d39\u5728\u8fd9\u4e9b\u91cd\u53e0\u7684\u95ee\u9898\u4e0a\u3002

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1312","title":"13.1.2. \u00a0 \u65b9\u6cd5\u4e8c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22","text":"

    \u4e3a\u4e86\u63d0\u5347\u7b97\u6cd5\u6548\u7387\uff0c\u6211\u4eec\u5e0c\u671b\u6240\u6709\u7684\u91cd\u53e0\u5b50\u95ee\u9898\u90fd\u53ea\u88ab\u8ba1\u7b97\u4e00\u6b21\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u8003\u8651\u501f\u52a9\u4e00\u4e2a\u6570\u7ec4 mem \u6765\u8bb0\u5f55\u6bcf\u4e2a\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u5e76\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u8fd9\u6837\u505a\uff1a

    • \u5f53\u9996\u6b21\u8ba1\u7b97 \\(dp[i]\\) \u65f6\uff0c\u6211\u4eec\u5c06\u5176\u8bb0\u5f55\u81f3 mem[i] \uff0c\u4ee5\u4fbf\u4e4b\u540e\u4f7f\u7528\uff1b
    • \u5f53\u518d\u6b21\u9700\u8981\u8ba1\u7b97 \\(dp[i]\\) \u65f6\uff0c\u6211\u4eec\u4fbf\u53ef\u76f4\u63a5\u4ece mem[i] \u4e2d\u83b7\u53d6\u7ed3\u679c\uff0c\u4ece\u800c\u5c06\u91cd\u53e0\u5b50\u95ee\u9898\u526a\u679d\uff1b
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_dfs_mem.java
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nint dfs(int i, int[] mem) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\nif (mem[i] != -1)\nreturn mem[i];\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1, mem) + dfs(i - 2, mem);\n// \u8bb0\u5f55 dp[i]\nmem[i] = count;\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint climbingStairsDFSMem(int n) {\n// mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\nint[] mem = new int[n + 1];\nArrays.fill(mem, -1);\nreturn dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.cpp
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nint dfs(int i, vector<int> &mem) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\nif (mem[i] != -1)\nreturn mem[i];\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1, mem) + dfs(i - 2, mem);\n// \u8bb0\u5f55 dp[i]\nmem[i] = count;\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint climbingStairsDFSMem(int n) {\n// mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\nvector<int> mem(n + 1, -1);\nreturn dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.py
    def dfs(i: int, mem: list[int]) -> int:\n\"\"\"\u8bb0\u5fc6\u5316\u641c\u7d22\"\"\"\n# \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif i == 1 or i == 2:\nreturn i\n# \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\nif mem[i] != -1:\nreturn mem[i]\n# dp[i] = dp[i-1] + dp[i-2]\ncount = dfs(i - 1, mem) + dfs(i - 2, mem)\n# \u8bb0\u5f55 dp[i]\nmem[i] = count\nreturn count\ndef climbing_stairs_dfs_mem(n: int) -> int:\n\"\"\"\u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\"\"\"\n# mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\nmem = [-1] * (n + 1)\nreturn dfs(n, mem)\n
    climbing_stairs_dfs_mem.go
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.js
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.ts
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.c
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.cs
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nint dfs(int i, int[] mem) {\n// \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\nif (i == 1 || i == 2)\nreturn i;\n// \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\nif (mem[i] != -1)\nreturn mem[i];\n// dp[i] = dp[i-1] + dp[i-2]\nint count = dfs(i - 1, mem) + dfs(i - 2, mem);\n// \u8bb0\u5f55 dp[i]\nmem[i] = count;\nreturn count;\n}\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint climbingStairsDFSMem(int n) {\n// mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\nint[] mem = new int[n + 1];\nArray.Fill(mem, -1);\nreturn dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.swift
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.zig
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n
    climbing_stairs_dfs_mem.dart
    [class]{}-[func]{dfs}\n[class]{}-[func]{climbingStairsDFSMem}\n

    \u89c2\u5bdf\u4e0b\u56fe\uff0c\u7ecf\u8fc7\u8bb0\u5fc6\u5316\u5904\u7406\u540e\uff0c\u6240\u6709\u91cd\u53e0\u5b50\u95ee\u9898\u90fd\u53ea\u9700\u88ab\u8ba1\u7b97\u4e00\u6b21\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u88ab\u4f18\u5316\u81f3 \\(O(n)\\) \uff0c\u8fd9\u662f\u4e00\u4e2a\u5de8\u5927\u7684\u98de\u8dc3\u3002\u5b9e\u9645\u4e0a\uff0c\u5982\u679c\u4e0d\u8003\u8651\u9012\u5f52\u5e26\u6765\u7684\u989d\u5916\u5f00\u9500\uff0c\u8bb0\u5fc6\u5316\u641c\u7d22\u89e3\u6cd5\u5df2\u7ecf\u51e0\u4e4e\u7b49\u540c\u4e8e\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\u7684\u65f6\u95f4\u6548\u7387\u3002

    Fig. \u8bb0\u5fc6\u5316\u641c\u7d22\u5bf9\u5e94\u9012\u5f52\u6811

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1313","title":"13.1.3. \u00a0 \u65b9\u6cd5\u4e09\uff1a\u52a8\u6001\u89c4\u5212","text":"

    \u8bb0\u5fc6\u5316\u641c\u7d22\u662f\u4e00\u79cd\u201c\u4ece\u9876\u81f3\u5e95\u201d\u7684\u65b9\u6cd5\uff1a\u6211\u4eec\u4ece\u539f\u95ee\u9898\uff08\u6839\u8282\u70b9\uff09\u5f00\u59cb\uff0c\u9012\u5f52\u5730\u5c06\u8f83\u5927\u5b50\u95ee\u9898\u5206\u89e3\u4e3a\u8f83\u5c0f\u5b50\u95ee\u9898\uff0c\u76f4\u81f3\u89e3\u5df2\u77e5\u7684\u6700\u5c0f\u5b50\u95ee\u9898\uff08\u53f6\u8282\u70b9\uff09\uff1b\u6700\u7ec8\u901a\u8fc7\u56de\u6eaf\u5c06\u5b50\u95ee\u9898\u7684\u89e3\u9010\u5c42\u6536\u96c6\uff0c\u5f97\u5230\u539f\u95ee\u9898\u7684\u89e3\u3002

    \u6211\u4eec\u4e5f\u53ef\u4ee5\u76f4\u63a5\u201c\u4ece\u5e95\u81f3\u9876\u201d\u8fdb\u884c\u6c42\u89e3\uff0c\u5f97\u5230\u6807\u51c6\u7684\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\uff1a\u4ece\u6700\u5c0f\u5b50\u95ee\u9898\u5f00\u59cb\uff0c\u8fed\u4ee3\u5730\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\uff0c\u76f4\u81f3\u5f97\u5230\u539f\u95ee\u9898\u7684\u89e3\u3002

    \u7531\u4e8e\u52a8\u6001\u89c4\u5212\u4e0d\u5305\u542b\u56de\u6eaf\u8fc7\u7a0b\uff0c\u56e0\u6b64\u65e0\u9700\u4f7f\u7528\u9012\u5f52\uff0c\u800c\u53ef\u4ee5\u76f4\u63a5\u57fa\u4e8e\u9012\u63a8\u5b9e\u73b0\u3002\u6211\u4eec\u521d\u59cb\u5316\u4e00\u4e2a\u6570\u7ec4 dp \u6765\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u4ece\u6700\u5c0f\u5b50\u95ee\u9898\u5f00\u59cb\uff0c\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\u3002\u5728\u4ee5\u4e0b\u4ee3\u7801\u4e2d\uff0c\u6570\u7ec4 dp \u8d77\u5230\u4e86\u8bb0\u5fc6\u5316\u641c\u7d22\u4e2d\u6570\u7ec4 mem \u76f8\u540c\u7684\u8bb0\u5f55\u4f5c\u7528\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_dp.java
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\nif (n == 1 || n == 2)\nreturn n;\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[] dp = new int[n + 1];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = 1;\ndp[2] = 2;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = dp[i - 1] + dp[i - 2];\n}\nreturn dp[n];\n}\n
    climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\nif (n == 1 || n == 2)\nreturn n;\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nvector<int> dp(n + 1);\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = 1;\ndp[2] = 2;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = dp[i - 1] + dp[i - 2];\n}\nreturn dp[n];\n}\n
    climbing_stairs_dp.py
    def climbing_stairs_dp(n: int) -> int:\n\"\"\"\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nif n == 1 or n == 2:\nreturn n\n# \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\ndp = [0] * (n + 1)\n# \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1], dp[2] = 1, 2\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor i in range(3, n + 1):\ndp[i] = dp[i - 1] + dp[i - 2]\nreturn dp[n]\n
    climbing_stairs_dp.go
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.js
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.ts
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.c
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\nif (n == 1 || n == 2)\nreturn n;\n// \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\nint[] dp = new int[n + 1];\n// \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\ndp[1] = 1;\ndp[2] = 2;\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\nfor (int i = 3; i <= n; i++) {\ndp[i] = dp[i - 1] + dp[i - 2];\n}\nreturn dp[n];\n}\n
    climbing_stairs_dp.swift
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.zig
    [class]{}-[func]{climbingStairsDP}\n
    climbing_stairs_dp.dart
    [class]{}-[func]{climbingStairsDP}\n

    \u4e0e\u56de\u6eaf\u7b97\u6cd5\u4e00\u6837\uff0c\u52a8\u6001\u89c4\u5212\u4e5f\u4f7f\u7528\u201c\u72b6\u6001\u201d\u6982\u5ff5\u6765\u8868\u793a\u95ee\u9898\u6c42\u89e3\u7684\u67d0\u4e2a\u7279\u5b9a\u9636\u6bb5\uff0c\u6bcf\u4e2a\u72b6\u6001\u90fd\u5bf9\u5e94\u4e00\u4e2a\u5b50\u95ee\u9898\u4ee5\u53ca\u76f8\u5e94\u7684\u5c40\u90e8\u6700\u4f18\u89e3\u3002\u4f8b\u5982\u5bf9\u4e8e\u722c\u697c\u68af\u95ee\u9898\uff0c\u72b6\u6001\u5b9a\u4e49\u4e3a\u5f53\u524d\u6240\u5728\u697c\u68af\u9636\u6570 \\(i\\) \u3002\u52a8\u6001\u89c4\u5212\u7684\u5e38\u7528\u672f\u8bed\u5305\u62ec\uff1a

    • \u5c06\u6570\u7ec4 dp \u79f0\u4e3a\u300c\\(dp\\) \u8868\u300d\uff0c\\(dp[i]\\) \u8868\u793a\u72b6\u6001 \\(i\\) \u5bf9\u5e94\u5b50\u95ee\u9898\u7684\u89e3\uff1b
    • \u5c06\u6700\u5c0f\u5b50\u95ee\u9898\u5bf9\u5e94\u7684\u72b6\u6001\uff08\u5373\u7b2c \\(1\\) , \\(2\\) \u9636\u697c\u68af\uff09\u79f0\u4e3a\u300c\u521d\u59cb\u72b6\u6001\u300d\uff1b
    • \u5c06\u9012\u63a8\u516c\u5f0f \\(dp[i] = dp[i-1] + dp[i-2]\\) \u79f0\u4e3a\u300c\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u300d\uff1b

    Fig. \u722c\u697c\u68af\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \u7ec6\u5fc3\u7684\u4f60\u53ef\u80fd\u53d1\u73b0\uff0c\u7531\u4e8e \\(dp[i]\\) \u53ea\u4e0e \\(dp[i-1]\\) \u548c \\(dp[i-2]\\) \u6709\u5173\uff0c\u56e0\u6b64\u6211\u4eec\u65e0\u9700\u4f7f\u7528\u4e00\u4e2a\u6570\u7ec4 dp \u6765\u5b58\u50a8\u6240\u6709\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u800c\u53ea\u9700\u4e24\u4e2a\u53d8\u91cf\u6eda\u52a8\u524d\u8fdb\u5373\u53ef\u3002\u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u7531\u4e8e\u7701\u53bb\u4e86\u6570\u7ec4 dp \u5360\u7528\u7684\u7a7a\u95f4\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n)\\) \u964d\u4f4e\u81f3 \\(O(1)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart climbing_stairs_dp.java
    /* \u722c\u697c\u68af\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\nif (n == 1 || n == 2)\nreturn n;\nint a = 1, b = 2;\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = a + b;\na = tmp;\n}\nreturn b;\n}\n
    climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\nif (n == 1 || n == 2)\nreturn n;\nint a = 1, b = 2;\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = a + b;\na = tmp;\n}\nreturn b;\n}\n
    climbing_stairs_dp.py
    def climbing_stairs_dp_comp(n: int) -> int:\n\"\"\"\u722c\u697c\u68af\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\nif n == 1 or n == 2:\nreturn n\na, b = 1, 2\nfor _ in range(3, n + 1):\na, b = b, a + b\nreturn b\n
    climbing_stairs_dp.go
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.js
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.ts
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.c
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\nif (n == 1 || n == 2)\nreturn n;\nint a = 1, b = 2;\nfor (int i = 3; i <= n; i++) {\nint tmp = b;\nb = a + b;\na = tmp;\n}\nreturn b;\n}\n
    climbing_stairs_dp.swift
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.zig
    [class]{}-[func]{climbingStairsDPComp}\n
    climbing_stairs_dp.dart
    [class]{}-[func]{climbingStairsDPComp}\n

    \u6211\u4eec\u5c06\u8fd9\u79cd\u7a7a\u95f4\u4f18\u5316\u6280\u5de7\u79f0\u4e3a\u300c\u72b6\u6001\u538b\u7f29\u300d\u3002\u5728\u8bb8\u591a\u52a8\u6001\u89c4\u5212\u95ee\u9898\u4e2d\uff0c\u5f53\u524d\u72b6\u6001\u4ec5\u4e0e\u524d\u9762\u6709\u9650\u4e2a\u72b6\u6001\u6709\u5173\uff0c\u4e0d\u5fc5\u4fdd\u5b58\u6240\u6709\u7684\u5386\u53f2\u72b6\u6001\uff0c\u8fd9\u65f6\u6211\u4eec\u53ef\u4ee5\u5e94\u7528\u72b6\u6001\u538b\u7f29\uff0c\u53ea\u4fdd\u7559\u5fc5\u8981\u7684\u72b6\u6001\uff0c\u901a\u8fc7\u201c\u964d\u7ef4\u201d\u6765\u8282\u7701\u5185\u5b58\u7a7a\u95f4\u3002

    \u603b\u7684\u770b\u6765\uff0c\u5b50\u95ee\u9898\u5206\u89e3\u662f\u4e00\u79cd\u901a\u7528\u7684\u7b97\u6cd5\u601d\u8def\uff0c\u5728\u5206\u6cbb\u7b97\u6cd5\u3001\u52a8\u6001\u89c4\u5212\u3001\u56de\u6eaf\u7b97\u6cd5\u4e2d\u5404\u6709\u7279\u70b9\uff1a

    • \u5206\u6cbb\u7b97\u6cd5\u5c06\u539f\u95ee\u9898\u5212\u5206\u4e3a\u51e0\u4e2a\u72ec\u7acb\u7684\u5b50\u95ee\u9898\uff0c\u7136\u540e\u9012\u5f52\u89e3\u51b3\u5b50\u95ee\u9898\uff0c\u6700\u540e\u5408\u5e76\u5b50\u95ee\u9898\u7684\u89e3\u5f97\u5230\u539f\u95ee\u9898\u7684\u89e3\u3002\u4f8b\u5982\uff0c\u5f52\u5e76\u6392\u5e8f\u5c06\u957f\u6570\u7ec4\u4e0d\u65ad\u5212\u5206\u4e3a\u4e24\u4e2a\u77ed\u5b50\u6570\u7ec4\uff0c\u518d\u5c06\u6392\u5e8f\u597d\u7684\u5b50\u6570\u7ec4\u5408\u5e76\u4e3a\u6392\u5e8f\u597d\u7684\u957f\u6570\u7ec4\u3002
    • \u52a8\u6001\u89c4\u5212\u4e5f\u662f\u5c06\u539f\u95ee\u9898\u5206\u89e3\u4e3a\u591a\u4e2a\u5b50\u95ee\u9898\uff0c\u4f46\u4e0e\u5206\u6cbb\u7b97\u6cd5\u7684\u4e3b\u8981\u533a\u522b\u662f\uff0c\u52a8\u6001\u89c4\u5212\u4e2d\u7684\u5b50\u95ee\u9898\u5f80\u5f80\u4e0d\u662f\u76f8\u4e92\u72ec\u7acb\u7684\uff0c\u539f\u95ee\u9898\u7684\u89e3\u4f9d\u8d56\u4e8e\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u800c\u5b50\u95ee\u9898\u7684\u89e3\u53c8\u4f9d\u8d56\u4e8e\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\u7684\u89e3\u3002\u56e0\u6b64\uff0c\u52a8\u6001\u89c4\u5212\u901a\u5e38\u4f1a\u5f15\u5165\u8bb0\u5fc6\u5316\uff0c\u4fdd\u5b58\u5df2\u7ecf\u89e3\u51b3\u7684\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u907f\u514d\u91cd\u590d\u8ba1\u7b97\u3002
    • \u56de\u6eaf\u7b97\u6cd5\u5728\u5c1d\u8bd5\u548c\u56de\u9000\u4e2d\u7a77\u4e3e\u6240\u6709\u53ef\u80fd\u7684\u89e3\uff0c\u5e76\u901a\u8fc7\u526a\u679d\u907f\u514d\u4e0d\u5fc5\u8981\u7684\u641c\u7d22\u5206\u652f\u3002\u539f\u95ee\u9898\u7684\u89e3\u7531\u4e00\u7cfb\u5217\u51b3\u7b56\u6b65\u9aa4\u6784\u6210\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6bcf\u4e2a\u51b3\u7b56\u6b65\u9aa4\u4e4b\u540e\u7684\u5269\u4f59\u95ee\u9898\u770b\u4f5c\u4e3a\u4e00\u4e2a\u5b50\u95ee\u9898\u3002
    "},{"location":"chapter_dynamic_programming/knapsack_problem/","title":"13.4. \u00a0 0-1 \u80cc\u5305\u95ee\u9898","text":"

    \u80cc\u5305\u95ee\u9898\u662f\u4e00\u4e2a\u975e\u5e38\u597d\u7684\u52a8\u6001\u89c4\u5212\u5165\u95e8\u9898\u76ee\uff0c\u662f\u52a8\u6001\u89c4\u5212\u4e2d\u6700\u5e38\u89c1\u7684\u95ee\u9898\u5f62\u5f0f\u3002\u5176\u5177\u6709\u5f88\u591a\u53d8\u79cd\uff0c\u4f8b\u5982 0-1 \u80cc\u5305\u95ee\u9898\u3001\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u3001\u591a\u91cd\u80cc\u5305\u95ee\u9898\u7b49\u3002

    \u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u5148\u6765\u5b66\u4e60\u57fa\u7840\u7684\u7684 0-1 \u80cc\u5305\u95ee\u9898\u3002

    Question

    \u7ed9\u5b9a \\(n\\) \u4e2a\u7269\u54c1\uff0c\u7b2c \\(i\\) \u4e2a\u7269\u54c1\u7684\u91cd\u91cf\u4e3a \\(wgt[i-1]\\) \u3001\u4ef7\u503c\u4e3a \\(val[i-1]\\) \uff0c\u73b0\u5728\u6709\u4e2a\u5bb9\u91cf\u4e3a \\(cap\\) \u7684\u80cc\u5305\uff0c\u6bcf\u4e2a\u7269\u54c1\u53ea\u80fd\u9009\u62e9\u4e00\u6b21\uff0c\u95ee\u5728\u4e0d\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\u4e0b\u80cc\u5305\u4e2d\u7269\u54c1\u7684\u6700\u5927\u4ef7\u503c\u3002

    \u8bf7\u6ce8\u610f\uff0c\u7269\u54c1\u7f16\u53f7 \\(i\\) \u4ece \\(1\\) \u5f00\u59cb\u8ba1\u6570\uff0c\u6570\u7ec4\u7d22\u5f15\u4ece \\(0\\) \u5f00\u59cb\u8ba1\u6570\uff0c\u56e0\u6b64\u7269\u54c1 \\(i\\) \u5bf9\u5e94\u91cd\u91cf \\(wgt[i-1]\\) \u548c\u4ef7\u503c \\(val[i-1]\\) \u3002

    \u4e0b\u56fe\u7ed9\u51fa\u4e86\u4e00\u4e2a 0-1 \u80cc\u5305\u7684\u793a\u4f8b\u6570\u636e\uff0c\u80cc\u5305\u5185\u7684\u6700\u5927\u4ef7\u503c\u4e3a \\(220\\) \u3002

    Fig. 0-1 \u80cc\u5305\u7684\u793a\u4f8b\u6570\u636e

    \u6211\u4eec\u53ef\u4ee5\u5c06 0-1 \u80cc\u5305\u95ee\u9898\u770b\u4f5c\u662f\u4e00\u4e2a\u7531 \\(n\\) \u8f6e\u51b3\u7b56\u7ec4\u6210\u7684\u8fc7\u7a0b\uff0c\u6bcf\u4e2a\u7269\u4f53\u90fd\u6709\u4e0d\u653e\u5165\u548c\u653e\u5165\u4e24\u79cd\u51b3\u7b56\uff0c\u56e0\u6b64\u8be5\u95ee\u9898\u662f\u6ee1\u8db3\u51b3\u7b56\u6811\u6a21\u578b\u7684\u3002\u6b64\u5916\uff0c\u8be5\u95ee\u9898\u7684\u76ee\u6807\u662f\u6c42\u89e3\u201c\u5728\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u7684\u6700\u5927\u4ef7\u503c\u201d\uff0c\u56e0\u6b64\u8f83\u5927\u6982\u7387\u662f\u4e2a\u52a8\u6001\u89c4\u5212\u95ee\u9898\u3002\u6211\u4eec\u63a5\u4e0b\u6765\u5c1d\u8bd5\u6c42\u89e3\u5b83\u3002

    \u7b2c\u4e00\u6b65\uff1a\u601d\u8003\u6bcf\u8f6e\u7684\u51b3\u7b56\uff0c\u5b9a\u4e49\u72b6\u6001\uff0c\u4ece\u800c\u5f97\u5230 \\(dp\\) \u8868

    \u5728 0-1 \u80cc\u5305\u95ee\u9898\u4e2d\uff0c\u4e0d\u653e\u5165\u80cc\u5305\uff0c\u80cc\u5305\u5bb9\u91cf\u4e0d\u53d8\uff1b\u653e\u5165\u80cc\u5305\uff0c\u80cc\u5305\u5bb9\u91cf\u51cf\u5c0f\u3002\u7531\u6b64\u53ef\u5f97\u72b6\u6001\u5b9a\u4e49\uff1a\u5f53\u524d\u7269\u54c1\u7f16\u53f7 \\(i\\) \u548c\u5269\u4f59\u80cc\u5305\u5bb9\u91cf \\(c\\) \uff0c\u8bb0\u4e3a \\([i, c]\\) \u3002

    \u72b6\u6001 \\([i, c]\\) \u5bf9\u5e94\u7684\u5b50\u95ee\u9898\u4e3a\uff1a\u524d \\(i\\) \u4e2a\u7269\u54c1\u5728\u5269\u4f59\u5bb9\u91cf\u4e3a \\(c\\) \u7684\u80cc\u5305\u4e2d\u7684\u6700\u5927\u4ef7\u503c\uff0c\u8bb0\u4e3a \\(dp[i, c]\\) \u3002

    \u9700\u8981\u6c42\u89e3\u7684\u662f \\(dp[n, cap]\\) \uff0c\u56e0\u6b64\u9700\u8981\u4e00\u4e2a\u5c3a\u5bf8\u4e3a \\((n+1) \\times (cap+1)\\) \u7684\u4e8c\u7ef4 \\(dp\\) \u8868\u3002

    \u7b2c\u4e8c\u6b65\uff1a\u627e\u51fa\u6700\u4f18\u5b50\u7ed3\u6784\uff0c\u8fdb\u800c\u63a8\u5bfc\u51fa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b

    \u5f53\u6211\u4eec\u505a\u51fa\u7269\u54c1 \\(i\\) \u7684\u51b3\u7b56\u540e\uff0c\u5269\u4f59\u7684\u662f\u524d \\(i-1\\) \u4e2a\u7269\u54c1\u7684\u51b3\u7b56\u3002\u56e0\u6b64\uff0c\u72b6\u6001\u8f6c\u79fb\u5206\u4e3a\u4e24\u79cd\u60c5\u51b5\uff1a

    • \u4e0d\u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u80cc\u5305\u5bb9\u91cf\u4e0d\u53d8\uff0c\u72b6\u6001\u8f6c\u79fb\u81f3 \\([i-1, c]\\) \uff1b
    • \u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u80cc\u5305\u5bb9\u91cf\u51cf\u5c0f \\(wgt[i-1]\\) \uff0c\u4ef7\u503c\u589e\u52a0 \\(val[i-1]\\) \uff0c\u72b6\u6001\u8f6c\u79fb\u81f3 \\([i-1, c-wgt[i-1]]\\) \uff1b

    \u4e0a\u8ff0\u7684\u72b6\u6001\u8f6c\u79fb\u5411\u6211\u4eec\u63ed\u793a\u4e86\u672c\u9898\u7684\u6700\u4f18\u5b50\u7ed3\u6784\uff1a\u6700\u5927\u4ef7\u503c \\(dp[i, c]\\) \u7b49\u4e8e\u4e0d\u653e\u5165\u7269\u54c1 \\(i\\) \u548c\u653e\u5165\u7269\u54c1 \\(i\\) \u4e24\u79cd\u65b9\u6848\u4e2d\u7684\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\u3002\u7531\u6b64\u53ef\u63a8\u51fa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff1a

    \\[ dp[i, c] = \\max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) \\]

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u82e5\u5f53\u524d\u7269\u54c1\u91cd\u91cf \\(wgt[i - 1]\\) \u8d85\u51fa\u5269\u4f59\u80cc\u5305\u5bb9\u91cf \\(c\\) \uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\u3002

    \u7b2c\u4e09\u6b65\uff1a\u786e\u5b9a\u8fb9\u754c\u6761\u4ef6\u548c\u72b6\u6001\u8f6c\u79fb\u987a\u5e8f

    \u5f53\u65e0\u7269\u54c1\u6216\u65e0\u5269\u4f59\u80cc\u5305\u5bb9\u91cf\u65f6\u6700\u5927\u4ef7\u503c\u4e3a \\(0\\) \uff0c\u5373\u6240\u6709 \\(dp[i, 0]\\) \u548c \\(dp[0, c]\\) \u90fd\u7b49\u4e8e \\(0\\) \u3002

    \u5f53\u524d\u72b6\u6001 \\([i, c]\\) \u4ece\u4e0a\u65b9\u7684\u72b6\u6001 \\([i-1, c]\\) \u548c\u5de6\u4e0a\u65b9\u7684\u72b6\u6001 \\([i-1, c-wgt[i-1]]\\) \u8f6c\u79fb\u800c\u6765\uff0c\u56e0\u6b64\u901a\u8fc7\u4e24\u5c42\u5faa\u73af\u6b63\u5e8f\u904d\u5386\u6574\u4e2a \\(dp\\) \u8868\u5373\u53ef\u3002

    Tip

    \u5b8c\u6210\u4ee5\u4e0a\u4e09\u6b65\u540e\uff0c\u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u5b9e\u73b0\u4ece\u5e95\u81f3\u9876\u7684\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\u3002\u800c\u4e3a\u4e86\u5c55\u793a\u672c\u9898\u5305\u542b\u7684\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u672c\u6587\u4e5f\u540c\u65f6\u7ed9\u51fa\u4ece\u9876\u81f3\u5e95\u7684\u66b4\u529b\u641c\u7d22\u548c\u8bb0\u5fc6\u5316\u641c\u7d22\u89e3\u6cd5\u3002

    "},{"location":"chapter_dynamic_programming/knapsack_problem/#1341","title":"13.4.1. \u00a0 \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u641c\u7d22","text":"

    \u641c\u7d22\u4ee3\u7801\u5305\u542b\u4ee5\u4e0b\u8981\u7d20\uff1a

    • \u9012\u5f52\u53c2\u6570\uff1a\u72b6\u6001 \\([i, c]\\) \uff1b\u8fd4\u56de\u503c\uff1a\u5b50\u95ee\u9898\u7684\u89e3 \\(dp[i, c]\\) \u3002
    • \u7ec8\u6b62\u6761\u4ef6\uff1a\u5f53\u7269\u54c1\u7f16\u53f7\u8d8a\u754c \\(i = 0\\) \u6216\u80cc\u5305\u5269\u4f59\u5bb9\u91cf\u4e3a \\(0\\) \u65f6\uff0c\u7ec8\u6b62\u9012\u5f52\u5e76\u8fd4\u56de\u4ef7\u503c \\(0\\) \u3002
    • \u526a\u679d\uff1a\u82e5\u5f53\u524d\u7269\u54c1\u91cd\u91cf\u8d85\u51fa\u80cc\u5305\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nint knapsackDFS(int[] wgt, int[] val, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (wgt[i - 1] > c) {\nreturn knapsackDFS(wgt, val, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFS(wgt, val, i - 1, c);\nint yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n// \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nreturn Math.max(no, yes);\n}\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nint knapsackDFS(vector<int> &wgt, vector<int> &val, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (wgt[i - 1] > c) {\nreturn knapsackDFS(wgt, val, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFS(wgt, val, i - 1, c);\nint yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];\n// \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nreturn max(no, yes);\n}\n
    knapsack.py
    def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -> int:\n\"\"\"0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22\"\"\"\n# \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif i == 0 or c == 0:\nreturn 0\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif wgt[i - 1] > c:\nreturn knapsack_dfs(wgt, val, i - 1, c)\n# \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nno = knapsack_dfs(wgt, val, i - 1, c)\nyes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]\n# \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nreturn max(no, yes)\n
    knapsack.go
    [class]{}-[func]{knapsackDFS}\n
    knapsack.js
    [class]{}-[func]{knapsackDFS}\n
    knapsack.ts
    [class]{}-[func]{knapsackDFS}\n
    knapsack.c
    [class]{}-[func]{knapsackDFS}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nint knapsackDFS(int[] weight, int[] val, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (weight[i - 1] > c) {\nreturn knapsackDFS(weight, val, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFS(weight, val, i - 1, c);\nint yes = knapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];\n// \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nreturn Math.Max(no, yes);\n}\n
    knapsack.swift
    [class]{}-[func]{knapsackDFS}\n
    knapsack.zig
    [class]{}-[func]{knapsackDFS}\n
    knapsack.dart
    [class]{}-[func]{knapsackDFS}\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u7531\u4e8e\u6bcf\u4e2a\u7269\u54c1\u90fd\u4f1a\u4ea7\u751f\u4e0d\u9009\u548c\u9009\u4e24\u6761\u641c\u7d22\u5206\u652f\uff0c\u56e0\u6b64\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \u3002

    \u89c2\u5bdf\u9012\u5f52\u6811\uff0c\u5bb9\u6613\u53d1\u73b0\u5176\u4e2d\u5b58\u5728\u4e00\u4e9b\u300c\u91cd\u53e0\u5b50\u95ee\u9898\u300d\uff0c\u4f8b\u5982 \\(dp[1, 10]\\) \u7b49\u3002\u800c\u5f53\u7269\u54c1\u8f83\u591a\u3001\u80cc\u5305\u5bb9\u91cf\u8f83\u5927\uff0c\u5c24\u5176\u662f\u5f53\u76f8\u540c\u91cd\u91cf\u7684\u7269\u54c1\u8f83\u591a\u65f6\uff0c\u91cd\u53e0\u5b50\u95ee\u9898\u7684\u6570\u91cf\u5c06\u4f1a\u5927\u5e45\u589e\u591a\u3002

    Fig. 0-1 \u80cc\u5305\u7684\u66b4\u529b\u641c\u7d22\u9012\u5f52\u6811

    "},{"location":"chapter_dynamic_programming/knapsack_problem/#1342","title":"13.4.2. \u00a0 \u65b9\u6cd5\u4e8c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22","text":"

    \u4e3a\u4e86\u9632\u6b62\u91cd\u590d\u6c42\u89e3\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u6211\u4eec\u501f\u52a9\u4e00\u4e2a\u8bb0\u5fc6\u5217\u8868 mem \u6765\u8bb0\u5f55\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u5176\u4e2d mem[i][c] \u5bf9\u5e94\u89e3 \\(dp[i, c]\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][c] != -1) {\nreturn mem[i][c];\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (wgt[i - 1] > c) {\nreturn knapsackDFSMem(wgt, val, mem, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFSMem(wgt, val, mem, i - 1, c);\nint yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nmem[i][c] = Math.max(no, yes);\nreturn mem[i][c];\n}\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint knapsackDFSMem(vector<int> &wgt, vector<int> &val, vector<vector<int>> &mem, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][c] != -1) {\nreturn mem[i][c];\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (wgt[i - 1] > c) {\nreturn knapsackDFSMem(wgt, val, mem, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFSMem(wgt, val, mem, i - 1, c);\nint yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nmem[i][c] = max(no, yes);\nreturn mem[i][c];\n}\n
    knapsack.py
    def knapsack_dfs_mem(\nwgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int\n) -> int:\n\"\"\"0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\"\"\"\n# \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif i == 0 or c == 0:\nreturn 0\n# \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif mem[i][c] != -1:\nreturn mem[i][c]\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif wgt[i - 1] > c:\nreturn knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n# \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nno = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\nyes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]\n# \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nmem[i][c] = max(no, yes)\nreturn mem[i][c]\n
    knapsack.go
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.js
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.ts
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.c
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint knapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {\n// \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\nif (i == 0 || c == 0) {\nreturn 0;\n}\n// \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (mem[i][c] != -1) {\nreturn mem[i][c];\n}\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u4e0d\u653e\u5165\u80cc\u5305\nif (weight[i - 1] > c) {\nreturn knapsackDFSMem(weight, val, mem, i - 1, c);\n}\n// \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\nint no = knapsackDFSMem(weight, val, mem, i - 1, c);\nint yes = knapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];\n// \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\nmem[i][c] = Math.Max(no, yes);\nreturn mem[i][c];\n}\n
    knapsack.swift
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.zig
    [class]{}-[func]{knapsackDFSMem}\n
    knapsack.dart
    [class]{}-[func]{knapsackDFSMem}\n

    \u5f15\u5165\u8bb0\u5fc6\u5316\u4e4b\u540e\uff0c\u6240\u6709\u5b50\u95ee\u9898\u90fd\u53ea\u88ab\u8ba1\u7b97\u4e00\u6b21\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u5b50\u95ee\u9898\u6570\u91cf\uff0c\u4e5f\u5c31\u662f \\(O(n \\times cap)\\) \u3002

    Fig. 0-1 \u80cc\u5305\u7684\u8bb0\u5fc6\u5316\u641c\u7d22\u9012\u5f52\u6811

    "},{"location":"chapter_dynamic_programming/knapsack_problem/#1343","title":"13.4.3. \u00a0 \u65b9\u6cd5\u4e09\uff1a\u52a8\u6001\u89c4\u5212","text":"

    \u52a8\u6001\u89c4\u5212\u89e3\u6cd5\u672c\u8d28\u4e0a\u5c31\u662f\u5728\u72b6\u6001\u8f6c\u79fb\u4e2d\u586b\u5145 \\(dp\\) \u8868\u7684\u8fc7\u7a0b\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(int[] wgt, int[] val, int cap) {\nint n = wgt.length;\n// \u521d\u59cb\u5316 dp \u8868\nint[][] dp = new int[n + 1][cap + 1];\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int c = 1; c <= cap; c++) {\nif (wgt[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[i][c] = dp[i - 1][c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[n][cap];\n}\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(vector<int> &wgt, vector<int> &val, int cap) {\nint n = wgt.size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int c = 1; c <= cap; c++) {\nif (wgt[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[i][c] = dp[i - 1][c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[n][cap];\n}\n
    knapsack.py
    def knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:\n\"\"\"0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(wgt)\n# \u521d\u59cb\u5316 dp \u8868\ndp = [[0] * (cap + 1) for _ in range(n + 1)]\n# \u72b6\u6001\u8f6c\u79fb\nfor i in range(1, n + 1):\nfor c in range(1, cap + 1):\nif wgt[i - 1] > c:\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[i][c] = dp[i - 1][c]\nelse:\n# \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\nreturn dp[n][cap]\n
    knapsack.go
    [class]{}-[func]{knapsackDP}\n
    knapsack.js
    [class]{}-[func]{knapsackDP}\n
    knapsack.ts
    [class]{}-[func]{knapsackDP}\n
    knapsack.c
    [class]{}-[func]{knapsackDP}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(int[] weight, int[] val, int cap) {\nint n = weight.Length;\n// \u521d\u59cb\u5316 dp \u8868\nint[,] dp = new int[n + 1, cap + 1];\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int c = 1; c <= cap; c++) {\nif (weight[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[i, c] = dp[i - 1, c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n}\n}\n}\nreturn dp[n, cap];\n}\n
    knapsack.swift
    [class]{}-[func]{knapsackDP}\n
    knapsack.zig
    [class]{}-[func]{knapsackDP}\n
    knapsack.dart
    [class]{}-[func]{knapsackDP}\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u7531\u6570\u7ec4 dp \u5927\u5c0f\u51b3\u5b9a\uff0c\u4e3a \\(O(n \\times cap)\\) \u3002

    <1><2><3><4><5><6><7><8><9><10><11><12><13><14>

    \u6700\u540e\u8003\u8651\u72b6\u6001\u538b\u7f29\u3002\u4ee5\u4e0a\u4ee3\u7801\u4e2d\u7684\u6570\u7ec4 dp \u5360\u7528 \\(O(n \\times cap)\\) \u7a7a\u95f4\u3002\u7531\u4e8e\u6bcf\u4e2a\u72b6\u6001\u90fd\u53ea\u4e0e\u5176\u4e0a\u4e00\u884c\u7684\u72b6\u6001\u6709\u5173\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4e24\u4e2a\u6570\u7ec4\u6eda\u52a8\u524d\u8fdb\uff0c\u5c06\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n^2)\\) \u5c06\u4f4e\u81f3 \\(O(n)\\) \u3002\u4ee3\u7801\u7701\u7565\uff0c\u6709\u5174\u8da3\u7684\u540c\u5b66\u53ef\u4ee5\u81ea\u884c\u5b9e\u73b0\u3002

    \u90a3\u4e48\uff0c\u6211\u4eec\u662f\u5426\u53ef\u4ee5\u4ec5\u7528\u4e00\u4e2a\u6570\u7ec4\u5b9e\u73b0\u72b6\u6001\u538b\u7f29\u5462\uff1f\u89c2\u5bdf\u53ef\u77e5\uff0c\u6bcf\u4e2a\u72b6\u6001\u90fd\u662f\u7531\u5de6\u4e0a\u65b9\u6216\u6b63\u4e0a\u65b9\u7684\u683c\u5b50\u8f6c\u79fb\u8fc7\u6765\u7684\u3002\u5047\u8bbe\u53ea\u6709\u4e00\u4e2a\u6570\u7ec4\uff0c\u5f53\u904d\u5386\u5230\u7b2c \\(i\\) \u884c\u65f6\uff0c\u8be5\u6570\u7ec4\u5b58\u50a8\u7684\u4ecd\u7136\u662f\u7b2c \\(i-1\\) \u884c\u7684\u72b6\u6001\uff0c\u4e3a\u4e86\u907f\u514d\u5de6\u65b9\u533a\u57df\u7684\u683c\u5b50\u5728\u72b6\u6001\u8f6c\u79fb\u4e2d\u88ab\u8986\u76d6\uff0c\u5e94\u8be5\u91c7\u53d6\u5012\u5e8f\u904d\u5386\u3002

    \u4ee5\u4e0b\u52a8\u753b\u5c55\u793a\u4e86\u5728\u5355\u4e2a\u6570\u7ec4\u4e0b\u4ece\u7b2c \\(i=1\\) \u884c\u8f6c\u6362\u81f3\u7b2c \\(i=2\\) \u884c\u7684\u8fc7\u7a0b\u3002\u5efa\u8bae\u4f60\u601d\u8003\u4e00\u4e0b\u6b63\u5e8f\u904d\u5386\u548c\u5012\u5e8f\u904d\u5386\u7684\u533a\u522b\u3002

    <1><2><3><4><5><6>

    \u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u6211\u4eec\u4ec5\u9700\u5c06\u6570\u7ec4 dp \u7684\u7b2c\u4e00\u7ef4 \\(i\\) \u76f4\u63a5\u5220\u9664\uff0c\u5e76\u4e14\u5c06\u5185\u5faa\u73af\u4fee\u6539\u4e3a\u5012\u5e8f\u904d\u5386\u5373\u53ef\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\nint n = wgt.length;\n// \u521d\u59cb\u5316 dp \u8868\nint[] dp = new int[cap + 1];\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\n// \u5012\u5e8f\u904d\u5386\nfor (int c = cap; c >= 1; c--) {\nif (wgt[i - 1] <= c) {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[cap];\n}\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {\nint n = wgt.size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<int> dp(cap + 1, 0);\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\n// \u5012\u5e8f\u904d\u5386\nfor (int c = cap; c >= 1; c--) {\nif (wgt[i - 1] <= c) {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[cap];\n}\n
    knapsack.py
    def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:\n\"\"\"0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(wgt)\n# \u521d\u59cb\u5316 dp \u8868\ndp = [0] * (cap + 1)\n# \u72b6\u6001\u8f6c\u79fb\nfor i in range(1, n + 1):\n# \u5012\u5e8f\u904d\u5386\nfor c in range(cap, 0, -1):\nif wgt[i - 1] > c:\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[c] = dp[c]\nelse:\n# \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\nreturn dp[cap]\n
    knapsack.go
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.js
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.ts
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.c
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(int[] weight, int[] val, int cap) {\nint n = weight.Length;\n// \u521d\u59cb\u5316 dp \u8868\nint[] dp = new int[cap + 1];\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\n// \u5012\u5e8f\u904d\u5386\nfor (int c = cap; c > 0; c--) {\nif (weight[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[c] = dp[c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[cap];\n}\n
    knapsack.swift
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.zig
    [class]{}-[func]{knapsackDPComp}\n
    knapsack.dart
    [class]{}-[func]{knapsackDPComp}\n
    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/","title":"13.5. \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898","text":"

    \u5728\u672c\u8282\uff0c\u6211\u4eec\u5148\u6c42\u89e3 0-1 \u80cc\u5305\u7684\u4e00\u4e2a\u53d8\u79cd\u95ee\u9898\uff1a\u5b8c\u5168\u80cc\u5305\u95ee\u9898\uff1b\u518d\u4e86\u89e3\u5b8c\u5168\u80cc\u5305\u7684\u4e00\u79cd\u7279\u4f8b\u95ee\u9898\uff1a\u96f6\u94b1\u5151\u6362\u3002

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1351","title":"13.5.1. \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898","text":"

    Question

    \u7ed9\u5b9a \\(n\\) \u79cd\u7269\u54c1\uff0c\u7b2c \\(i\\) \u4e2a\u7269\u54c1\u7684\u91cd\u91cf\u4e3a \\(wgt[i-1]\\) \u3001\u4ef7\u503c\u4e3a \\(val[i-1]\\) \uff0c\u73b0\u5728\u6709\u4e2a\u5bb9\u91cf\u4e3a \\(cap\\) \u7684\u80cc\u5305\uff0c\u6bcf\u79cd\u7269\u54c1\u53ef\u4ee5\u91cd\u590d\u9009\u53d6\uff0c\u95ee\u5728\u4e0d\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\u4e0b\u80cc\u5305\u4e2d\u7269\u54c1\u7684\u6700\u5927\u4ef7\u503c\u3002

    Fig. \u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u793a\u4f8b\u6570\u636e

    \u5b8c\u5168\u80cc\u5305\u548c 0-1 \u80cc\u5305\u95ee\u9898\u975e\u5e38\u76f8\u4f3c\uff0c\u533a\u522b\u4ec5\u5728\u4e8e\u4e0d\u9650\u5236\u7269\u54c1\u7684\u9009\u62e9\u6b21\u6570\u3002

    • \u5728 0-1 \u80cc\u5305\u4e2d\uff0c\u6bcf\u4e2a\u7269\u54c1\u53ea\u6709\u4e00\u4e2a\uff0c\u56e0\u6b64\u5c06\u7269\u54c1 \\(i\\) \u653e\u5165\u80cc\u5305\u540e\uff0c\u53ea\u80fd\u4ece\u524d \\(i-1\\) \u4e2a\u7269\u54c1\u4e2d\u9009\u62e9\uff1b
    • \u5728\u5b8c\u5168\u80cc\u5305\u4e2d\uff0c\u6bcf\u4e2a\u7269\u54c1\u6709\u65e0\u6570\u4e2a\uff0c\u56e0\u6b64\u5c06\u7269\u54c1 \\(i\\) \u653e\u5165\u80cc\u5305\u540e\uff0c\u4ecd\u53ef\u4ee5\u4ece\u524d \\(i\\) \u4e2a\u7269\u54c1\u4e2d\u9009\u62e9\uff1b

    \u8fd9\u5c31\u5bfc\u81f4\u4e86\u72b6\u6001\u8f6c\u79fb\u7684\u53d8\u5316\uff0c\u5bf9\u4e8e\u72b6\u6001 \\([i, c]\\) \u6709\uff1a

    • \u4e0d\u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u4e0e 0-1 \u80cc\u5305\u76f8\u540c\uff0c\u8f6c\u79fb\u81f3 \\([i-1, c]\\) \uff1b
    • \u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u72b6\u6001\u8f6c\u79fb\u81f3 \\([i, c-wgt[i-1]]\\) \u800c\u975e 0-1 \u80cc\u5305\u7684 \\([i-1, c-wgt[i-1]]\\) \uff1b

    \u56e0\u6b64\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u53d8\u4e3a\uff1a

    \\[ dp[i, c] = \\max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) \\]

    \u5bf9\u6bd4\u4e24\u9053\u9898\u76ee\u7684\u52a8\u6001\u89c4\u5212\u4ee3\u7801\uff0c\u72b6\u6001\u8f6c\u79fb\u4e2d\u6709\u4e00\u5904\u4ece \\(i-1\\) \u53d8\u4e3a \\(i\\) \uff0c\u5176\u4f59\u5b8c\u5168\u4e00\u81f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart unbounded_knapsack.java
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDP(int[] wgt, int[] val, int cap) {\nint n = wgt.length;\n// \u521d\u59cb\u5316 dp \u8868\nint[][] dp = new int[n + 1][cap + 1];\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int c = 1; c <= cap; c++) {\nif (wgt[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[i][c] = dp[i - 1][c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[n][cap];\n}\n
    unbounded_knapsack.cpp
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDP(vector<int> &wgt, vector<int> &val, int cap) {\nint n = wgt.size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int c = 1; c <= cap; c++) {\nif (wgt[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[i][c] = dp[i - 1][c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[n][cap];\n}\n
    unbounded_knapsack.py
    def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:\n\"\"\"\u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(wgt)\n# \u521d\u59cb\u5316 dp \u8868\ndp = [[0] * (cap + 1) for _ in range(n + 1)]\n# \u72b6\u6001\u8f6c\u79fb\nfor i in range(1, n + 1):\nfor c in range(1, cap + 1):\nif wgt[i - 1] > c:\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[i][c] = dp[i - 1][c]\nelse:\n# \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\nreturn dp[n][cap]\n
    unbounded_knapsack.go
    [class]{}-[func]{unboundedKnapsackDP}\n
    unbounded_knapsack.js
    [class]{}-[func]{unboundedKnapsackDP}\n
    unbounded_knapsack.ts
    [class]{}-[func]{unboundedKnapsackDP}\n
    unbounded_knapsack.c
    [class]{}-[func]{unboundedKnapsackDP}\n
    unbounded_knapsack.cs
    [class]{unbounded_knapsack}-[func]{unboundedKnapsackDP}\n
    unbounded_knapsack.swift
    [class]{}-[func]{unboundedKnapsackDP}\n
    unbounded_knapsack.zig
    [class]{}-[func]{unboundedKnapsackDP}\n
    unbounded_knapsack.dart
    [class]{}-[func]{unboundedKnapsackDP}\n

    \u7531\u4e8e\u5f53\u524d\u72b6\u6001\u662f\u4ece\u5de6\u8fb9\u548c\u4e0a\u8fb9\u7684\u72b6\u6001\u8f6c\u79fb\u800c\u6765\uff0c\u56e0\u6b64\u72b6\u6001\u538b\u7f29\u540e\u5e94\u8be5\u5bf9 \\(dp\\) \u8868\u4e2d\u7684\u6bcf\u4e00\u884c\u91c7\u53d6\u6b63\u5e8f\u904d\u5386\uff0c\u8fd9\u4e2a\u904d\u5386\u987a\u5e8f\u4e0e 0-1 \u80cc\u5305\u6b63\u597d\u76f8\u53cd\u3002\u8bf7\u901a\u8fc7\u4ee5\u4e0b\u52a8\u753b\u6765\u7406\u89e3\u4e3a\u4ec0\u4e48\u8981\u6539\u4e3a\u6b63\u5e8f\u904d\u5386\u3002

    <1><2><3><4><5><6>

    \u4ee3\u7801\u5b9e\u73b0\u6bd4\u8f83\u7b80\u5355\uff0c\u4ec5\u9700\u5c06\u6570\u7ec4 dp \u7684\u7b2c\u4e00\u7ef4\u5220\u9664\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart unbounded_knapsack.java
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\nint n = wgt.length;\n// \u521d\u59cb\u5316 dp \u8868\nint[] dp = new int[cap + 1];\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int c = 1; c <= cap; c++) {\nif (wgt[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[c] = dp[c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[cap];\n}\n
    unbounded_knapsack.cpp
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {\nint n = wgt.size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<int> dp(cap + 1, 0);\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int c = 1; c <= cap; c++) {\nif (wgt[i - 1] > c) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[c] = dp[c];\n} else {\n// \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n}\n}\n}\nreturn dp[cap];\n}\n
    unbounded_knapsack.py
    def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:\n\"\"\"\u5b8c\u5168\u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(wgt)\n# \u521d\u59cb\u5316 dp \u8868\ndp = [0] * (cap + 1)\n# \u72b6\u6001\u8f6c\u79fb\nfor i in range(1, n + 1):\n# \u6b63\u5e8f\u904d\u5386\nfor c in range(1, cap + 1):\nif wgt[i - 1] > c:\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\ndp[c] = dp[c]\nelse:\n# \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\ndp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\nreturn dp[cap]\n
    unbounded_knapsack.go
    [class]{}-[func]{unboundedKnapsackDPComp}\n
    unbounded_knapsack.js
    [class]{}-[func]{unboundedKnapsackDPComp}\n
    unbounded_knapsack.ts
    [class]{}-[func]{unboundedKnapsackDPComp}\n
    unbounded_knapsack.c
    [class]{}-[func]{unboundedKnapsackDPComp}\n
    unbounded_knapsack.cs
    [class]{unbounded_knapsack}-[func]{unboundedKnapsackDPComp}\n
    unbounded_knapsack.swift
    [class]{}-[func]{unboundedKnapsackDPComp}\n
    unbounded_knapsack.zig
    [class]{}-[func]{unboundedKnapsackDPComp}\n
    unbounded_knapsack.dart
    [class]{}-[func]{unboundedKnapsackDPComp}\n
    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1352","title":"13.5.2. \u00a0 \u96f6\u94b1\u5151\u6362\u95ee\u9898","text":"

    \u80cc\u5305\u95ee\u9898\u662f\u4e00\u5927\u7c7b\u52a8\u6001\u89c4\u5212\u95ee\u9898\u7684\u4ee3\u8868\uff0c\u5176\u62e5\u6709\u5f88\u591a\u7684\u53d8\u79cd\uff0c\u4f8b\u5982\u96f6\u94b1\u5151\u6362\u95ee\u9898\u3002

    Question

    \u7ed9\u5b9a \\(n\\) \u79cd\u786c\u5e01\uff0c\u7b2c \\(i\\) \u4e2a\u786c\u5e01\u7684\u9762\u503c\u4e3a \\(coins[i - 1]\\) \uff0c\u4e3a\u76ee\u6807\u91d1\u989d \\(amt\\) \uff0c\u6bcf\u79cd\u786c\u5e01\u53ef\u4ee5\u91cd\u590d\u9009\u53d6\uff0c\u95ee\u80fd\u591f\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u7684\u6700\u5c11\u786c\u5e01\u4e2a\u6570\u3002\u5982\u679c\u65e0\u6cd5\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u5219\u8fd4\u56de \\(-1\\) \u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u51d1\u51fa \\(11\\) \u5143\u6700\u5c11\u9700\u8981 \\(3\\) \u679a\u786c\u5e01\uff0c\u65b9\u6848\u4e3a \\(1 + 2 + 5 = 11\\) \u3002

    Fig. \u96f6\u94b1\u5151\u6362\u95ee\u9898\u7684\u793a\u4f8b\u6570\u636e

    \u96f6\u94b1\u5151\u6362\u95ee\u9898\u53ef\u4ee5\u770b\u4f5c\u662f\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u4e00\u79cd\u7279\u6b8a\u60c5\u51b5\uff0c\u4e24\u8005\u5177\u6709\u4ee5\u4e0b\u8054\u7cfb\u4e0e\u4e0d\u540c\u70b9\uff1a

    • \u4e24\u9053\u9898\u53ef\u4ee5\u76f8\u4e92\u8f6c\u6362\uff0c\u201c\u7269\u54c1\u201d\u5bf9\u5e94\u4e8e\u201c\u786c\u5e01\u201d\u3001\u201c\u7269\u54c1\u91cd\u91cf\u201d\u5bf9\u5e94\u4e8e\u201c\u786c\u5e01\u9762\u503c\u201d\u3001\u201c\u80cc\u5305\u5bb9\u91cf\u201d\u5bf9\u5e94\u4e8e\u201c\u76ee\u6807\u91d1\u989d\u201d\uff1b
    • \u76ee\u6807\u4e0d\u540c\uff0c\u80cc\u5305\u95ee\u9898\u662f\u8981\u6700\u5927\u5316\u7269\u54c1\u4ef7\u503c\uff0c\u96f6\u94b1\u5151\u6362\u95ee\u9898\u662f\u8981\u6700\u5c0f\u5316\u786c\u5e01\u6570\u91cf\uff1b
    • \u80cc\u5305\u95ee\u9898\u662f\u6c42\u201c\u4e0d\u8d85\u8fc7\u201d\u80cc\u5305\u5bb9\u91cf\u4e0b\u7684\u89e3\uff0c\u96f6\u94b1\u5151\u6362\u662f\u6c42\u201c\u6070\u597d\u201d\u51d1\u5230\u76ee\u6807\u91d1\u989d\u7684\u89e3\uff1b

    \u7b2c\u4e00\u6b65\uff1a\u601d\u8003\u6bcf\u8f6e\u7684\u51b3\u7b56\uff0c\u5b9a\u4e49\u72b6\u6001\uff0c\u4ece\u800c\u5f97\u5230 \\(dp\\) \u8868

    \u72b6\u6001 \\([i, a]\\) \u5bf9\u5e94\u7684\u5b50\u95ee\u9898\u4e3a\uff1a\u524d \\(i\\) \u4e2a\u786c\u5e01\u80fd\u591f\u51d1\u51fa\u91d1\u989d \\(a\\) \u7684\u6700\u5c11\u786c\u5e01\u4e2a\u6570\uff0c\u8bb0\u4e3a \\(dp[i, a]\\) \u3002

    \u4e8c\u7ef4 \\(dp\\) \u8868\u7684\u5c3a\u5bf8\u4e3a \\((n+1) \\times (amt+1)\\) \u3002

    \u7b2c\u4e8c\u6b65\uff1a\u627e\u51fa\u6700\u4f18\u5b50\u7ed3\u6784\uff0c\u8fdb\u800c\u63a8\u5bfc\u51fa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b

    \u4e0e\u5b8c\u5168\u80cc\u5305\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u57fa\u672c\u76f8\u540c\uff0c\u4e0d\u540c\u70b9\u5728\u4e8e\uff1a

    • \u672c\u9898\u8981\u6c42\u6700\u5c0f\u503c\uff0c\u56e0\u6b64\u9700\u5c06\u8fd0\u7b97\u7b26 \\(\\max()\\) \u66f4\u6539\u4e3a \\(\\min()\\) \uff1b
    • \u4f18\u5316\u4e3b\u4f53\u662f\u201c\u786c\u5e01\u6570\u91cf\u201d\u800c\u975e\u201d\u5546\u54c1\u4ef7\u503c\u201c\uff0c\u56e0\u6b64\u5728\u9009\u4e2d\u786c\u5e01\u65f6\u6267\u884c \\(+1\\) \u5373\u53ef\uff1b
    \\[ dp[i, a] = \\min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) \\]

    \u7b2c\u4e09\u6b65\uff1a\u786e\u5b9a\u8fb9\u754c\u6761\u4ef6\u548c\u72b6\u6001\u8f6c\u79fb\u987a\u5e8f

    \u5f53\u76ee\u6807\u91d1\u989d\u4e3a \\(0\\) \u65f6\uff0c\u51d1\u51fa\u5b83\u7684\u6700\u5c11\u786c\u5e01\u4e2a\u6570\u4e3a \\(0\\) \uff0c\u5373\u6240\u6709 \\(dp[i, 0]\\) \u90fd\u7b49\u4e8e \\(0\\) \u3002\u5f53\u65e0\u786c\u5e01\u65f6\uff0c\u65e0\u6cd5\u51d1\u51fa\u4efb\u610f \\(> 0\\) \u7684\u76ee\u6807\u91d1\u989d\uff0c\u5373\u662f\u65e0\u6548\u89e3\u3002\u4e3a\u4f7f\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e2d\u7684 \\(\\min()\\) \u51fd\u6570\u80fd\u591f\u8bc6\u522b\u5e76\u8fc7\u6ee4\u65e0\u6548\u89e3\uff0c\u6211\u4eec\u8003\u8651\u4f7f\u7528 \\(+ \\infty\\) \u6765\u8868\u793a\u5b83\u4eec\uff0c\u5373\u4ee4\u6240\u6709 \\(dp[0, a]\\) \u90fd\u7b49\u4e8e \\(+ \\infty\\) \u3002

    \u4ee5\u4e0a\u505a\u6cd5\u4ec5\u9002\u7528\u4e8e Python \u8bed\u8a00\uff0c\u56e0\u4e3a\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u5e76\u672a\u63d0\u4f9b \\(+ \\infty\\) \u53d8\u91cf\uff0c\u6240\u4ee5\u53ea\u80fd\u4f7f\u7528\u6574\u578b int \u7684\u6700\u5927\u503c\uff0c\u800c\u8fd9\u53c8\u4f1a\u5bfc\u81f4\u5927\u6570\u8d8a\u754c\uff1a\u5f53 \\(dp[i, a - coins[i-1]]\\) \u662f\u65e0\u6548\u89e3\u65f6\uff0c\u518d\u6267\u884c \\(+ 1\\) \u64cd\u4f5c\u4f1a\u53d1\u751f\u6ea2\u51fa\u3002

    \u4e3a\u89e3\u51b3\u8be5\u95ee\u9898\uff0c\u6211\u4eec\u91c7\u7528\u4e00\u4e2a\u4e0d\u53ef\u80fd\u8fbe\u5230\u7684\u5927\u6570\u5b57 \\(amt + 1\\) \u6765\u8868\u793a\u65e0\u6548\u89e3\uff0c\u56e0\u4e3a\u51d1\u51fa \\(amt\\) \u7684\u786c\u5e01\u4e2a\u6570\u6700\u591a\u4e3a \\(amt\\) \u4e2a\u3002

    \u5728\u6700\u540e\u8fd4\u56de\u524d\uff0c\u5224\u65ad \\(dp[n, amt]\\) \u662f\u5426\u7b49\u4e8e \\(amt + 1\\) \uff0c\u82e5\u662f\u5219\u8fd4\u56de \\(-1\\) \uff0c\u4ee3\u8868\u65e0\u6cd5\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart coin_change.java
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeDP(int[] coins, int amt) {\nint n = coins.length;\nint MAX = amt + 1;\n// \u521d\u59cb\u5316 dp \u8868\nint[][] dp = new int[n + 1][amt + 1];\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\nfor (int a = 1; a <= amt; a++) {\ndp[0][a] = MAX;\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u5217\nfor (int i = 1; i <= n; i++) {\nfor (int a = 1; a <= amt; a++) {\nif (coins[i - 1] > a) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[i][a] = dp[i - 1][a];\n} else {\n// \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\ndp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n}\n}\n}\nreturn dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n
    coin_change.cpp
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeDP(vector<int> &coins, int amt) {\nint n = coins.size();\nint MAX = amt + 1;\n// \u521d\u59cb\u5316 dp \u8868\nvector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\nfor (int a = 1; a <= amt; a++) {\ndp[0][a] = MAX;\n}\n// \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u5217\nfor (int i = 1; i <= n; i++) {\nfor (int a = 1; a <= amt; a++) {\nif (coins[i - 1] > a) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[i][a] = dp[i - 1][a];\n} else {\n// \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\ndp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n}\n}\n}\nreturn dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n
    coin_change.py
    def coin_change_dp(coins: list[int], amt: int) -> int:\n\"\"\"\u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(coins)\nMAX = amt + 1\n# \u521d\u59cb\u5316 dp \u8868\ndp = [[0] * (amt + 1) for _ in range(n + 1)]\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\nfor a in range(1, amt + 1):\ndp[0][a] = MAX\n# \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u5217\nfor i in range(1, n + 1):\nfor a in range(1, amt + 1):\nif coins[i - 1] > a:\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[i][a] = dp[i - 1][a]\nelse:\n# \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\ndp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\nreturn dp[n][amt] if dp[n][amt] != MAX else -1\n
    coin_change.go
    [class]{}-[func]{coinChangeDP}\n
    coin_change.js
    [class]{}-[func]{coinChangeDP}\n
    coin_change.ts
    [class]{}-[func]{coinChangeDP}\n
    coin_change.c
    [class]{}-[func]{coinChangeDP}\n
    coin_change.cs
    [class]{coin_change}-[func]{coinChangeDP}\n
    coin_change.swift
    [class]{}-[func]{coinChangeDP}\n
    coin_change.zig
    [class]{}-[func]{coinChangeDP}\n
    coin_change.dart
    [class]{}-[func]{coinChangeDP}\n

    \u4e0b\u56fe\u5c55\u793a\u4e86\u96f6\u94b1\u5151\u6362\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b\u3002

    <1><2><3><4><5><6><7><8><9><10><11><12><13><14><15>

    \u7531\u4e8e\u96f6\u94b1\u5151\u6362\u548c\u5b8c\u5168\u80cc\u5305\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u5982\u51fa\u4e00\u8f99\uff0c\u56e0\u6b64\u72b6\u6001\u538b\u7f29\u65b9\u5f0f\u4e5f\u76f8\u540c\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart coin_change.java
    /* \u96f6\u94b1\u5151\u6362\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeDPComp(int[] coins, int amt) {\nint n = coins.length;\nint MAX = amt + 1;\n// \u521d\u59cb\u5316 dp \u8868\nint[] dp = new int[amt + 1];\nArrays.fill(dp, MAX);\ndp[0] = 0;\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int a = 1; a <= amt; a++) {\nif (coins[i - 1] > a) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[a] = dp[a];\n} else {\n// \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\ndp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n}\n}\n}\nreturn dp[amt] != MAX ? dp[amt] : -1;\n}\n
    coin_change.cpp
    /* \u96f6\u94b1\u5151\u6362\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeDPComp(vector<int> &coins, int amt) {\nint n = coins.size();\nint MAX = amt + 1;\n// \u521d\u59cb\u5316 dp \u8868\nvector<int> dp(amt + 1, MAX);\ndp[0] = 0;\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int a = 1; a <= amt; a++) {\nif (coins[i - 1] > a) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[a] = dp[a];\n} else {\n// \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\ndp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n}\n}\n}\nreturn dp[amt] != MAX ? dp[amt] : -1;\n}\n
    coin_change.py
    def coin_change_dp_comp(coins: list[int], amt: int) -> int:\n\"\"\"\u96f6\u94b1\u5151\u6362\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(coins)\nMAX = amt + 1\n# \u521d\u59cb\u5316 dp \u8868\ndp = [MAX] * (amt + 1)\ndp[0] = 0\n# \u72b6\u6001\u8f6c\u79fb\nfor i in range(1, n + 1):\n# \u6b63\u5e8f\u904d\u5386\nfor a in range(1, amt + 1):\nif coins[i - 1] > a:\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[a] = dp[a]\nelse:\n# \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\ndp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\nreturn dp[amt] if dp[amt] != MAX else -1\n
    coin_change.go
    [class]{}-[func]{coinChangeDPComp}\n
    coin_change.js
    [class]{}-[func]{coinChangeDPComp}\n
    coin_change.ts
    [class]{}-[func]{coinChangeDPComp}\n
    coin_change.c
    [class]{}-[func]{coinChangeDPComp}\n
    coin_change.cs
    [class]{coin_change}-[func]{coinChangeDPComp}\n
    coin_change.swift
    [class]{}-[func]{coinChangeDPComp}\n
    coin_change.zig
    [class]{}-[func]{coinChangeDPComp}\n
    coin_change.dart
    [class]{}-[func]{coinChangeDPComp}\n
    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1353-ii","title":"13.5.3. \u00a0 \u96f6\u94b1\u5151\u6362\u95ee\u9898 II","text":"

    Question

    \u7ed9\u5b9a \\(n\\) \u79cd\u786c\u5e01\uff0c\u7b2c \\(i\\) \u4e2a\u786c\u5e01\u7684\u9762\u503c\u4e3a \\(coins[i - 1]\\) \uff0c\u76ee\u6807\u91d1\u989d\u4e3a \\(amt\\) \uff0c\u6bcf\u79cd\u786c\u5e01\u53ef\u4ee5\u91cd\u590d\u9009\u53d6\uff0c\u95ee\u5728\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u7684\u786c\u5e01\u7ec4\u5408\u6570\u91cf\u3002

    Fig. \u96f6\u94b1\u5151\u6362\u95ee\u9898 II \u7684\u793a\u4f8b\u6570\u636e

    \u76f8\u6bd4\u4e8e\u4e0a\u4e00\u9898\uff0c\u672c\u9898\u76ee\u6807\u662f\u7ec4\u5408\u6570\u91cf\uff0c\u56e0\u6b64\u5b50\u95ee\u9898\u53d8\u4e3a\uff1a\u524d \\(i\\) \u4e2a\u786c\u5e01\u80fd\u591f\u51d1\u51fa\u91d1\u989d \\(a\\) \u7684\u7ec4\u5408\u6570\u91cf\u3002\u800c \\(dp\\) \u8868\u4ecd\u7136\u662f\u5c3a\u5bf8\u4e3a \\((n+1) \\times (amt + 1)\\) \u7684\u4e8c\u7ef4\u77e9\u9635\u3002

    \u5f53\u524d\u72b6\u6001\u7684\u7ec4\u5408\u6570\u91cf\u7b49\u4e8e\u4e0d\u9009\u5f53\u524d\u786c\u5e01\u4e0e\u9009\u5f53\u524d\u786c\u5e01\u8fd9\u4e24\u79cd\u51b3\u7b56\u7684\u7ec4\u5408\u6570\u91cf\u4e4b\u548c\u3002\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e3a\uff1a

    \\[ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] \\]

    \u5f53\u76ee\u6807\u91d1\u989d\u4e3a \\(0\\) \u65f6\uff0c\u65e0\u9700\u9009\u62e9\u4efb\u4f55\u786c\u5e01\u5373\u53ef\u51d1\u51fa\u76ee\u6807\u91d1\u989d\uff0c\u56e0\u6b64\u5e94\u5c06\u6240\u6709 \\(dp[i, 0]\\) \u90fd\u521d\u59cb\u5316\u4e3a \\(1\\) \u3002\u5f53\u65e0\u786c\u5e01\u65f6\uff0c\u65e0\u6cd5\u51d1\u51fa\u4efb\u4f55 \\(>0\\) \u7684\u76ee\u6807\u91d1\u989d\uff0c\u56e0\u6b64\u6240\u6709 \\(dp[0, a]\\) \u90fd\u7b49\u4e8e \\(0\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart coin_change_ii.java
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDP(int[] coins, int amt) {\nint n = coins.length;\n// \u521d\u59cb\u5316 dp \u8868\nint[][] dp = new int[n + 1][amt + 1];\n// \u521d\u59cb\u5316\u9996\u5217\nfor (int i = 0; i <= n; i++) {\ndp[i][0] = 1;\n}\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int a = 1; a <= amt; a++) {\nif (coins[i - 1] > a) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[i][a] = dp[i - 1][a];\n} else {\n// \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\ndp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n}\n}\n}\nreturn dp[n][amt];\n}\n
    coin_change_ii.cpp
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDP(vector<int> &coins, int amt) {\nint n = coins.size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));\n// \u521d\u59cb\u5316\u9996\u5217\nfor (int i = 0; i <= n; i++) {\ndp[i][0] = 1;\n}\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int a = 1; a <= amt; a++) {\nif (coins[i - 1] > a) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[i][a] = dp[i - 1][a];\n} else {\n// \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\ndp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n}\n}\n}\nreturn dp[n][amt];\n}\n
    coin_change_ii.py
    def coin_change_ii_dp(coins: list[int], amt: int) -> int:\n\"\"\"\u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(coins)\n# \u521d\u59cb\u5316 dp \u8868\ndp = [[0] * (amt + 1) for _ in range(n + 1)]\n# \u521d\u59cb\u5316\u9996\u5217\nfor i in range(n + 1):\ndp[i][0] = 1\n# \u72b6\u6001\u8f6c\u79fb\nfor i in range(1, n + 1):\nfor a in range(1, amt + 1):\nif coins[i - 1] > a:\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[i][a] = dp[i - 1][a]\nelse:\n# \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\ndp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\nreturn dp[n][amt]\n
    coin_change_ii.go
    [class]{}-[func]{coinChangeIIDP}\n
    coin_change_ii.js
    [class]{}-[func]{coinChangeIIDP}\n
    coin_change_ii.ts
    [class]{}-[func]{coinChangeIIDP}\n
    coin_change_ii.c
    [class]{}-[func]{coinChangeIIDP}\n
    coin_change_ii.cs
    [class]{coin_change_ii}-[func]{coinChangeIIDP}\n
    coin_change_ii.swift
    [class]{}-[func]{coinChangeIIDP}\n
    coin_change_ii.zig
    [class]{}-[func]{coinChangeIIDP}\n
    coin_change_ii.dart
    [class]{}-[func]{coinChangeIIDP}\n

    \u72b6\u6001\u538b\u7f29\u5904\u7406\u65b9\u5f0f\u76f8\u540c\uff0c\u5220\u9664\u786c\u5e01\u7ef4\u5ea6\u5373\u53ef\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart coin_change_ii.java
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDPComp(int[] coins, int amt) {\nint n = coins.length;\n// \u521d\u59cb\u5316 dp \u8868\nint[] dp = new int[amt + 1];\ndp[0] = 1;\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int a = 1; a <= amt; a++) {\nif (coins[i - 1] > a) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[a] = dp[a];\n} else {\n// \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\ndp[a] = dp[a] + dp[a - coins[i - 1]];\n}\n}\n}\nreturn dp[amt];\n}\n
    coin_change_ii.cpp
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDPComp(vector<int> &coins, int amt) {\nint n = coins.size();\n// \u521d\u59cb\u5316 dp \u8868\nvector<int> dp(amt + 1, 0);\ndp[0] = 1;\n// \u72b6\u6001\u8f6c\u79fb\nfor (int i = 1; i <= n; i++) {\nfor (int a = 1; a <= amt; a++) {\nif (coins[i - 1] > a) {\n// \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[a] = dp[a];\n} else {\n// \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\ndp[a] = dp[a] + dp[a - coins[i - 1]];\n}\n}\n}\nreturn dp[amt];\n}\n
    coin_change_ii.py
    def coin_change_ii_dp_comp(coins: list[int], amt: int) -> int:\n\"\"\"\u96f6\u94b1\u5151\u6362 II\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\nn = len(coins)\n# \u521d\u59cb\u5316 dp \u8868\ndp = [0] * (amt + 1)\ndp[0] = 1\n# \u72b6\u6001\u8f6c\u79fb\nfor i in range(1, n + 1):\n# \u6b63\u5e8f\u904d\u5386\nfor a in range(1, amt + 1):\nif coins[i - 1] > a:\n# \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\ndp[a] = dp[a]\nelse:\n# \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\ndp[a] = dp[a] + dp[a - coins[i - 1]]\nreturn dp[amt]\n
    coin_change_ii.go
    [class]{}-[func]{coinChangeIIDPComp}\n
    coin_change_ii.js
    [class]{}-[func]{coinChangeIIDPComp}\n
    coin_change_ii.ts
    [class]{}-[func]{coinChangeIIDPComp}\n
    coin_change_ii.c
    [class]{}-[func]{coinChangeIIDPComp}\n
    coin_change_ii.cs
    [class]{coin_change_ii}-[func]{coinChangeIIDPComp}\n
    coin_change_ii.swift
    [class]{}-[func]{coinChangeIIDPComp}\n
    coin_change_ii.zig
    [class]{}-[func]{coinChangeIIDPComp}\n
    coin_change_ii.dart
    [class]{}-[func]{coinChangeIIDPComp}\n
    "},{"location":"chapter_graph/","title":"9. \u00a0 \u56fe","text":""},{"location":"chapter_graph/graph/","title":"9.1. \u00a0 \u56fe","text":"

    \u300c\u56fe Graph\u300d\u662f\u4e00\u79cd\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u7531\u300c\u9876\u70b9 Vertex\u300d\u548c\u300c\u8fb9 Edge\u300d\u7ec4\u6210\u3002\u6211\u4eec\u53ef\u4ee5\u5c06\u56fe \\(G\\) \u62bd\u8c61\u5730\u8868\u793a\u4e3a\u4e00\u7ec4\u9876\u70b9 \\(V\\) \u548c\u4e00\u7ec4\u8fb9 \\(E\\) \u7684\u96c6\u5408\u3002\u4ee5\u4e0b\u793a\u4f8b\u5c55\u793a\u4e86\u4e00\u4e2a\u5305\u542b 5 \u4e2a\u9876\u70b9\u548c 7 \u6761\u8fb9\u7684\u56fe\u3002

    \\[ \\begin{aligned} V & = \\{ 1, 2, 3, 4, 5 \\} \\newline E & = \\{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \\} \\newline G & = \\{ V, E \\} \\newline \\end{aligned} \\]

    Fig. \u94fe\u8868\u3001\u6811\u3001\u56fe\u4e4b\u95f4\u7684\u5173\u7cfb

    \u90a3\u4e48\uff0c\u56fe\u4e0e\u5176\u4ed6\u6570\u636e\u7ed3\u6784\u7684\u5173\u7cfb\u662f\u4ec0\u4e48\uff1f\u5982\u679c\u6211\u4eec\u628a\u300c\u9876\u70b9\u300d\u770b\u4f5c\u8282\u70b9\uff0c\u628a\u300c\u8fb9\u300d\u770b\u4f5c\u8fde\u63a5\u5404\u4e2a\u8282\u70b9\u7684\u6307\u9488\uff0c\u5219\u53ef\u5c06\u300c\u56fe\u300d\u770b\u4f5c\u662f\u4e00\u79cd\u4ece\u300c\u94fe\u8868\u300d\u62d3\u5c55\u800c\u6765\u7684\u6570\u636e\u7ed3\u6784\u3002\u76f8\u8f83\u4e8e\u7ebf\u6027\u5173\u7cfb\uff08\u94fe\u8868\uff09\u548c\u5206\u6cbb\u5173\u7cfb\uff08\u6811\uff09\uff0c\u7f51\u7edc\u5173\u7cfb\uff08\u56fe\uff09\u7684\u81ea\u7531\u5ea6\u66f4\u9ad8\uff0c\u4ece\u800c\u66f4\u4e3a\u590d\u6742\u3002

    "},{"location":"chapter_graph/graph/#911","title":"9.1.1. \u00a0 \u56fe\u5e38\u89c1\u7c7b\u578b","text":"

    \u6839\u636e\u8fb9\u662f\u5426\u5177\u6709\u65b9\u5411\uff0c\u53ef\u5206\u4e3a\u300c\u65e0\u5411\u56fe Undirected Graph\u300d\u548c\u300c\u6709\u5411\u56fe Directed Graph\u300d\u3002

    • \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u8fb9\u8868\u793a\u4e24\u9876\u70b9\u4e4b\u95f4\u7684\u201c\u53cc\u5411\u201d\u8fde\u63a5\u5173\u7cfb\uff0c\u4f8b\u5982\u5fae\u4fe1\u6216 QQ \u4e2d\u7684\u201c\u597d\u53cb\u5173\u7cfb\u201d\uff1b
    • \u5728\u6709\u5411\u56fe\u4e2d\uff0c\u8fb9\u5177\u6709\u65b9\u5411\u6027\uff0c\u5373 \\(A \\rightarrow B\\) \u548c \\(A \\leftarrow B\\) \u4e24\u4e2a\u65b9\u5411\u7684\u8fb9\u662f\u76f8\u4e92\u72ec\u7acb\u7684\uff0c\u4f8b\u5982\u5fae\u535a\u6216\u6296\u97f3\u4e0a\u7684\u201c\u5173\u6ce8\u201d\u4e0e\u201c\u88ab\u5173\u6ce8\u201d\u5173\u7cfb\uff1b

    Fig. \u6709\u5411\u56fe\u4e0e\u65e0\u5411\u56fe

    \u6839\u636e\u6240\u6709\u9876\u70b9\u662f\u5426\u8fde\u901a\uff0c\u53ef\u5206\u4e3a\u300c\u8fde\u901a\u56fe Connected Graph\u300d\u548c\u300c\u975e\u8fde\u901a\u56fe Disconnected Graph\u300d\u3002

    • \u5bf9\u4e8e\u8fde\u901a\u56fe\uff0c\u4ece\u67d0\u4e2a\u9876\u70b9\u51fa\u53d1\uff0c\u53ef\u4ee5\u5230\u8fbe\u5176\u4f59\u4efb\u610f\u9876\u70b9\uff1b
    • \u5bf9\u4e8e\u975e\u8fde\u901a\u56fe\uff0c\u4ece\u67d0\u4e2a\u9876\u70b9\u51fa\u53d1\uff0c\u81f3\u5c11\u6709\u4e00\u4e2a\u9876\u70b9\u65e0\u6cd5\u5230\u8fbe\uff1b

    Fig. \u8fde\u901a\u56fe\u4e0e\u975e\u8fde\u901a\u56fe

    \u6211\u4eec\u8fd8\u53ef\u4ee5\u4e3a\u8fb9\u6dfb\u52a0\u201c\u6743\u91cd\u201d\u53d8\u91cf\uff0c\u4ece\u800c\u5f97\u5230\u300c\u6709\u6743\u56fe Weighted Graph\u300d\u3002\u4f8b\u5982\uff0c\u5728\u738b\u8005\u8363\u8000\u7b49\u624b\u6e38\u4e2d\uff0c\u7cfb\u7edf\u4f1a\u6839\u636e\u5171\u540c\u6e38\u620f\u65f6\u95f4\u6765\u8ba1\u7b97\u73a9\u5bb6\u4e4b\u95f4\u7684\u201c\u4eb2\u5bc6\u5ea6\u201d\uff0c\u8fd9\u79cd\u4eb2\u5bc6\u5ea6\u7f51\u7edc\u5c31\u53ef\u4ee5\u7528\u6709\u6743\u56fe\u6765\u8868\u793a\u3002

    Fig. \u6709\u6743\u56fe\u4e0e\u65e0\u6743\u56fe

    "},{"location":"chapter_graph/graph/#912","title":"9.1.2. \u00a0 \u56fe\u5e38\u7528\u672f\u8bed","text":"
    • \u300c\u90bb\u63a5 Adjacency\u300d\uff1a\u5f53\u4e24\u9876\u70b9\u4e4b\u95f4\u5b58\u5728\u8fb9\u76f8\u8fde\u65f6\uff0c\u79f0\u8fd9\u4e24\u9876\u70b9\u201c\u90bb\u63a5\u201d\u3002\u5728\u4e0a\u56fe\u4e2d\uff0c\u9876\u70b9 1 \u7684\u90bb\u63a5\u9876\u70b9\u4e3a\u9876\u70b9 2\u30013\u30015\u3002
    • \u300c\u8def\u5f84 Path\u300d\uff1a\u4ece\u9876\u70b9 A \u5230\u9876\u70b9 B \u7ecf\u8fc7\u7684\u8fb9\u6784\u6210\u7684\u5e8f\u5217\u88ab\u79f0\u4e3a\u4ece A \u5230 B \u7684\u201c\u8def\u5f84\u201d\u3002\u5728\u4e0a\u56fe\u4e2d\uff0c\u8fb9\u5e8f\u5217 1-5-2-4 \u662f\u9876\u70b9 1 \u5230\u9876\u70b9 4 \u7684\u4e00\u6761\u8def\u5f84\u3002
    • \u300c\u5ea6 Degree\u300d\u8868\u793a\u4e00\u4e2a\u9876\u70b9\u62e5\u6709\u7684\u8fb9\u6570\u3002\u5bf9\u4e8e\u6709\u5411\u56fe\uff0c\u300c\u5165\u5ea6 In-Degree\u300d\u8868\u793a\u6709\u591a\u5c11\u6761\u8fb9\u6307\u5411\u8be5\u9876\u70b9\uff0c\u300c\u51fa\u5ea6 Out-Degree\u300d\u8868\u793a\u6709\u591a\u5c11\u6761\u8fb9\u4ece\u8be5\u9876\u70b9\u6307\u51fa\u3002
    "},{"location":"chapter_graph/graph/#913","title":"9.1.3. \u00a0 \u56fe\u7684\u8868\u793a","text":"

    \u56fe\u7684\u5e38\u7528\u8868\u793a\u65b9\u6cd5\u5305\u62ec\u300c\u90bb\u63a5\u77e9\u9635\u300d\u548c\u300c\u90bb\u63a5\u8868\u300d\u3002\u4ee5\u4e0b\u4f7f\u7528\u65e0\u5411\u56fe\u8fdb\u884c\u4e3e\u4f8b\u3002

    "},{"location":"chapter_graph/graph/#_1","title":"\u90bb\u63a5\u77e9\u9635","text":"

    \u8bbe\u56fe\u7684\u9876\u70b9\u6570\u91cf\u4e3a \\(n\\) \uff0c\u300c\u90bb\u63a5\u77e9\u9635 Adjacency Matrix\u300d\u4f7f\u7528\u4e00\u4e2a \\(n \\times n\\) \u5927\u5c0f\u7684\u77e9\u9635\u6765\u8868\u793a\u56fe\uff0c\u6bcf\u4e00\u884c\uff08\u5217\uff09\u4ee3\u8868\u4e00\u4e2a\u9876\u70b9\uff0c\u77e9\u9635\u5143\u7d20\u4ee3\u8868\u8fb9\uff0c\u7528 \\(1\\) \u6216 \\(0\\) \u8868\u793a\u4e24\u4e2a\u9876\u70b9\u4e4b\u95f4\u662f\u5426\u5b58\u5728\u8fb9\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u8bbe\u90bb\u63a5\u77e9\u9635\u4e3a \\(M\\) \u3001\u9876\u70b9\u5217\u8868\u4e3a \\(V\\) \uff0c\u90a3\u4e48\u77e9\u9635\u5143\u7d20 \\(M[i][j] = 1\\) \u8868\u793a\u9876\u70b9 \\(V[i]\\) \u5230\u9876\u70b9 \\(V[j]\\) \u4e4b\u95f4\u5b58\u5728\u8fb9\uff0c\u53cd\u4e4b \\(M[i][j] = 0\\) \u8868\u793a\u4e24\u9876\u70b9\u4e4b\u95f4\u65e0\u8fb9\u3002

    Fig. \u56fe\u7684\u90bb\u63a5\u77e9\u9635\u8868\u793a

    \u90bb\u63a5\u77e9\u9635\u5177\u6709\u4ee5\u4e0b\u7279\u6027\uff1a

    • \u9876\u70b9\u4e0d\u80fd\u4e0e\u81ea\u8eab\u76f8\u8fde\uff0c\u56e0\u6b64\u90bb\u63a5\u77e9\u9635\u4e3b\u5bf9\u89d2\u7ebf\u5143\u7d20\u6ca1\u6709\u610f\u4e49\u3002
    • \u5bf9\u4e8e\u65e0\u5411\u56fe\uff0c\u4e24\u4e2a\u65b9\u5411\u7684\u8fb9\u7b49\u4ef7\uff0c\u6b64\u65f6\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\u3002
    • \u5c06\u90bb\u63a5\u77e9\u9635\u7684\u5143\u7d20\u4ece \\(1\\) , \\(0\\) \u66ff\u6362\u4e3a\u6743\u91cd\uff0c\u5219\u53ef\u8868\u793a\u6709\u6743\u56fe\u3002

    \u4f7f\u7528\u90bb\u63a5\u77e9\u9635\u8868\u793a\u56fe\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u8bbf\u95ee\u77e9\u9635\u5143\u7d20\u4ee5\u83b7\u53d6\u8fb9\uff0c\u56e0\u6b64\u589e\u5220\u67e5\u64cd\u4f5c\u7684\u6548\u7387\u5f88\u9ad8\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(1)\\) \u3002\u7136\u800c\uff0c\u77e9\u9635\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff0c\u5185\u5b58\u5360\u7528\u8f83\u591a\u3002

    "},{"location":"chapter_graph/graph/#_2","title":"\u90bb\u63a5\u8868","text":"

    \u300c\u90bb\u63a5\u8868 Adjacency List\u300d\u4f7f\u7528 \\(n\\) \u4e2a\u94fe\u8868\u6765\u8868\u793a\u56fe\uff0c\u94fe\u8868\u8282\u70b9\u8868\u793a\u9876\u70b9\u3002\u7b2c \\(i\\) \u6761\u94fe\u8868\u5bf9\u5e94\u9876\u70b9 \\(i\\) \uff0c\u5176\u4e2d\u5b58\u50a8\u4e86\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\uff08\u5373\u4e0e\u8be5\u9876\u70b9\u76f8\u8fde\u7684\u9876\u70b9\uff09\u3002

    Fig. \u56fe\u7684\u90bb\u63a5\u8868\u8868\u793a

    \u90bb\u63a5\u8868\u4ec5\u5b58\u50a8\u5b9e\u9645\u5b58\u5728\u7684\u8fb9\uff0c\u800c\u8fb9\u7684\u603b\u6570\u901a\u5e38\u8fdc\u5c0f\u4e8e \\(n^2\\) \uff0c\u56e0\u6b64\u5b83\u66f4\u52a0\u8282\u7701\u7a7a\u95f4\u3002\u7136\u800c\uff0c\u5728\u90bb\u63a5\u8868\u4e2d\u9700\u8981\u901a\u8fc7\u904d\u5386\u94fe\u8868\u6765\u67e5\u627e\u8fb9\uff0c\u56e0\u6b64\u5176\u65f6\u95f4\u6548\u7387\u4e0d\u5982\u90bb\u63a5\u77e9\u9635\u3002

    \u89c2\u5bdf\u4e0a\u56fe\u53ef\u53d1\u73b0\uff0c\u90bb\u63a5\u8868\u7ed3\u6784\u4e0e\u54c8\u5e0c\u8868\u4e2d\u7684\u300c\u94fe\u5730\u5740\u6cd5\u300d\u975e\u5e38\u76f8\u4f3c\uff0c\u56e0\u6b64\u6211\u4eec\u4e5f\u53ef\u4ee5\u91c7\u7528\u7c7b\u4f3c\u65b9\u6cd5\u6765\u4f18\u5316\u6548\u7387\u3002\u4f8b\u5982\uff0c\u5f53\u94fe\u8868\u8f83\u957f\u65f6\uff0c\u53ef\u4ee5\u5c06\u94fe\u8868\u8f6c\u5316\u4e3a AVL \u6811\u6216\u7ea2\u9ed1\u6811\uff0c\u4ece\u800c\u5c06\u65f6\u95f4\u6548\u7387\u4ece \\(O(n)\\) \u4f18\u5316\u81f3 \\(O(\\log n)\\) \uff0c\u8fd8\u53ef\u4ee5\u901a\u8fc7\u4e2d\u5e8f\u904d\u5386\u83b7\u53d6\u6709\u5e8f\u5e8f\u5217\uff1b\u6b64\u5916\uff0c\u8fd8\u53ef\u4ee5\u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u54c8\u5e0c\u8868\uff0c\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u964d\u4f4e\u81f3 \\(O(1)\\) \u3002

    "},{"location":"chapter_graph/graph/#914","title":"9.1.4. \u00a0 \u56fe\u5e38\u89c1\u5e94\u7528","text":"

    \u5b9e\u9645\u5e94\u7528\u4e2d\uff0c\u8bb8\u591a\u7cfb\u7edf\u90fd\u53ef\u4ee5\u7528\u56fe\u6765\u5efa\u6a21\uff0c\u76f8\u5e94\u7684\u5f85\u6c42\u89e3\u95ee\u9898\u4e5f\u53ef\u4ee5\u7ea6\u5316\u4e3a\u56fe\u8ba1\u7b97\u95ee\u9898\u3002

    \u9876\u70b9 \u8fb9 \u56fe\u8ba1\u7b97\u95ee\u9898 \u793e\u4ea4\u7f51\u7edc \u7528\u6237 \u597d\u53cb\u5173\u7cfb \u6f5c\u5728\u597d\u53cb\u63a8\u8350 \u5730\u94c1\u7ebf\u8def \u7ad9\u70b9 \u7ad9\u70b9\u95f4\u7684\u8fde\u901a\u6027 \u6700\u77ed\u8def\u7ebf\u63a8\u8350 \u592a\u9633\u7cfb \u661f\u4f53 \u661f\u4f53\u95f4\u7684\u4e07\u6709\u5f15\u529b\u4f5c\u7528 \u884c\u661f\u8f68\u9053\u8ba1\u7b97"},{"location":"chapter_graph/graph_operations/","title":"9.2. \u00a0 \u56fe\u57fa\u7840\u64cd\u4f5c","text":"

    \u56fe\u7684\u57fa\u7840\u64cd\u4f5c\u53ef\u5206\u4e3a\u5bf9\u300c\u8fb9\u300d\u7684\u64cd\u4f5c\u548c\u5bf9\u300c\u9876\u70b9\u300d\u7684\u64cd\u4f5c\u3002\u5728\u300c\u90bb\u63a5\u77e9\u9635\u300d\u548c\u300c\u90bb\u63a5\u8868\u300d\u4e24\u79cd\u8868\u793a\u65b9\u6cd5\u4e0b\uff0c\u5b9e\u73b0\u65b9\u5f0f\u6709\u6240\u4e0d\u540c\u3002

    "},{"location":"chapter_graph/graph_operations/#921","title":"9.2.1. \u00a0 \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u7684\u5b9e\u73b0","text":"

    \u7ed9\u5b9a\u4e00\u4e2a\u9876\u70b9\u6570\u91cf\u4e3a \\(n\\) \u7684\u65e0\u5411\u56fe\uff0c\u5219\u6709\uff1a

    • \u6dfb\u52a0\u6216\u5220\u9664\u8fb9\uff1a\u76f4\u63a5\u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u4fee\u6539\u6307\u5b9a\u7684\u8fb9\u5373\u53ef\uff0c\u4f7f\u7528 \\(O(1)\\) \u65f6\u95f4\u3002\u800c\u7531\u4e8e\u662f\u65e0\u5411\u56fe\uff0c\u56e0\u6b64\u9700\u8981\u540c\u65f6\u66f4\u65b0\u4e24\u4e2a\u65b9\u5411\u7684\u8fb9\u3002
    • \u6dfb\u52a0\u9876\u70b9\uff1a\u5728\u90bb\u63a5\u77e9\u9635\u7684\u5c3e\u90e8\u6dfb\u52a0\u4e00\u884c\u4e00\u5217\uff0c\u5e76\u5168\u90e8\u586b \\(0\\) \u5373\u53ef\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002
    • \u5220\u9664\u9876\u70b9\uff1a\u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u4e00\u884c\u4e00\u5217\u3002\u5f53\u5220\u9664\u9996\u884c\u9996\u5217\u65f6\u8fbe\u5230\u6700\u5dee\u60c5\u51b5\uff0c\u9700\u8981\u5c06 \\((n-1)^2\\) \u4e2a\u5143\u7d20\u201c\u5411\u5de6\u4e0a\u79fb\u52a8\u201d\uff0c\u4ece\u800c\u4f7f\u7528 \\(O(n^2)\\) \u65f6\u95f4\u3002
    • \u521d\u59cb\u5316\uff1a\u4f20\u5165 \\(n\\) \u4e2a\u9876\u70b9\uff0c\u521d\u59cb\u5316\u957f\u5ea6\u4e3a \\(n\\) \u7684\u9876\u70b9\u5217\u8868 vertices \uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\uff1b\u521d\u59cb\u5316 \\(n \\times n\\) \u5927\u5c0f\u7684\u90bb\u63a5\u77e9\u9635 adjMat \uff0c\u4f7f\u7528 \\(O(n^2)\\) \u65f6\u95f4\u3002
    \u521d\u59cb\u5316\u90bb\u63a5\u77e9\u9635\u6dfb\u52a0\u8fb9\u5220\u9664\u8fb9\u6dfb\u52a0\u9876\u70b9\u5220\u9664\u9876\u70b9

    \u4ee5\u4e0b\u662f\u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u8868\u793a\u56fe\u7684\u5b9e\u73b0\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart graph_adjacency_matrix.java
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nList<Integer> vertices; // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nList<List<Integer>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u65b9\u6cd5 */\npublic GraphAdjMat(int[] vertices, int[][] edges) {\nthis.vertices = new ArrayList<>();\nthis.adjMat = new ArrayList<>();\n// \u6dfb\u52a0\u9876\u70b9\nfor (int val : vertices) {\naddVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor (int[] e : edges) {\naddEdge(e[0], e[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\npublic int size() {\nreturn vertices.size();\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\npublic void addVertex(int val) {\nint n = size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nvertices.add(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nList<Integer> newRow = new ArrayList<>(n);\nfor (int j = 0; j < n; j++) {\nnewRow.add(0);\n}\nadjMat.add(newRow);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor (List<Integer> row : adjMat) {\nrow.add(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\npublic void removeVertex(int index) {\nif (index >= size())\nthrow new IndexOutOfBoundsException();\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nvertices.remove(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nadjMat.remove(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor (List<Integer> row : adjMat) {\nrow.remove(index);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\npublic void addEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\nthrow new IndexOutOfBoundsException();\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nadjMat.get(i).set(j, 1);\nadjMat.get(j).set(i, 1);\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\npublic void removeEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\nthrow new IndexOutOfBoundsException();\nadjMat.get(i).set(j, 0);\nadjMat.get(j).set(i, 0);\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\npublic void print() {\nSystem.out.print(\"\u9876\u70b9\u5217\u8868 = \");\nSystem.out.println(vertices);\nSystem.out.println(\"\u90bb\u63a5\u77e9\u9635 =\");\nPrintUtil.printMatrix(adjMat);\n}\n}\n
    graph_adjacency_matrix.cpp
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nvector<int> vertices;       // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nvector<vector<int>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nGraphAdjMat(const vector<int> &vertices, const vector<vector<int>> &edges) {\n// \u6dfb\u52a0\u9876\u70b9\nfor (int val : vertices) {\naddVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor (const vector<int> &edge : edges) {\naddEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nint size() const {\nreturn vertices.size();\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(int val) {\nint n = size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nvertices.push_back(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nadjMat.emplace_back(vector<int>(n, 0));\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor (vector<int> &row : adjMat) {\nrow.push_back(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(int index) {\nif (index >= size()) {\nthrow out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nvertices.erase(vertices.begin() + index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nadjMat.erase(adjMat.begin() + index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor (vector<int> &row : adjMat) {\nrow.erase(row.begin() + index);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid addEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\nthrow out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nadjMat[i][j] = 1;\nadjMat[j][i] = 1;\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid removeEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\nthrow out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n}\nadjMat[i][j] = 0;\nadjMat[j][i] = 0;\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nvoid print() {\ncout << \"\u9876\u70b9\u5217\u8868 = \";\nprintVector(vertices);\ncout << \"\u90bb\u63a5\u77e9\u9635 =\" << endl;\nprintVectorMatrix(adjMat);\n}\n};\n
    graph_adjacency_matrix.py
    class GraphAdjMat:\n\"\"\"\u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\"\"\"\n# \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nvertices: list[int] = []\n# \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\nadj_mat: list[list[int]] = []\ndef __init__(self, vertices: list[int], edges: list[list[int]]) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.vertices: list[int] = []\nself.adj_mat: list[list[int]] = []\n# \u6dfb\u52a0\u9876\u70b9\nfor val in vertices:\nself.add_vertex(val)\n# \u6dfb\u52a0\u8fb9\n# \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor e in edges:\nself.add_edge(e[0], e[1])\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u9876\u70b9\u6570\u91cf\"\"\"\nreturn len(self.vertices)\ndef add_vertex(self, val: int) -> None:\n\"\"\"\u6dfb\u52a0\u9876\u70b9\"\"\"\nn = self.size()\n# \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nself.vertices.append(val)\n# \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nnew_row = [0] * n\nself.adj_mat.append(new_row)\n# \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor row in self.adj_mat:\nrow.append(0)\ndef remove_vertex(self, index: int) -> None:\n\"\"\"\u5220\u9664\u9876\u70b9\"\"\"\nif index >= self.size():\nraise IndexError()\n# \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nself.vertices.pop(index)\n# \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nself.adj_mat.pop(index)\n# \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor row in self.adj_mat:\nrow.pop(index)\ndef add_edge(self, i: int, j: int) -> None:\n\"\"\"\u6dfb\u52a0\u8fb9\"\"\"\n# \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n# \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:\nraise IndexError()\n# \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nself.adj_mat[i][j] = 1\nself.adj_mat[j][i] = 1\ndef remove_edge(self, i: int, j: int) -> None:\n\"\"\"\u5220\u9664\u8fb9\"\"\"\n# \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n# \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:\nraise IndexError()\nself.adj_mat[i][j] = 0\nself.adj_mat[j][i] = 0\ndef print(self) -> None:\n\"\"\"\u6253\u5370\u90bb\u63a5\u77e9\u9635\"\"\"\nprint(\"\u9876\u70b9\u5217\u8868 =\", self.vertices)\nprint(\"\u90bb\u63a5\u77e9\u9635 =\")\nprint_matrix(self.adj_mat)\n
    graph_adjacency_matrix.go
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\ntype graphAdjMat struct {\n// \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nvertices []int\n// \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\nadjMat [][]int\n}\n/* \u6784\u9020\u51fd\u6570 */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n// \u6dfb\u52a0\u9876\u70b9\nn := len(vertices)\nadjMat := make([][]int, n)\nfor i := range adjMat {\nadjMat[i] = make([]int, n)\n}\n// \u521d\u59cb\u5316\u56fe\ng := &graphAdjMat{\nvertices: vertices,\nadjMat:   adjMat,\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor i := range edges {\ng.addEdge(edges[i][0], edges[i][1])\n}\nreturn g\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc (g *graphAdjMat) size() int {\nreturn len(g.vertices)\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc (g *graphAdjMat) addVertex(val int) {\nn := g.size()\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\ng.vertices = append(g.vertices, val)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nnewRow := make([]int, n)\ng.adjMat = append(g.adjMat, newRow)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor i := range g.adjMat {\ng.adjMat[i] = append(g.adjMat[i], 0)\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nfunc (g *graphAdjMat) removeVertex(index int) {\nif index >= g.size() {\nreturn\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\ng.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\ng.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor i := range g.adjMat {\ng.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfunc (g *graphAdjMat) addEdge(i, j int) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {\nfmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\ng.adjMat[i][j] = 1\ng.adjMat[j][i] = 1\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfunc (g *graphAdjMat) removeEdge(i, j int) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {\nfmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n}\ng.adjMat[i][j] = 0\ng.adjMat[j][i] = 0\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nfunc (g *graphAdjMat) print() {\nfmt.Printf(\"\\t\u9876\u70b9\u5217\u8868 = %v\\n\", g.vertices)\nfmt.Printf(\"\\t\u90bb\u63a5\u77e9\u9635 = \\n\")\nfor i := range g.adjMat {\nfmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n}\n}\n
    graph_adjacency_matrix.js
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nvertices; // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nadjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u51fd\u6570 */\nconstructor(vertices, edges) {\nthis.vertices = [];\nthis.adjMat = [];\n// \u6dfb\u52a0\u9876\u70b9\nfor (const val of vertices) {\nthis.addVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor (const e of edges) {\nthis.addEdge(e[0], e[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nsize() {\nreturn this.vertices.length;\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\naddVertex(val) {\nconst n = this.size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nthis.vertices.push(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nconst newRow = [];\nfor (let j = 0; j < n; j++) {\nnewRow.push(0);\n}\nthis.adjMat.push(newRow);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor (const row of this.adjMat) {\nrow.push(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nremoveVertex(index) {\nif (index >= this.size()) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nthis.vertices.splice(index, 1);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nthis.adjMat.splice(index, 1);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor (const row of this.adjMat) {\nrow.splice(index, 1);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\naddEdge(i, j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nthis.adjMat[i][j] = 1;\nthis.adjMat[j][i] = 1;\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nremoveEdge(i, j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\nthis.adjMat[i][j] = 0;\nthis.adjMat[j][i] = 0;\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nprint() {\nconsole.log('\u9876\u70b9\u5217\u8868 = ', this.vertices);\nconsole.log('\u90bb\u63a5\u77e9\u9635 =', this.adjMat);\n}\n}\n
    graph_adjacency_matrix.ts
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nvertices: number[]; // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nadjMat: number[][]; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u51fd\u6570 */\nconstructor(vertices: number[], edges: number[][]) {\nthis.vertices = [];\nthis.adjMat = [];\n// \u6dfb\u52a0\u9876\u70b9\nfor (const val of vertices) {\nthis.addVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor (const e of edges) {\nthis.addEdge(e[0], e[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nsize(): number {\nreturn this.vertices.length;\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\naddVertex(val: number): void {\nconst n: number = this.size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nthis.vertices.push(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nconst newRow: number[] = [];\nfor (let j: number = 0; j < n; j++) {\nnewRow.push(0);\n}\nthis.adjMat.push(newRow);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor (const row of this.adjMat) {\nrow.push(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nremoveVertex(index: number): void {\nif (index >= this.size()) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nthis.vertices.splice(index, 1);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nthis.adjMat.splice(index, 1);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor (const row of this.adjMat) {\nrow.splice(index, 1);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\naddEdge(i: number, j: number): void {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nthis.adjMat[i][j] = 1;\nthis.adjMat[j][i] = 1;\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nremoveEdge(i: number, j: number): void {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\nthrow new RangeError('Index Out Of Bounds Exception');\n}\nthis.adjMat[i][j] = 0;\nthis.adjMat[j][i] = 0;\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nprint(): void {\nconsole.log('\u9876\u70b9\u5217\u8868 = ', this.vertices);\nconsole.log('\u90bb\u63a5\u77e9\u9635 =', this.adjMat);\n}\n}\n
    graph_adjacency_matrix.c
    [class]{graphAdjMat}-[func]{}\n
    graph_adjacency_matrix.cs
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nList<int> vertices;     // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nList<List<int>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u51fd\u6570 */\npublic GraphAdjMat(int[] vertices, int[][] edges) {\nthis.vertices = new List<int>();\nthis.adjMat = new List<List<int>>();\n// \u6dfb\u52a0\u9876\u70b9\nforeach (int val in vertices) {\naddVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nforeach (int[] e in edges) {\naddEdge(e[0], e[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\npublic int size() {\nreturn vertices.Count;\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\npublic void addVertex(int val) {\nint n = size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nvertices.Add(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nList<int> newRow = new List<int>(n);\nfor (int j = 0; j < n; j++) {\nnewRow.Add(0);\n}\nadjMat.Add(newRow);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nforeach (List<int> row in adjMat) {\nrow.Add(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\npublic void removeVertex(int index) {\nif (index >= size())\nthrow new IndexOutOfRangeException();\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nvertices.RemoveAt(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nadjMat.RemoveAt(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nforeach (List<int> row in adjMat) {\nrow.RemoveAt(index);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\npublic void addEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\nthrow new IndexOutOfRangeException();\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nadjMat[i][j] = 1;\nadjMat[j][i] = 1;\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\npublic void removeEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\nthrow new IndexOutOfRangeException();\nadjMat[i][j] = 0;\nadjMat[j][i] = 0;\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\npublic void print() {\nConsole.Write(\"\u9876\u70b9\u5217\u8868 = \");\nPrintUtil.PrintList(vertices);\nConsole.WriteLine(\"\u90bb\u63a5\u77e9\u9635 =\");\nPrintUtil.PrintMatrix(adjMat);\n}\n}\n
    graph_adjacency_matrix.swift
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nprivate var vertices: [Int] // \u9876\u70b9\u5217\u8868\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nprivate var adjMat: [[Int]] // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u65b9\u6cd5 */\ninit(vertices: [Int], edges: [[Int]]) {\nself.vertices = []\nadjMat = []\n// \u6dfb\u52a0\u9876\u70b9\nfor val in vertices {\naddVertex(val: val)\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor e in edges {\naddEdge(i: e[0], j: e[1])\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc size() -> Int {\nvertices.count\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc addVertex(val: Int) {\nlet n = size()\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nvertices.append(val)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nlet newRow = Array(repeating: 0, count: n)\nadjMat.append(newRow)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor i in adjMat.indices {\nadjMat[i].append(0)\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nfunc removeVertex(index: Int) {\nif index >= size() {\nfatalError(\"\u8d8a\u754c\")\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nvertices.remove(at: index)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nadjMat.remove(at: index)\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor i in adjMat.indices {\nadjMat[i].remove(at: index)\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfunc addEdge(i: Int, j: Int) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 || j < 0 || i >= size() || j >= size() || i == j {\nfatalError(\"\u8d8a\u754c\")\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nadjMat[i][j] = 1\nadjMat[j][i] = 1\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfunc removeEdge(i: Int, j: Int) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif i < 0 || j < 0 || i >= size() || j >= size() || i == j {\nfatalError(\"\u8d8a\u754c\")\n}\nadjMat[i][j] = 0\nadjMat[j][i] = 0\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nfunc print() {\nSwift.print(\"\u9876\u70b9\u5217\u8868 = \", terminator: \"\")\nSwift.print(vertices)\nSwift.print(\"\u90bb\u63a5\u77e9\u9635 =\")\nPrintUtil.printMatrix(matrix: adjMat)\n}\n}\n
    graph_adjacency_matrix.zig
    \n
    graph_adjacency_matrix.dart
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\nList<int> vertices = []; // \u9876\u70b9\u5143\u7d20\uff0c\u5143\u7d20\u4ee3\u8868\u201c\u9876\u70b9\u503c\u201d\uff0c\u7d22\u5f15\u4ee3\u8868\u201c\u9876\u70b9\u7d22\u5f15\u201d\nList<List<int>> adjMat = []; //\u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n/* \u6784\u9020\u65b9\u6cd5 */\nGraphAdjMat(List<int> vertices, List<List<int>> edges) {\nthis.vertices = [];\nthis.adjMat = [];\n// \u6dfb\u52a0\u9876\u70b9\nfor (int val in vertices) {\naddVertex(val);\n}\n// \u6dfb\u52a0\u8fb9\n// \u8bf7\u6ce8\u610f\uff0cedges \u5143\u7d20\u4ee3\u8868\u9876\u70b9\u7d22\u5f15\uff0c\u5373\u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nfor (List<int> e in edges) {\naddEdge(e[0], e[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nint size() {\nreturn vertices.length;\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(int val) {\nint n = size();\n// \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\nvertices.add(val);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\nList<int> newRow = List.filled(n, 0, growable: true);\nadjMat.add(newRow);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\nfor (List<int> row in adjMat) {\nrow.add(0);\n}\n}\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(int index) {\nif (index >= size()) {\nthrow IndexError;\n}\n// \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\nvertices.removeAt(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\nadjMat.removeAt(index);\n// \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\nfor (List<int> row in adjMat) {\nrow.removeAt(index);\n}\n}\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid addEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\nthrow IndexError;\n}\n// \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u6cbf\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\nadjMat[i][j] = 1;\nadjMat[j][i] = 1;\n}\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid removeEdge(int i, int j) {\n// \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\nif (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\nthrow IndexError;\n}\nadjMat[i][j] = 0;\nadjMat[j][i] = 0;\n}\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nvoid printAdjMat() {\nprint(\"\u9876\u70b9\u5217\u8868 = $vertices\");\nprint(\"\u90bb\u63a5\u77e9\u9635 = \");\nprintMatrix(adjMat);\n}\n}\n
    "},{"location":"chapter_graph/graph_operations/#922","title":"9.2.2. \u00a0 \u57fa\u4e8e\u90bb\u63a5\u8868\u7684\u5b9e\u73b0","text":"

    \u8bbe\u65e0\u5411\u56fe\u7684\u9876\u70b9\u603b\u6570\u4e3a \\(n\\) \u3001\u8fb9\u603b\u6570\u4e3a \\(m\\) \uff0c\u5219\u6709\uff1a

    • \u6dfb\u52a0\u8fb9\uff1a\u5728\u9876\u70b9\u5bf9\u5e94\u94fe\u8868\u7684\u672b\u5c3e\u6dfb\u52a0\u8fb9\u5373\u53ef\uff0c\u4f7f\u7528 \\(O(1)\\) \u65f6\u95f4\u3002\u56e0\u4e3a\u662f\u65e0\u5411\u56fe\uff0c\u6240\u4ee5\u9700\u8981\u540c\u65f6\u6dfb\u52a0\u4e24\u4e2a\u65b9\u5411\u7684\u8fb9\u3002
    • \u5220\u9664\u8fb9\uff1a\u5728\u9876\u70b9\u5bf9\u5e94\u94fe\u8868\u4e2d\u67e5\u627e\u5e76\u5220\u9664\u6307\u5b9a\u8fb9\uff0c\u4f7f\u7528 \\(O(m)\\) \u65f6\u95f4\u3002\u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u9700\u8981\u540c\u65f6\u5220\u9664\u4e24\u4e2a\u65b9\u5411\u7684\u8fb9\u3002
    • \u6dfb\u52a0\u9876\u70b9\uff1a\u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u94fe\u8868\uff0c\u5e76\u5c06\u65b0\u589e\u9876\u70b9\u4f5c\u4e3a\u94fe\u8868\u5934\u8282\u70b9\uff0c\u4f7f\u7528 \\(O(1)\\) \u65f6\u95f4\u3002
    • \u5220\u9664\u9876\u70b9\uff1a\u9700\u904d\u5386\u6574\u4e2a\u90bb\u63a5\u8868\uff0c\u5220\u9664\u5305\u542b\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u8fb9\uff0c\u4f7f\u7528 \\(O(n + m)\\) \u65f6\u95f4\u3002
    • \u521d\u59cb\u5316\uff1a\u5728\u90bb\u63a5\u8868\u4e2d\u521b\u5efa \\(n\\) \u4e2a\u9876\u70b9\u548c \\(2m\\) \u6761\u8fb9\uff0c\u4f7f\u7528 \\(O(n + m)\\) \u65f6\u95f4\u3002
    \u521d\u59cb\u5316\u90bb\u63a5\u8868\u6dfb\u52a0\u8fb9\u5220\u9664\u8fb9\u6dfb\u52a0\u9876\u70b9\u5220\u9664\u9876\u70b9

    \u4ee5\u4e0b\u662f\u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u56fe\u7684\u4ee3\u7801\u793a\u4f8b\u3002\u7ec6\u5fc3\u7684\u540c\u5b66\u53ef\u80fd\u6ce8\u610f\u5230\uff0c\u6211\u4eec\u5728\u90bb\u63a5\u8868\u4e2d\u4f7f\u7528 Vertex \u8282\u70b9\u7c7b\u6765\u8868\u793a\u9876\u70b9\uff0c\u8fd9\u6837\u505a\u7684\u539f\u56e0\u6709\uff1a

    • \u5982\u679c\u6211\u4eec\u9009\u62e9\u901a\u8fc7\u9876\u70b9\u503c\u6765\u533a\u5206\u4e0d\u540c\u9876\u70b9\uff0c\u90a3\u4e48\u503c\u91cd\u590d\u7684\u9876\u70b9\u5c06\u65e0\u6cd5\u88ab\u533a\u5206\u3002
    • \u5982\u679c\u7c7b\u4f3c\u90bb\u63a5\u77e9\u9635\u90a3\u6837\uff0c\u4f7f\u7528\u9876\u70b9\u5217\u8868\u7d22\u5f15\u6765\u533a\u5206\u4e0d\u540c\u9876\u70b9\u3002\u90a3\u4e48\uff0c\u5047\u8bbe\u6211\u4eec\u60f3\u8981\u5220\u9664\u7d22\u5f15\u4e3a \\(i\\) \u7684\u9876\u70b9\uff0c\u5219\u9700\u8981\u904d\u5386\u6574\u4e2a\u90bb\u63a5\u8868\uff0c\u5c06\u5176\u4e2d \\(> i\\) \u7684\u7d22\u5f15\u5168\u90e8\u51cf \\(1\\) \uff0c\u8fd9\u6837\u64cd\u4f5c\u6548\u7387\u8f83\u4f4e\u3002
    • \u56e0\u6b64\u6211\u4eec\u8003\u8651\u5f15\u5165\u9876\u70b9\u7c7b Vertex \uff0c\u4f7f\u5f97\u6bcf\u4e2a\u9876\u70b9\u90fd\u662f\u552f\u4e00\u7684\u5bf9\u8c61\uff0c\u6b64\u65f6\u5220\u9664\u9876\u70b9\u65f6\u5c31\u65e0\u9700\u6539\u52a8\u5176\u4f59\u9876\u70b9\u4e86\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart graph_adjacency_list.java
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nMap<Vertex, List<Vertex>> adjList;\n/* \u6784\u9020\u65b9\u6cd5 */\npublic GraphAdjList(Vertex[][] edges) {\nthis.adjList = new HashMap<>();\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor (Vertex[] edge : edges) {\naddVertex(edge[0]);\naddVertex(edge[1]);\naddEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\npublic int size() {\nreturn adjList.size();\n}\n/* \u6dfb\u52a0\u8fb9 */\npublic void addEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\nthrow new IllegalArgumentException();\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nadjList.get(vet1).add(vet2);\nadjList.get(vet2).add(vet1);\n}\n/* \u5220\u9664\u8fb9 */\npublic void removeEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\nthrow new IllegalArgumentException();\n// \u5220\u9664\u8fb9 vet1 - vet2\nadjList.get(vet1).remove(vet2);\nadjList.get(vet2).remove(vet1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\npublic void addVertex(Vertex vet) {\nif (adjList.containsKey(vet))\nreturn;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nadjList.put(vet, new ArrayList<>());\n}\n/* \u5220\u9664\u9876\u70b9 */\npublic void removeVertex(Vertex vet) {\nif (!adjList.containsKey(vet))\nthrow new IllegalArgumentException();\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nadjList.remove(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor (List<Vertex> list : adjList.values()) {\nlist.remove(vet);\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\npublic void print() {\nSystem.out.println(\"\u90bb\u63a5\u8868 =\");\nfor (Map.Entry<Vertex, List<Vertex>> pair : adjList.entrySet()) {\nList<Integer> tmp = new ArrayList<>();\nfor (Vertex vertex : pair.getValue())\ntmp.add(vertex.val);\nSystem.out.println(pair.getKey().val + \": \" + tmp + \",\");\n}\n}\n}\n
    graph_adjacency_list.cpp
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\npublic:\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nunordered_map<Vertex *, vector<Vertex *>> adjList;\n/* \u5728 vector \u4e2d\u5220\u9664\u6307\u5b9a\u8282\u70b9 */\nvoid remove(vector<Vertex *> &vec, Vertex *vet) {\nfor (int i = 0; i < vec.size(); i++) {\nif (vec[i] == vet) {\nvec.erase(vec.begin() + i);\nbreak;\n}\n}\n}\n/* \u6784\u9020\u65b9\u6cd5 */\nGraphAdjList(const vector<vector<Vertex *>> &edges) {\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor (const vector<Vertex *> &edge : edges) {\naddVertex(edge[0]);\naddVertex(edge[1]);\naddEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nint size() {\nreturn adjList.size();\n}\n/* \u6dfb\u52a0\u8fb9 */\nvoid addEdge(Vertex *vet1, Vertex *vet2) {\nif (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\nthrow invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nadjList[vet1].push_back(vet2);\nadjList[vet2].push_back(vet1);\n}\n/* \u5220\u9664\u8fb9 */\nvoid removeEdge(Vertex *vet1, Vertex *vet2) {\nif (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\nthrow invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n// \u5220\u9664\u8fb9 vet1 - vet2\nremove(adjList[vet1], vet2);\nremove(adjList[vet2], vet1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(Vertex *vet) {\nif (adjList.count(vet))\nreturn;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nadjList[vet] = vector<Vertex *>();\n}\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(Vertex *vet) {\nif (!adjList.count(vet))\nthrow invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nadjList.erase(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor (auto &adj : adjList) {\nremove(adj.second, vet);\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nvoid print() {\ncout << \"\u90bb\u63a5\u8868 =\" << endl;\nfor (auto &adj : adjList) {\nconst auto &key = adj.first;\nconst auto &vec = adj.second;\ncout << key->val << \": \";\nprintVector(vetsToVals(vec));\n}\n}\n};\n
    graph_adjacency_list.py
    class GraphAdjList:\n\"\"\"\u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\"\"\"\ndef __init__(self, edges: list[list[Vertex]]) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n# \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nself.adj_list = dict[Vertex, Vertex]()\n# \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor edge in edges:\nself.add_vertex(edge[0])\nself.add_vertex(edge[1])\nself.add_edge(edge[0], edge[1])\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u9876\u70b9\u6570\u91cf\"\"\"\nreturn len(self.adj_list)\ndef add_edge(self, vet1: Vertex, vet2: Vertex) -> None:\n\"\"\"\u6dfb\u52a0\u8fb9\"\"\"\nif vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\nraise ValueError()\n# \u6dfb\u52a0\u8fb9 vet1 - vet2\nself.adj_list[vet1].append(vet2)\nself.adj_list[vet2].append(vet1)\ndef remove_edge(self, vet1: Vertex, vet2: Vertex) -> None:\n\"\"\"\u5220\u9664\u8fb9\"\"\"\nif vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\nraise ValueError()\n# \u5220\u9664\u8fb9 vet1 - vet2\nself.adj_list[vet1].remove(vet2)\nself.adj_list[vet2].remove(vet1)\ndef add_vertex(self, vet: Vertex) -> None:\n\"\"\"\u6dfb\u52a0\u9876\u70b9\"\"\"\nif vet in self.adj_list:\nreturn\n# \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nself.adj_list[vet] = []\ndef remove_vertex(self, vet: Vertex) -> None:\n\"\"\"\u5220\u9664\u9876\u70b9\"\"\"\nif vet not in self.adj_list:\nraise ValueError()\n# \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nself.adj_list.pop(vet)\n# \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor vertex in self.adj_list:\nif vet in self.adj_list[vertex]:\nself.adj_list[vertex].remove(vet)\ndef print(self) -> None:\n\"\"\"\u6253\u5370\u90bb\u63a5\u8868\"\"\"\nprint(\"\u90bb\u63a5\u8868 =\")\nfor vertex in self.adj_list:\ntmp = [v.val for v in self.adj_list[vertex]]\nprint(f\"{vertex.val}: {tmp},\")\n
    graph_adjacency_list.go
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\ntype graphAdjList struct {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nadjList map[Vertex][]Vertex\n}\n/* \u6784\u9020\u51fd\u6570 */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\ng := &graphAdjList{\nadjList: make(map[Vertex][]Vertex),\n}\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor _, edge := range edges {\ng.addVertex(edge[0])\ng.addVertex(edge[1])\ng.addEdge(edge[0], edge[1])\n}\nreturn g\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc (g *graphAdjList) size() int {\nreturn len(g.adjList)\n}\n/* \u6dfb\u52a0\u8fb9 */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n_, ok1 := g.adjList[vet1]\n_, ok2 := g.adjList[vet2]\nif !ok1 || !ok2 || vet1 == vet2 {\npanic(\"error\")\n}\n// \u6dfb\u52a0\u8fb9 vet1 - vet2, \u6dfb\u52a0\u533f\u540d struct{},\ng.adjList[vet1] = append(g.adjList[vet1], vet2)\ng.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n/* \u5220\u9664\u8fb9 */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n_, ok1 := g.adjList[vet1]\n_, ok2 := g.adjList[vet2]\nif !ok1 || !ok2 || vet1 == vet2 {\npanic(\"error\")\n}\n// \u5220\u9664\u8fb9 vet1 - vet2\ng.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\ng.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n_, ok := g.adjList[vet]\nif ok {\nreturn\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\ng.adjList[vet] = make([]Vertex, 0)\n}\n/* \u5220\u9664\u9876\u70b9 */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n_, ok := g.adjList[vet]\nif !ok {\npanic(\"error\")\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\ndelete(g.adjList, vet)\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor v, list := range g.adjList {\ng.adjList[v] = DeleteSliceElms(list, vet)\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nfunc (g *graphAdjList) print() {\nvar builder strings.Builder\nfmt.Printf(\"\u90bb\u63a5\u8868 = \\n\")\nfor k, v := range g.adjList {\nbuilder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\nfor _, vet := range v {\nbuilder.WriteString(strconv.Itoa(vet.Val) + \" \")\n}\nfmt.Println(builder.String())\nbuilder.Reset()\n}\n}\n
    graph_adjacency_list.js
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nadjList;\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor(edges) {\nthis.adjList = new Map();\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor (const edge of edges) {\nthis.addVertex(edge[0]);\nthis.addVertex(edge[1]);\nthis.addEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nsize() {\nreturn this.adjList.size;\n}\n/* \u6dfb\u52a0\u8fb9 */\naddEdge(vet1, vet2) {\nif (\n!this.adjList.has(vet1) ||\n!this.adjList.has(vet2) ||\nvet1 === vet2\n) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nthis.adjList.get(vet1).push(vet2);\nthis.adjList.get(vet2).push(vet1);\n}\n/* \u5220\u9664\u8fb9 */\nremoveEdge(vet1, vet2) {\nif (\n!this.adjList.has(vet1) ||\n!this.adjList.has(vet2) ||\nvet1 === vet2\n) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u5220\u9664\u8fb9 vet1 - vet2\nthis.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\nthis.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\naddVertex(vet) {\nif (this.adjList.has(vet)) return;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nthis.adjList.set(vet, []);\n}\n/* \u5220\u9664\u9876\u70b9 */\nremoveVertex(vet) {\nif (!this.adjList.has(vet)) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nthis.adjList.delete(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor (let set of this.adjList.values()) {\nconst index = set.indexOf(vet);\nif (index > -1) {\nset.splice(index, 1);\n}\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nprint() {\nconsole.log('\u90bb\u63a5\u8868 =');\nfor (const [key, value] of this.adjList) {\nconst tmp = [];\nfor (const vertex of value) {\ntmp.push(vertex.val);\n}\nconsole.log(key.val + ': ' + tmp.join());\n}\n}\n}\n
    graph_adjacency_list.ts
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nadjList: Map<Vertex, Vertex[]>;\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor(edges: Vertex[][]) {\nthis.adjList = new Map();\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor (const edge of edges) {\nthis.addVertex(edge[0]);\nthis.addVertex(edge[1]);\nthis.addEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nsize(): number {\nreturn this.adjList.size;\n}\n/* \u6dfb\u52a0\u8fb9 */\naddEdge(vet1: Vertex, vet2: Vertex): void {\nif (\n!this.adjList.has(vet1) ||\n!this.adjList.has(vet2) ||\nvet1 === vet2\n) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nthis.adjList.get(vet1).push(vet2);\nthis.adjList.get(vet2).push(vet1);\n}\n/* \u5220\u9664\u8fb9 */\nremoveEdge(vet1: Vertex, vet2: Vertex): void {\nif (\n!this.adjList.has(vet1) ||\n!this.adjList.has(vet2) ||\nvet1 === vet2\n) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u5220\u9664\u8fb9 vet1 - vet2\nthis.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\nthis.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\naddVertex(vet: Vertex): void {\nif (this.adjList.has(vet)) return;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nthis.adjList.set(vet, []);\n}\n/* \u5220\u9664\u9876\u70b9 */\nremoveVertex(vet: Vertex): void {\nif (!this.adjList.has(vet)) {\nthrow new Error('Illegal Argument Exception');\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nthis.adjList.delete(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor (let set of this.adjList.values()) {\nconst index: number = set.indexOf(vet);\nif (index > -1) {\nset.splice(index, 1);\n}\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nprint(): void {\nconsole.log('\u90bb\u63a5\u8868 =');\nfor (const [key, value] of this.adjList.entries()) {\nconst tmp = [];\nfor (const vertex of value) {\ntmp.push(vertex.val);\n}\nconsole.log(key.val + ': ' + tmp.join());\n}\n}\n}\n
    graph_adjacency_list.c
    [class]{graphAdjList}-[func]{}\n
    graph_adjacency_list.cs
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\npublic Dictionary<Vertex, List<Vertex>> adjList;\n/* \u6784\u9020\u51fd\u6570 */\npublic GraphAdjList(Vertex[][] edges) {\nthis.adjList = new Dictionary<Vertex, List<Vertex>>();\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nforeach (Vertex[] edge in edges) {\naddVertex(edge[0]);\naddVertex(edge[1]);\naddEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\npublic int size() {\nreturn adjList.Count;\n}\n/* \u6dfb\u52a0\u8fb9 */\npublic void addEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\nthrow new InvalidOperationException();\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nadjList[vet1].Add(vet2);\nadjList[vet2].Add(vet1);\n}\n/* \u5220\u9664\u8fb9 */\npublic void removeEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\nthrow new InvalidOperationException();\n// \u5220\u9664\u8fb9 vet1 - vet2\nadjList[vet1].Remove(vet2);\nadjList[vet2].Remove(vet1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\npublic void addVertex(Vertex vet) {\nif (adjList.ContainsKey(vet))\nreturn;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nadjList.Add(vet, new List<Vertex>());\n}\n/* \u5220\u9664\u9876\u70b9 */\npublic void removeVertex(Vertex vet) {\nif (!adjList.ContainsKey(vet))\nthrow new InvalidOperationException();\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nadjList.Remove(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nforeach (List<Vertex> list in adjList.Values) {\nlist.Remove(vet);\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\npublic void print() {\nConsole.WriteLine(\"\u90bb\u63a5\u8868 =\");\nforeach (KeyValuePair<Vertex, List<Vertex>> pair in adjList) {\nList<int> tmp = new List<int>();\nforeach (Vertex vertex in pair.Value)\ntmp.Add(vertex.val);\nConsole.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n}\n}\n}\n
    graph_adjacency_list.swift
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\npublic private(set) var adjList: [Vertex: [Vertex]]\n/* \u6784\u9020\u65b9\u6cd5 */\npublic init(edges: [[Vertex]]) {\nadjList = [:]\n// \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\nfor edge in edges {\naddVertex(vet: edge[0])\naddVertex(vet: edge[1])\naddEdge(vet1: edge[0], vet2: edge[1])\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\npublic func size() -> Int {\nadjList.count\n}\n/* \u6dfb\u52a0\u8fb9 */\npublic func addEdge(vet1: Vertex, vet2: Vertex) {\nif adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\nfatalError(\"\u53c2\u6570\u9519\u8bef\")\n}\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nadjList[vet1]?.append(vet2)\nadjList[vet2]?.append(vet1)\n}\n/* \u5220\u9664\u8fb9 */\npublic func removeEdge(vet1: Vertex, vet2: Vertex) {\nif adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\nfatalError(\"\u53c2\u6570\u9519\u8bef\")\n}\n// \u5220\u9664\u8fb9 vet1 - vet2\nadjList[vet1]?.removeAll(where: { $0 == vet2 })\nadjList[vet2]?.removeAll(where: { $0 == vet1 })\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\npublic func addVertex(vet: Vertex) {\nif adjList[vet] != nil {\nreturn\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nadjList[vet] = []\n}\n/* \u5220\u9664\u9876\u70b9 */\npublic func removeVertex(vet: Vertex) {\nif adjList[vet] == nil {\nfatalError(\"\u53c2\u6570\u9519\u8bef\")\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nadjList.removeValue(forKey: vet)\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nfor key in adjList.keys {\nadjList[key]?.removeAll(where: { $0 == vet })\n}\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\npublic func print() {\nSwift.print(\"\u90bb\u63a5\u8868 =\")\nfor pair in adjList {\nvar tmp: [Int] = []\nfor vertex in pair.value {\ntmp.append(vertex.val)\n}\nSwift.print(\"\\(pair.key.val): \\(tmp),\")\n}\n}\n}\n
    graph_adjacency_list.zig
    [class]{GraphAdjList}-[func]{}\n
    graph_adjacency_list.dart
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n// \u90bb\u63a5\u8868\uff0ckey: \u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nMap<Vertex, List<Vertex>> adjList = {};\n/* \u6784\u9020\u65b9\u6cd5 */\nGraphAdjList(List<List<Vertex>> edges) {\nfor (List<Vertex> edge in edges) {\naddVertex(edge[0]);\naddVertex(edge[1]);\naddEdge(edge[0], edge[1]);\n}\n}\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nint size() {\nreturn adjList.length;\n}\n/* \u6dfb\u52a0\u8fb9 */\nvoid addEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.containsKey(vet1) ||\n!adjList.containsKey(vet2) ||\nvet1 == vet2) {\nthrow ArgumentError;\n}\n// \u6dfb\u52a0\u8fb9 vet1 - vet2\nadjList[vet1]!.add(vet2);\nadjList[vet2]!.add(vet1);\n}\n/* \u5220\u9664\u8fb9 */\nvoid removeEdge(Vertex vet1, Vertex vet2) {\nif (!adjList.containsKey(vet1) ||\n!adjList.containsKey(vet2) ||\nvet1 == vet2) {\nthrow ArgumentError;\n}\n// \u5220\u9664\u8fb9 vet1 - vet2\nadjList[vet1]!.remove(vet2);\nadjList[vet2]!.remove(vet1);\n}\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(Vertex vet) {\nif (adjList.containsKey(vet)) return;\n// \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\nadjList[vet] = [];\n}\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(Vertex vet) {\nif (!adjList.containsKey(vet)) {\nthrow ArgumentError;\n}\n// \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\nadjList.remove(vet);\n// \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\nadjList.forEach((key, value) {\nvalue.remove(vet);\n});\n}\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nvoid printAdjList() {\nprint(\"\u90bb\u63a5\u8868 =\");\nadjList.forEach((key, value) {\nList<int> tmp = [];\nfor (Vertex vertex in value) {\ntmp.add(vertex.val);\n}\nprint(\"${key.val}: $tmp,\");\n});\n}\n}\n
    "},{"location":"chapter_graph/graph_operations/#923","title":"9.2.3. \u00a0 \u6548\u7387\u5bf9\u6bd4","text":"

    \u8bbe\u56fe\u4e2d\u5171\u6709 \\(n\\) \u4e2a\u9876\u70b9\u548c \\(m\\) \u6761\u8fb9\uff0c\u4e0b\u8868\u4e3a\u90bb\u63a5\u77e9\u9635\u548c\u90bb\u63a5\u8868\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u6548\u7387\u5bf9\u6bd4\u3002

    \u90bb\u63a5\u77e9\u9635 \u90bb\u63a5\u8868\uff08\u94fe\u8868\uff09 \u90bb\u63a5\u8868\uff08\u54c8\u5e0c\u8868\uff09 \u5224\u65ad\u662f\u5426\u90bb\u63a5 \\(O(1)\\) \\(O(m)\\) \\(O(1)\\) \u6dfb\u52a0\u8fb9 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) \u5220\u9664\u8fb9 \\(O(1)\\) \\(O(m)\\) \\(O(1)\\) \u6dfb\u52a0\u9876\u70b9 \\(O(n)\\) \\(O(1)\\) \\(O(1)\\) \u5220\u9664\u9876\u70b9 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n)\\) \u5185\u5b58\u7a7a\u95f4\u5360\u7528 \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n + m)\\)

    \u89c2\u5bdf\u4e0a\u8868\uff0c\u4f3c\u4e4e\u90bb\u63a5\u8868\uff08\u54c8\u5e0c\u8868\uff09\u7684\u65f6\u95f4\u4e0e\u7a7a\u95f4\u6548\u7387\u6700\u4f18\u3002\u4f46\u5b9e\u9645\u4e0a\uff0c\u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u64cd\u4f5c\u8fb9\u7684\u6548\u7387\u66f4\u9ad8\uff0c\u53ea\u9700\u8981\u4e00\u6b21\u6570\u7ec4\u8bbf\u95ee\u6216\u8d4b\u503c\u64cd\u4f5c\u5373\u53ef\u3002\u7efc\u5408\u6765\u770b\uff0c\u90bb\u63a5\u77e9\u9635\u4f53\u73b0\u4e86\u201c\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u201d\u7684\u539f\u5219\uff0c\u800c\u90bb\u63a5\u8868\u4f53\u73b0\u4e86\u201c\u4ee5\u65f6\u95f4\u6362\u7a7a\u95f4\u201d\u7684\u539f\u5219\u3002

    "},{"location":"chapter_graph/graph_traversal/","title":"9.3. \u00a0 \u56fe\u7684\u904d\u5386","text":"

    \u56fe\u4e0e\u6811\u7684\u5173\u7cfb

    \u6811\u4ee3\u8868\u7684\u662f\u201c\u4e00\u5bf9\u591a\u201d\u7684\u5173\u7cfb\uff0c\u800c\u56fe\u5219\u5177\u6709\u66f4\u9ad8\u7684\u81ea\u7531\u5ea6\uff0c\u53ef\u4ee5\u8868\u793a\u4efb\u610f\u7684\u201c\u591a\u5bf9\u591a\u201d\u5173\u7cfb\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u628a\u6811\u770b\u4f5c\u662f\u56fe\u7684\u4e00\u79cd\u7279\u4f8b\u3002\u663e\u7136\uff0c\u6811\u7684\u904d\u5386\u64cd\u4f5c\u4e5f\u662f\u56fe\u7684\u904d\u5386\u64cd\u4f5c\u7684\u4e00\u79cd\u7279\u4f8b\uff0c\u5efa\u8bae\u4f60\u5728\u5b66\u4e60\u672c\u7ae0\u8282\u65f6\u878d\u4f1a\u8d2f\u901a\u4e24\u8005\u7684\u6982\u5ff5\u4e0e\u5b9e\u73b0\u65b9\u6cd5\u3002

    \u300c\u56fe\u300d\u548c\u300c\u6811\u300d\u90fd\u662f\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u90fd\u9700\u8981\u4f7f\u7528\u300c\u641c\u7d22\u7b97\u6cd5\u300d\u6765\u5b9e\u73b0\u904d\u5386\u64cd\u4f5c\u3002

    \u4e0e\u6811\u7c7b\u4f3c\uff0c\u56fe\u7684\u904d\u5386\u65b9\u5f0f\u4e5f\u53ef\u5206\u4e3a\u4e24\u79cd\uff0c\u5373\u300c\u5e7f\u5ea6\u4f18\u5148\u904d\u5386 Breadth-First Traversal\u300d\u548c\u300c\u6df1\u5ea6\u4f18\u5148\u904d\u5386 Depth-First Traversal\u300d\uff0c\u4e5f\u79f0\u4e3a\u300c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22 Breadth-First Search\u300d\u548c\u300c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22 Depth-First Search\u300d\uff0c\u7b80\u79f0 BFS \u548c DFS\u3002

    "},{"location":"chapter_graph/graph_traversal/#931","title":"9.3.1. \u00a0 \u5e7f\u5ea6\u4f18\u5148\u904d\u5386","text":"

    \u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u662f\u4e00\u79cd\u7531\u8fd1\u53ca\u8fdc\u7684\u904d\u5386\u65b9\u5f0f\uff0c\u4ece\u8ddd\u79bb\u6700\u8fd1\u7684\u9876\u70b9\u5f00\u59cb\u8bbf\u95ee\uff0c\u5e76\u4e00\u5c42\u5c42\u5411\u5916\u6269\u5f20\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u4ece\u67d0\u4e2a\u9876\u70b9\u51fa\u53d1\uff0c\u5148\u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\uff0c\u7136\u540e\u904d\u5386\u4e0b\u4e00\u4e2a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\uff0c\u4ee5\u6b64\u7c7b\u63a8\uff0c\u76f4\u81f3\u6240\u6709\u9876\u70b9\u8bbf\u95ee\u5b8c\u6bd5\u3002

    Fig. \u56fe\u7684\u5e7f\u5ea6\u4f18\u5148\u904d\u5386

    "},{"location":"chapter_graph/graph_traversal/#_1","title":"\u7b97\u6cd5\u5b9e\u73b0","text":"

    BFS \u901a\u5e38\u501f\u52a9\u300c\u961f\u5217\u300d\u6765\u5b9e\u73b0\u3002\u961f\u5217\u5177\u6709\u201c\u5148\u5165\u5148\u51fa\u201d\u7684\u6027\u8d28\uff0c\u8fd9\u4e0e BFS \u7684\u201c\u7531\u8fd1\u53ca\u8fdc\u201d\u7684\u601d\u60f3\u5f02\u66f2\u540c\u5de5\u3002

    1. \u5c06\u904d\u5386\u8d77\u59cb\u9876\u70b9 startVet \u52a0\u5165\u961f\u5217\uff0c\u5e76\u5f00\u542f\u5faa\u73af\uff1b
    2. \u5728\u5faa\u73af\u7684\u6bcf\u8f6e\u8fed\u4ee3\u4e2d\uff0c\u5f39\u51fa\u961f\u9996\u9876\u70b9\u5e76\u8bb0\u5f55\u8bbf\u95ee\uff0c\u7136\u540e\u5c06\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\u52a0\u5165\u5230\u961f\u5217\u5c3e\u90e8\uff1b
    3. \u5faa\u73af\u6b65\u9aa4 2. \uff0c\u76f4\u5230\u6240\u6709\u9876\u70b9\u88ab\u8bbf\u95ee\u5b8c\u6210\u540e\u7ed3\u675f\uff1b

    \u4e3a\u4e86\u9632\u6b62\u91cd\u590d\u904d\u5386\u9876\u70b9\uff0c\u6211\u4eec\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868 visited \u6765\u8bb0\u5f55\u54ea\u4e9b\u8282\u70b9\u5df2\u88ab\u8bbf\u95ee\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart graph_bfs.java
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nList<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = new ArrayList<>();\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nSet<Vertex> visited = new HashSet<>() {{ add(startVet); }};\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nQueue<Vertex> que = new LinkedList<>() {{ offer(startVet); }};\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (!que.isEmpty()) {\nVertex vet = que.poll(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.add(vet);            // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (Vertex adjVet : graph.adjList.get(vet)) {\nif (visited.contains(adjVet))\ncontinue;        // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nque.offer(adjVet);   // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n
    graph_bfs.cpp
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nvector<Vertex *> graphBFS(GraphAdjList &graph, Vertex *startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nvector<Vertex *> res;\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nunordered_set<Vertex *> visited = {startVet};\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nqueue<Vertex *> que;\nque.push(startVet);\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (!que.empty()) {\nVertex *vet = que.front();\nque.pop();          // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.push_back(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (auto adjVet : graph.adjList[vet]) {\nif (visited.count(adjVet))\ncontinue;            // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nque.push(adjVet);        // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.emplace(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n
    graph_bfs.py
    def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:\n\"\"\"\u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS\"\"\"\n# \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n# \u9876\u70b9\u904d\u5386\u5e8f\u5217\nres = []\n# \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvisited = set[Vertex]([start_vet])\n# \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nque = deque[Vertex]([start_vet])\n# \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile len(que) > 0:\nvet = que.popleft()  # \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.append(vet)  # \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n# \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor adj_vet in graph.adj_list[vet]:\nif adj_vet in visited:\ncontinue  # \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nque.append(adj_vet)  # \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.add(adj_vet)  # \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n# \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res\n
    graph_bfs.go
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunc graphBFS(g *graphAdjList, startVet Vertex) []Vertex {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nres := make([]Vertex, 0)\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvisited := make(map[Vertex]struct{})\nvisited[startVet] = struct{}{}\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS, \u4f7f\u7528\u5207\u7247\u6a21\u62df\u961f\u5217\nqueue := make([]Vertex, 0)\nqueue = append(queue, startVet)\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nfor len(queue) > 0 {\n// \u961f\u9996\u9876\u70b9\u51fa\u961f\nvet := queue[0]\nqueue = queue[1:]\n// \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nres = append(res, vet)\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor _, adjVet := range g.adjList[vet] {\n_, isExist := visited[adjVet]\n// \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nif !isExist {\nqueue = append(queue, adjVet)\nvisited[adjVet] = struct{}{}\n}\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res\n}\n
    graph_bfs.js
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunction graphBFS(graph, startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nconst res = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nconst visited = new Set();\nvisited.add(startVet);\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nconst que = [startVet];\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (que.length) {\nconst vet = que.shift(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (const adjVet of graph.adjList.get(vet) ?? []) {\nif (visited.has(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\nque.push(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n
    graph_bfs.ts
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunction graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nconst res: Vertex[] = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nconst visited: Set<Vertex> = new Set();\nvisited.add(startVet);\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nconst que = [startVet];\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (que.length) {\nconst vet = que.shift(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (const adjVet of graph.adjList.get(vet) ?? []) {\nif (visited.has(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\nque.push(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\nvisited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n
    graph_bfs.c
    [class]{}-[func]{graphBFS}\n
    graph_bfs.cs
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nList<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = new List<Vertex>();\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nHashSet<Vertex> visited = new HashSet<Vertex>() { startVet };\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nQueue<Vertex> que = new Queue<Vertex>();\nque.Enqueue(startVet);\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (que.Count > 0) {\nVertex vet = que.Dequeue(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.Add(vet);               // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nforeach (Vertex adjVet in graph.adjList[vet]) {\nif (visited.Contains(adjVet)) {\ncontinue;          // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\nque.Enqueue(adjVet);   // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.Add(adjVet);   // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n
    graph_bfs.swift
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunc graphBFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nvar res: [Vertex] = []\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvar visited: Set<Vertex> = [startVet]\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nvar que: [Vertex] = [startVet]\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile !que.isEmpty {\nlet vet = que.removeFirst() // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.append(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor adjVet in graph.adjList[vet] ?? [] {\nif visited.contains(adjVet) {\ncontinue // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\nque.append(adjVet) // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.insert(adjVet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res\n}\n
    graph_bfs.zig
    [class]{}-[func]{graphBFS}\n
    graph_bfs.dart
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 BFS */\nList<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nSet<Vertex> visited = {};\nvisited.add(startVet);\n// \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\nQueue<Vertex> que = Queue();\nque.add(startVet);\n// \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\nwhile (que.isNotEmpty) {\nVertex vet = que.removeFirst(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\nres.add(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (Vertex adjVet in graph.adjList[vet]!) {\nif (visited.contains(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\nque.add(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\nvisited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n}\n}\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res;\n}\n

    \u4ee3\u7801\u76f8\u5bf9\u62bd\u8c61\uff0c\u5efa\u8bae\u5bf9\u7167\u4ee5\u4e0b\u52a8\u753b\u56fe\u793a\u6765\u52a0\u6df1\u7406\u89e3\u3002

    <1><2><3><4><5><6><7><8><9><10><11>

    \u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u7684\u5e8f\u5217\u662f\u5426\u552f\u4e00\uff1f

    \u4e0d\u552f\u4e00\u3002\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u53ea\u8981\u6c42\u6309\u201c\u7531\u8fd1\u53ca\u8fdc\u201d\u7684\u987a\u5e8f\u904d\u5386\uff0c\u800c\u591a\u4e2a\u76f8\u540c\u8ddd\u79bb\u7684\u9876\u70b9\u7684\u904d\u5386\u987a\u5e8f\u662f\u5141\u8bb8\u88ab\u4efb\u610f\u6253\u4e71\u7684\u3002\u4ee5\u4e0a\u56fe\u4e3a\u4f8b\uff0c\u9876\u70b9 \\(1\\) , \\(3\\) \u7684\u8bbf\u95ee\u987a\u5e8f\u53ef\u4ee5\u4ea4\u6362\u3001\u9876\u70b9 \\(2\\) , \\(4\\) , \\(6\\) \u7684\u8bbf\u95ee\u987a\u5e8f\u4e5f\u53ef\u4ee5\u4efb\u610f\u4ea4\u6362\u3002

    "},{"location":"chapter_graph/graph_traversal/#_2","title":"\u590d\u6742\u5ea6\u5206\u6790","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\uff1a \u6240\u6709\u9876\u70b9\u90fd\u4f1a\u5165\u961f\u5e76\u51fa\u961f\u4e00\u6b21\uff0c\u4f7f\u7528 \\(O(|V|)\\) \u65f6\u95f4\uff1b\u5728\u904d\u5386\u90bb\u63a5\u9876\u70b9\u7684\u8fc7\u7a0b\u4e2d\uff0c\u7531\u4e8e\u662f\u65e0\u5411\u56fe\uff0c\u56e0\u6b64\u6240\u6709\u8fb9\u90fd\u4f1a\u88ab\u8bbf\u95ee \\(2\\) \u6b21\uff0c\u4f7f\u7528 \\(O(2|E|)\\) \u65f6\u95f4\uff1b\u603b\u4f53\u4f7f\u7528 \\(O(|V| + |E|)\\) \u65f6\u95f4\u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\uff1a \u5217\u8868 res \uff0c\u54c8\u5e0c\u8868 visited \uff0c\u961f\u5217 que \u4e2d\u7684\u9876\u70b9\u6570\u91cf\u6700\u591a\u4e3a \\(|V|\\) \uff0c\u4f7f\u7528 \\(O(|V|)\\) \u7a7a\u95f4\u3002

    "},{"location":"chapter_graph/graph_traversal/#932","title":"9.3.2. \u00a0 \u6df1\u5ea6\u4f18\u5148\u904d\u5386","text":"

    \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u662f\u4e00\u79cd\u4f18\u5148\u8d70\u5230\u5e95\u3001\u65e0\u8def\u53ef\u8d70\u518d\u56de\u5934\u7684\u904d\u5386\u65b9\u5f0f\u3002\u5177\u4f53\u5730\uff0c\u4ece\u67d0\u4e2a\u9876\u70b9\u51fa\u53d1\uff0c\u8bbf\u95ee\u5f53\u524d\u9876\u70b9\u7684\u67d0\u4e2a\u90bb\u63a5\u9876\u70b9\uff0c\u76f4\u5230\u8d70\u5230\u5c3d\u5934\u65f6\u8fd4\u56de\uff0c\u518d\u7ee7\u7eed\u8d70\u5230\u5c3d\u5934\u5e76\u8fd4\u56de\uff0c\u4ee5\u6b64\u7c7b\u63a8\uff0c\u76f4\u81f3\u6240\u6709\u9876\u70b9\u904d\u5386\u5b8c\u6210\u3002

    Fig. \u56fe\u7684\u6df1\u5ea6\u4f18\u5148\u904d\u5386

    "},{"location":"chapter_graph/graph_traversal/#_3","title":"\u7b97\u6cd5\u5b9e\u73b0","text":"

    \u8fd9\u79cd\u201c\u8d70\u5230\u5c3d\u5934 + \u56de\u6eaf\u201d\u7684\u7b97\u6cd5\u5f62\u5f0f\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u6765\u5b9e\u73b0\u3002\u4e0e BFS \u7c7b\u4f3c\uff0c\u5728 DFS \u4e2d\u6211\u4eec\u4e5f\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868 visited \u6765\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\uff0c\u4ee5\u907f\u514d\u91cd\u590d\u8bbf\u95ee\u9876\u70b9\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart graph_dfs.java
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {\nres.add(vet);     // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (Vertex adjVet : graph.adjList.get(vet)) {\nif (visited.contains(adjVet))\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nList<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = new ArrayList<>();\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nSet<Vertex> visited = new HashSet<>();\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n
    graph_dfs.cpp
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *> &res, Vertex *vet) {\nres.push_back(vet);   // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.emplace(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (Vertex *adjVet : graph.adjList[vet]) {\nif (visited.count(adjVet))\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nvector<Vertex *> graphDFS(GraphAdjList &graph, Vertex *startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nvector<Vertex *> res;\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nunordered_set<Vertex *> visited;\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n
    graph_dfs.py
    def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n\"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570\"\"\"\nres.append(vet)  # \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.add(vet)  # \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n# \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor adjVet in graph.adj_list[vet]:\nif adjVet in visited:\ncontinue  # \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n# \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet)\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:\n\"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS\"\"\"\n# \u9876\u70b9\u904d\u5386\u5e8f\u5217\nres = []\n# \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvisited = set[Vertex]()\ndfs(graph, visited, res, start_vet)\nreturn res\n
    graph_dfs.go
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nfunc dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {\n// append \u64cd\u4f5c\u4f1a\u8fd4\u56de\u65b0\u7684\u7684\u5f15\u7528\uff0c\u5fc5\u987b\u8ba9\u539f\u5f15\u7528\u91cd\u65b0\u8d4b\u503c\u4e3a\u65b0slice\u7684\u5f15\u7528\n*res = append(*res, vet)\nvisited[vet] = struct{}{}\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor _, adjVet := range g.adjList[vet] {\n_, isExist := visited[adjVet]\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\nif !isExist {\ndfs(g, visited, res, adjVet)\n}\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunc graphDFS(g *graphAdjList, startVet Vertex) []Vertex {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nres := make([]Vertex, 0)\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvisited := make(map[Vertex]struct{})\ndfs(g, visited, &res, startVet)\n// \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\nreturn res\n}\n
    graph_dfs.js
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunction dfs(graph, visited, res, vet) {\nres.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (const adjVet of graph.adjList.get(vet)) {\nif (visited.has(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunction graphDFS(graph, startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nconst res = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nconst visited = new Set();\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n
    graph_dfs.ts
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nfunction dfs(\ngraph: GraphAdjList,\nvisited: Set<Vertex>,\nres: Vertex[],\nvet: Vertex\n): void {\nres.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (const adjVet of graph.adjList.get(vet)) {\nif (visited.has(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunction graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nconst res: Vertex[] = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nconst visited: Set<Vertex> = new Set();\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n
    graph_dfs.c
    [class]{}-[func]{dfs}\n[class]{}-[func]{graphDFS}\n
    graph_dfs.cs
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet) {\nres.Add(vet);     // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.Add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nforeach (Vertex adjVet in graph.adjList[vet]) {\nif (visited.Contains(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9                             \n}\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nList<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = new List<Vertex>();\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nHashSet<Vertex> visited = new HashSet<Vertex>();\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n
    graph_dfs.swift
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nfunc dfs(graph: GraphAdjList, visited: inout Set<Vertex>, res: inout [Vertex], vet: Vertex) {\nres.append(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.insert(vet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor adjVet in graph.adjList[vet] ?? [] {\nif visited.contains(adjVet) {\ncontinue // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph: graph, visited: &visited, res: &res, vet: adjVet)\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\n// \u4f7f\u7528\u90bb\u63a5\u8868\u6765\u8868\u793a\u56fe\uff0c\u4ee5\u4fbf\u83b7\u53d6\u6307\u5b9a\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfunc graphDFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nvar res: [Vertex] = []\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nvar visited: Set<Vertex> = []\ndfs(graph: graph, visited: &visited, res: &res, vet: startVet)\nreturn res\n}\n
    graph_dfs.zig
    [class]{}-[func]{dfs}\n[class]{}-[func]{graphDFS}\n
    graph_dfs.dart
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS \u8f85\u52a9\u51fd\u6570 */\nvoid dfs(\nGraphAdjList graph,\nSet<Vertex> visited,\nList<Vertex> res,\nVertex vet,\n) {\nres.add(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\nvisited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n// \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\nfor (Vertex adjVet in graph.adjList[vet]!) {\nif (visited.contains(adjVet)) {\ncontinue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n}\n// \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\ndfs(graph, visited, res, adjVet);\n}\n}\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 DFS */\nList<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {\n// \u9876\u70b9\u904d\u5386\u5e8f\u5217\nList<Vertex> res = [];\n// \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\nSet<Vertex> visited = {};\ndfs(graph, visited, res, startVet);\nreturn res;\n}\n

    \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u7684\u7b97\u6cd5\u6d41\u7a0b\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5176\u4e2d\uff1a

    • \u76f4\u865a\u7ebf\u4ee3\u8868\u5411\u4e0b\u9012\u63a8\uff0c\u8868\u793a\u5f00\u542f\u4e86\u4e00\u4e2a\u65b0\u7684\u9012\u5f52\u65b9\u6cd5\u6765\u8bbf\u95ee\u65b0\u9876\u70b9\uff1b
    • \u66f2\u865a\u7ebf\u4ee3\u8868\u5411\u4e0a\u56de\u6eaf\uff0c\u8868\u793a\u6b64\u9012\u5f52\u65b9\u6cd5\u5df2\u7ecf\u8fd4\u56de\uff0c\u56de\u6eaf\u5230\u4e86\u5f00\u542f\u6b64\u9012\u5f52\u65b9\u6cd5\u7684\u4f4d\u7f6e\uff1b

    \u4e3a\u4e86\u52a0\u6df1\u7406\u89e3\uff0c\u5efa\u8bae\u5c06\u56fe\u793a\u4e0e\u4ee3\u7801\u7ed3\u5408\u8d77\u6765\uff0c\u5728\u8111\u4e2d\uff08\u6216\u8005\u7528\u7b14\u753b\u4e0b\u6765\uff09\u6a21\u62df\u6574\u4e2a DFS \u8fc7\u7a0b\uff0c\u5305\u62ec\u6bcf\u4e2a\u9012\u5f52\u65b9\u6cd5\u4f55\u65f6\u5f00\u542f\u3001\u4f55\u65f6\u8fd4\u56de\u3002

    <1><2><3><4><5><6><7><8><9><10><11>

    \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u7684\u5e8f\u5217\u662f\u5426\u552f\u4e00\uff1f

    \u4e0e\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u7c7b\u4f3c\uff0c\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u5e8f\u5217\u7684\u987a\u5e8f\u4e5f\u4e0d\u662f\u552f\u4e00\u7684\u3002\u7ed9\u5b9a\u67d0\u9876\u70b9\uff0c\u5148\u5f80\u54ea\u4e2a\u65b9\u5411\u63a2\u7d22\u90fd\u53ef\u4ee5\uff0c\u5373\u90bb\u63a5\u9876\u70b9\u7684\u987a\u5e8f\u53ef\u4ee5\u4efb\u610f\u6253\u4e71\uff0c\u90fd\u662f\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u3002

    \u4ee5\u6811\u7684\u904d\u5386\u4e3a\u4f8b\uff0c\u201c\u6839 \\(\\rightarrow\\) \u5de6 \\(\\rightarrow\\) \u53f3\u201d\u3001\u201c\u5de6 \\(\\rightarrow\\) \u6839 \\(\\rightarrow\\) \u53f3\u201d\u3001\u201c\u5de6 \\(\\rightarrow\\) \u53f3 \\(\\rightarrow\\) \u6839\u201d\u5206\u522b\u5bf9\u5e94\u524d\u5e8f\u3001\u4e2d\u5e8f\u3001\u540e\u5e8f\u904d\u5386\uff0c\u5b83\u4eec\u5c55\u793a\u4e86\u4e09\u79cd\u4e0d\u540c\u7684\u904d\u5386\u4f18\u5148\u7ea7\uff0c\u7136\u800c\u8fd9\u4e09\u8005\u90fd\u5c5e\u4e8e\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u3002

    "},{"location":"chapter_graph/graph_traversal/#_4","title":"\u590d\u6742\u5ea6\u5206\u6790","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\uff1a \u6240\u6709\u9876\u70b9\u90fd\u4f1a\u88ab\u8bbf\u95ee \\(1\\) \u6b21\uff0c\u4f7f\u7528 \\(O(|V|)\\) \u65f6\u95f4\uff1b\u6240\u6709\u8fb9\u90fd\u4f1a\u88ab\u8bbf\u95ee \\(2\\) \u6b21\uff0c\u4f7f\u7528 \\(O(2|E|)\\) \u65f6\u95f4\uff1b\u603b\u4f53\u4f7f\u7528 \\(O(|V| + |E|)\\) \u65f6\u95f4\u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\uff1a \u5217\u8868 res \uff0c\u54c8\u5e0c\u8868 visited \u9876\u70b9\u6570\u91cf\u6700\u591a\u4e3a \\(|V|\\) \uff0c\u9012\u5f52\u6df1\u5ea6\u6700\u5927\u4e3a \\(|V|\\) \uff0c\u56e0\u6b64\u4f7f\u7528 \\(O(|V|)\\) \u7a7a\u95f4\u3002

    "},{"location":"chapter_graph/summary/","title":"9.4. \u00a0 \u5c0f\u7ed3","text":"
    • \u56fe\u7531\u9876\u70b9\u548c\u8fb9\u7ec4\u6210\uff0c\u53ef\u4ee5\u88ab\u8868\u793a\u4e3a\u4e00\u7ec4\u9876\u70b9\u548c\u4e00\u7ec4\u8fb9\u6784\u6210\u7684\u96c6\u5408\u3002
    • \u76f8\u8f83\u4e8e\u7ebf\u6027\u5173\u7cfb\uff08\u94fe\u8868\uff09\u548c\u5206\u6cbb\u5173\u7cfb\uff08\u6811\uff09\uff0c\u7f51\u7edc\u5173\u7cfb\uff08\u56fe\uff09\u5177\u6709\u66f4\u9ad8\u7684\u81ea\u7531\u5ea6\uff0c\u56e0\u800c\u66f4\u4e3a\u590d\u6742\u3002
    • \u6709\u5411\u56fe\u7684\u8fb9\u5177\u6709\u65b9\u5411\u6027\uff0c\u8fde\u901a\u56fe\u4e2d\u7684\u4efb\u610f\u9876\u70b9\u5747\u53ef\u8fbe\uff0c\u6709\u6743\u56fe\u7684\u6bcf\u6761\u8fb9\u90fd\u5305\u542b\u6743\u91cd\u53d8\u91cf\u3002
    • \u90bb\u63a5\u77e9\u9635\u5229\u7528\u77e9\u9635\u6765\u8868\u793a\u56fe\uff0c\u6bcf\u4e00\u884c\uff08\u5217\uff09\u4ee3\u8868\u4e00\u4e2a\u9876\u70b9\uff0c\u77e9\u9635\u5143\u7d20\u4ee3\u8868\u8fb9\uff0c\u7528 \\(1\\) \u6216 \\(0\\) \u8868\u793a\u4e24\u4e2a\u9876\u70b9\u4e4b\u95f4\u6709\u8fb9\u6216\u65e0\u8fb9\u3002\u90bb\u63a5\u77e9\u9635\u5728\u589e\u5220\u67e5\u64cd\u4f5c\u4e0a\u6548\u7387\u5f88\u9ad8\uff0c\u4f46\u7a7a\u95f4\u5360\u7528\u8f83\u591a\u3002
    • \u90bb\u63a5\u8868\u4f7f\u7528\u591a\u4e2a\u94fe\u8868\u6765\u8868\u793a\u56fe\uff0c\u7b2c \\(i\\) \u6761\u94fe\u8868\u5bf9\u5e94\u9876\u70b9 \\(i\\) \uff0c\u5176\u4e2d\u5b58\u50a8\u4e86\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\u3002\u90bb\u63a5\u8868\u76f8\u5bf9\u4e8e\u90bb\u63a5\u77e9\u9635\u66f4\u52a0\u8282\u7701\u7a7a\u95f4\uff0c\u4f46\u7531\u4e8e\u9700\u8981\u904d\u5386\u94fe\u8868\u6765\u67e5\u627e\u8fb9\uff0c\u65f6\u95f4\u6548\u7387\u8f83\u4f4e\u3002
    • \u5f53\u90bb\u63a5\u8868\u4e2d\u7684\u94fe\u8868\u8fc7\u957f\u65f6\uff0c\u53ef\u4ee5\u5c06\u5176\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811\u6216\u54c8\u5e0c\u8868\uff0c\u4ece\u800c\u63d0\u5347\u67e5\u8be2\u6548\u7387\u3002
    • \u4ece\u7b97\u6cd5\u601d\u60f3\u89d2\u5ea6\u5206\u6790\uff0c\u90bb\u63a5\u77e9\u9635\u4f53\u73b0\u201c\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u201d\uff0c\u90bb\u63a5\u8868\u4f53\u73b0\u201c\u4ee5\u65f6\u95f4\u6362\u7a7a\u95f4\u201d\u3002
    • \u56fe\u53ef\u7528\u4e8e\u5efa\u6a21\u5404\u7c7b\u73b0\u5b9e\u7cfb\u7edf\uff0c\u5982\u793e\u4ea4\u7f51\u7edc\u3001\u5730\u94c1\u7ebf\u8def\u7b49\u3002
    • \u6811\u662f\u56fe\u7684\u4e00\u79cd\u7279\u4f8b\uff0c\u6811\u7684\u904d\u5386\u4e5f\u662f\u56fe\u7684\u904d\u5386\u7684\u4e00\u79cd\u7279\u4f8b\u3002
    • \u56fe\u7684\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u662f\u4e00\u79cd\u7531\u8fd1\u53ca\u8fdc\u3001\u5c42\u5c42\u6269\u5f20\u7684\u641c\u7d22\u65b9\u5f0f\uff0c\u901a\u5e38\u501f\u52a9\u961f\u5217\u5b9e\u73b0\u3002
    • \u56fe\u7684\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u662f\u4e00\u79cd\u4f18\u5148\u8d70\u5230\u5e95\u3001\u65e0\u8def\u53ef\u8d70\u65f6\u518d\u56de\u6eaf\u7684\u641c\u7d22\u65b9\u5f0f\uff0c\u5e38\u57fa\u4e8e\u9012\u5f52\u6765\u5b9e\u73b0\u3002
    "},{"location":"chapter_graph/summary/#941-q-a","title":"9.4.1. \u00a0 Q & A","text":"

    \u8def\u5f84\u7684\u5b9a\u4e49\u662f\u9876\u70b9\u5e8f\u5217\u8fd8\u662f\u8fb9\u5e8f\u5217\uff1f

    \u7ef4\u57fa\u767e\u79d1\u4e0a\u4e0d\u540c\u8bed\u8a00\u7248\u672c\u7684\u5b9a\u4e49\u4e0d\u4e00\u81f4\uff1a\u82f1\u6587\u7248\u662f\u201c\u8def\u5f84\u662f\u4e00\u4e2a\u8fb9\u5e8f\u5217\u201d\uff0c\u800c\u4e2d\u6587\u7248\u662f\u201c\u8def\u5f84\u662f\u4e00\u4e2a\u9876\u70b9\u5e8f\u5217\u201d\u3002\u4ee5\u4e0b\u662f\u82f1\u6587\u7248\u539f\u6587\uff1aIn graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices. \u5728\u672c\u6587\u4e2d\uff0c\u8def\u5f84\u88ab\u8ba4\u4e3a\u662f\u4e00\u4e2a\u8fb9\u5e8f\u5217\uff0c\u800c\u4e0d\u662f\u4e00\u4e2a\u9876\u70b9\u5e8f\u5217\u3002\u8fd9\u662f\u56e0\u4e3a\u4e24\u4e2a\u9876\u70b9\u4e4b\u95f4\u53ef\u80fd\u5b58\u5728\u591a\u6761\u8fb9\u8fde\u63a5\uff0c\u6b64\u65f6\u6bcf\u6761\u8fb9\u90fd\u5bf9\u5e94\u4e00\u6761\u8def\u5f84\u3002

    \u975e\u8fde\u901a\u56fe\u4e2d\uff0c\u662f\u5426\u4f1a\u6709\u65e0\u6cd5\u904d\u5386\u5230\u7684\u70b9\uff1f

    \u5728\u975e\u8fde\u901a\u56fe\u4e2d\uff0c\u4ece\u67d0\u4e2a\u9876\u70b9\u51fa\u53d1\uff0c\u81f3\u5c11\u6709\u4e00\u4e2a\u9876\u70b9\u65e0\u6cd5\u5230\u8fbe\u3002\u904d\u5386\u975e\u8fde\u901a\u56fe\u9700\u8981\u8bbe\u7f6e\u591a\u4e2a\u8d77\u70b9\uff0c\u4ee5\u904d\u5386\u5230\u56fe\u7684\u6240\u6709\u8fde\u901a\u5206\u91cf\u3002

    \u5728\u90bb\u63a5\u8868\u4e2d\uff0c\u201c\u4e0e\u8be5\u9876\u70b9\u76f8\u8fde\u7684\u6240\u6709\u9876\u70b9\u201d\u7684\u9876\u70b9\u987a\u5e8f\u662f\u5426\u6709\u8981\u6c42\uff1f

    \u53ef\u4ee5\u662f\u4efb\u610f\u987a\u5e8f\u3002\u4f46\u5728\u5b9e\u9645\u5e94\u7528\u4e2d\uff0c\u53ef\u80fd\u4f1a\u9700\u8981\u6309\u7167\u6307\u5b9a\u89c4\u5219\u6765\u6392\u5e8f\uff0c\u6bd4\u5982\u6309\u7167\u9876\u70b9\u6dfb\u52a0\u7684\u6b21\u5e8f\u3001\u6216\u8005\u6309\u7167\u9876\u70b9\u503c\u5927\u5c0f\u7684\u987a\u5e8f\u7b49\u7b49\uff0c\u8fd9\u6837\u53ef\u4ee5\u6709\u52a9\u4e8e\u5feb\u901f\u67e5\u627e\u201c\u5e26\u6709\u67d0\u79cd\u6781\u503c\u201d\u7684\u9876\u70b9\u3002

    "},{"location":"chapter_hashing/","title":"6. \u00a0 \u6563\u5217\u8868","text":""},{"location":"chapter_hashing/hash_algorithm/","title":"6.3. \u00a0 \u54c8\u5e0c\u7b97\u6cd5","text":"

    \u5728\u4e0a\u4e24\u8282\u4e2d\uff0c\u6211\u4eec\u4e86\u89e3\u4e86\u54c8\u5e0c\u8868\u7684\u5de5\u4f5c\u539f\u7406\uff0c\u4ee5\u53ca\u54c8\u5e0c\u51b2\u7a81\u7684\u5904\u7406\u65b9\u6cd5\u3002\u7136\u800c\uff0c\u65e0\u8bba\u662f\u5f00\u653e\u5bfb\u5740\u8fd8\u662f\u94fe\u5730\u5740\u6cd5\uff0c\u5b83\u4eec\u53ea\u80fd\u4fdd\u8bc1\u54c8\u5e0c\u8868\u53ef\u4ee5\u5728\u53d1\u751f\u51b2\u7a81\u65f6\u6b63\u5e38\u5de5\u4f5c\uff0c\u4f46\u65e0\u6cd5\u51cf\u5c11\u54c8\u5e0c\u51b2\u7a81\u7684\u53d1\u751f\u3002

    \u5982\u679c\u54c8\u5e0c\u51b2\u7a81\u8fc7\u4e8e\u9891\u7e41\uff0c\u54c8\u5e0c\u8868\u7684\u6027\u80fd\u5219\u4f1a\u6025\u5267\u52a3\u5316\u3002\u4f8b\u5982\u5bf9\u4e8e\u94fe\u5730\u5740\u54c8\u5e0c\u8868\uff0c\u7406\u60f3\u60c5\u51b5\u4e0b\u952e\u503c\u5bf9\u5e73\u5747\u5206\u5e03\u5728\u5404\u4e2a\u6876\u4e2d\uff0c\u8fbe\u5230\u6700\u597d\u7684\u67e5\u8be2\u6548\u7387\uff1b\u6700\u5dee\u60c5\u51b5\u4e0b\u5168\u90e8\u952e\u503c\u90fd\u88ab\u5b58\u50a8\u5230\u540c\u4e00\u4e2a\u6876\u4e2d\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u9000\u5316\u81f3 \\(O(n)\\) \u3002

    Fig. \u54c8\u5e0c\u51b2\u7a81\u7684\u6700\u4f73\u4e0e\u6700\u5dee\u60c5\u51b5

    \u952e\u503c\u5bf9\u7684\u5206\u5e03\u60c5\u51b5\u662f\u7531\u54c8\u5e0c\u51fd\u6570\u51b3\u5b9a\u7684\u3002\u56de\u5fc6\u54c8\u5e0c\u51fd\u6570\u7684\u8ba1\u7b97\u6b65\u9aa4\uff0c\u5148\u8ba1\u7b97\u54c8\u5e0c\u503c\uff0c\u518d\u5bf9\u6570\u7ec4\u957f\u5ea6\u53d6\u6a21\uff1a

    index = hash(key) % capacity\n

    \u89c2\u5bdf\u4ee5\u4e0a\u516c\u5f0f\uff0c\u5f53\u54c8\u5e0c\u8868\u5bb9\u91cf capacity \u56fa\u5b9a\u65f6\uff0c\u54c8\u5e0c\u7b97\u6cd5 hash() \u51b3\u5b9a\u4e86\u8f93\u51fa\u503c\uff0c\u8fdb\u800c\u51b3\u5b9a\u4e86\u952e\u503c\u5bf9\u5728\u54c8\u5e0c\u8868\u4e2d\u7684\u5206\u5e03\u3002\u56e0\u6b64\uff0c\u4e3a\u4e86\u51cf\u5c0f\u54c8\u5e0c\u51b2\u7a81\u7684\u53d1\u751f\u6982\u7387\uff0c\u6211\u4eec\u9700\u8981\u5c06\u6ce8\u610f\u529b\u96c6\u4e2d\u5728\u54c8\u5e0c\u7b97\u6cd5 hash() \u7684\u8bbe\u8ba1\u4e0a\u3002

    "},{"location":"chapter_hashing/hash_algorithm/#631","title":"6.3.1. \u00a0 \u54c8\u5e0c\u7b97\u6cd5\u7684\u76ee\u6807","text":"

    \u4e3a\u4e86\u5728\u7f16\u7a0b\u8bed\u8a00\u4e2d\u5b9e\u73b0\u201c\u65e2\u5feb\u53c8\u7a33\u201d\u7684\u54c8\u5e0c\u8868\u6570\u636e\u7ed3\u6784\uff0c\u54c8\u5e0c\u7b97\u6cd5\u5e94\u5305\u542b\u4ee5\u4e0b\u7279\u70b9\uff1a

    • \u786e\u5b9a\u6027\uff1a\u5bf9\u4e8e\u76f8\u540c\u7684\u8f93\u5165\uff0c\u54c8\u5e0c\u7b97\u6cd5\u5e94\u59cb\u7ec8\u4ea7\u751f\u76f8\u540c\u7684\u8f93\u51fa\u3002\u8fd9\u6837\u624d\u80fd\u786e\u4fdd\u54c8\u5e0c\u8868\u662f\u53ef\u9760\u7684\u3002
    • \u6548\u7387\u9ad8\uff1a\u8ba1\u7b97\u54c8\u5e0c\u503c\u7684\u8fc7\u7a0b\u5e94\u8be5\u8db3\u591f\u5feb\u3002\u8ba1\u7b97\u5f00\u9500\u8d8a\u5c0f\uff0c\u54c8\u5e0c\u8868\u7684\u5b9e\u7528\u6027\u8d8a\u9ad8\u3002
    • \u5747\u5300\u5206\u5e03\uff1a\u54c8\u5e0c\u7b97\u6cd5\u5e94\u4f7f\u5f97\u952e\u503c\u5bf9\u5e73\u5747\u5206\u5e03\u5728\u54c8\u5e0c\u8868\u4e2d\u3002\u5206\u5e03\u8d8a\u5e73\u5747\uff0c\u54c8\u5e0c\u51b2\u7a81\u7684\u6982\u7387\u5c31\u8d8a\u4f4e\u3002

    \u5b9e\u9645\u4e0a\uff0c\u54c8\u5e0c\u7b97\u6cd5\u9664\u4e86\u53ef\u4ee5\u7528\u4e8e\u5b9e\u73b0\u54c8\u5e0c\u8868\uff0c\u8fd8\u5e7f\u6cdb\u5e94\u7528\u4e8e\u5176\u4ed6\u9886\u57df\u4e2d\uff0c\u5305\u62ec\uff1a

    • \u5bc6\u7801\u5b58\u50a8\uff1a\u4e3a\u4e86\u4fdd\u62a4\u7528\u6237\u5bc6\u7801\u7684\u5b89\u5168\uff0c\u7cfb\u7edf\u901a\u5e38\u4e0d\u4f1a\u76f4\u63a5\u5b58\u50a8\u7528\u6237\u7684\u660e\u6587\u5bc6\u7801\uff0c\u800c\u662f\u5b58\u50a8\u5bc6\u7801\u7684\u54c8\u5e0c\u503c\u3002\u5f53\u7528\u6237\u8f93\u5165\u5bc6\u7801\u65f6\uff0c\u7cfb\u7edf\u4f1a\u5bf9\u8f93\u5165\u7684\u5bc6\u7801\u8ba1\u7b97\u54c8\u5e0c\u503c\uff0c\u7136\u540e\u4e0e\u5b58\u50a8\u7684\u54c8\u5e0c\u503c\u8fdb\u884c\u6bd4\u8f83\u3002\u5982\u679c\u4e24\u8005\u5339\u914d\uff0c\u90a3\u4e48\u5bc6\u7801\u5c31\u88ab\u89c6\u4e3a\u6b63\u786e\u3002
    • \u6570\u636e\u5b8c\u6574\u6027\u68c0\u67e5\uff1a\u6570\u636e\u53d1\u9001\u65b9\u53ef\u4ee5\u8ba1\u7b97\u6570\u636e\u7684\u54c8\u5e0c\u503c\u5e76\u5c06\u5176\u4e00\u540c\u53d1\u9001\uff1b\u63a5\u6536\u65b9\u53ef\u4ee5\u91cd\u65b0\u8ba1\u7b97\u63a5\u6536\u5230\u7684\u6570\u636e\u7684\u54c8\u5e0c\u503c\uff0c\u5e76\u4e0e\u63a5\u6536\u5230\u7684\u54c8\u5e0c\u503c\u8fdb\u884c\u6bd4\u8f83\u3002\u5982\u679c\u4e24\u8005\u5339\u914d\uff0c\u90a3\u4e48\u6570\u636e\u5c31\u88ab\u89c6\u4e3a\u5b8c\u6574\u7684\u3002

    \u5bf9\u4e8e\u5bc6\u7801\u5b66\u7684\u76f8\u5173\u5e94\u7528\uff0c\u54c8\u5e0c\u7b97\u6cd5\u9700\u8981\u6ee1\u8db3\u66f4\u9ad8\u7684\u5b89\u5168\u6807\u51c6\uff0c\u4ee5\u9632\u6b62\u4ece\u54c8\u5e0c\u503c\u63a8\u5bfc\u51fa\u539f\u59cb\u5bc6\u7801\u7b49\u9006\u5411\u5de5\u7a0b\uff0c\u5305\u62ec\uff1a

    • \u6297\u78b0\u649e\u6027\uff1a\u5e94\u5f53\u6781\u5176\u56f0\u96be\u627e\u5230\u4e24\u4e2a\u4e0d\u540c\u7684\u8f93\u5165\uff0c\u4f7f\u5f97\u5b83\u4eec\u7684\u54c8\u5e0c\u503c\u76f8\u540c\u3002
    • \u96ea\u5d29\u6548\u5e94\uff1a\u8f93\u5165\u7684\u5fae\u5c0f\u53d8\u5316\u5e94\u5f53\u5bfc\u81f4\u8f93\u51fa\u7684\u663e\u8457\u4e14\u4e0d\u53ef\u9884\u6d4b\u7684\u53d8\u5316\u3002

    \u6ce8\u610f\uff0c\u201c\u5747\u5300\u5206\u5e03\u201d\u4e0e\u201c\u6297\u78b0\u649e\u6027\u201d\u662f\u4e24\u4e2a\u72ec\u7acb\u7684\u6982\u5ff5\uff0c\u6ee1\u8db3\u5747\u5300\u5206\u5e03\u4e0d\u4e00\u5b9a\u6ee1\u8db3\u6297\u78b0\u649e\u6027\u3002\u4f8b\u5982\uff0c\u5728\u968f\u673a\u8f93\u5165 key \u4e0b\uff0c\u54c8\u5e0c\u51fd\u6570 key % 100 \u53ef\u4ee5\u4ea7\u751f\u5747\u5300\u5206\u5e03\u7684\u8f93\u51fa\u3002\u7136\u800c\uff0c\u8be5\u54c8\u5e0c\u7b97\u6cd5\u8fc7\u4e8e\u7b80\u5355\uff0c\u6240\u6709\u540e\u4e24\u4f4d\u76f8\u7b49\u7684 key \u7684\u8f93\u51fa\u90fd\u76f8\u540c\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u5f88\u5bb9\u6613\u5730\u4ece\u54c8\u5e0c\u503c\u53cd\u63a8\u51fa\u53ef\u7528\u7684 key \uff0c\u4ece\u800c\u7834\u89e3\u5bc6\u7801\u3002

    "},{"location":"chapter_hashing/hash_algorithm/#632","title":"6.3.2. \u00a0 \u54c8\u5e0c\u7b97\u6cd5\u7684\u8bbe\u8ba1","text":"

    \u54c8\u5e0c\u7b97\u6cd5\u7684\u8bbe\u8ba1\u662f\u4e00\u4e2a\u590d\u6742\u4e14\u9700\u8981\u8003\u8651\u8bb8\u591a\u56e0\u7d20\u7684\u95ee\u9898\u3002\u7136\u800c\uff0c\u5bf9\u4e8e\u4e00\u4e9b\u7b80\u5355\u573a\u666f\uff0c\u6211\u4eec\u4e5f\u80fd\u8bbe\u8ba1\u4e00\u4e9b\u7b80\u5355\u7684\u54c8\u5e0c\u7b97\u6cd5\uff0c\u4ee5\u5b57\u7b26\u4e32\u54c8\u5e0c\u4e3a\u4f8b\uff1a

    • \u52a0\u6cd5\u54c8\u5e0c\uff1a\u5bf9\u8f93\u5165\u7684\u6bcf\u4e2a\u5b57\u7b26\u7684 ASCII \u7801\u8fdb\u884c\u76f8\u52a0\uff0c\u5c06\u5f97\u5230\u7684\u603b\u548c\u4f5c\u4e3a\u54c8\u5e0c\u503c\u3002
    • \u4e58\u6cd5\u54c8\u5e0c\uff1a\u5229\u7528\u4e86\u4e58\u6cd5\u7684\u4e0d\u76f8\u5173\u6027\uff0c\u6bcf\u8f6e\u4e58\u4ee5\u4e00\u4e2a\u5e38\u6570\uff0c\u5c06\u5404\u4e2a\u5b57\u7b26\u7684 ASCII \u7801\u7d2f\u79ef\u5230\u54c8\u5e0c\u503c\u4e2d\u3002
    • \u5f02\u6216\u54c8\u5e0c\uff1a\u5c06\u8f93\u5165\u6570\u636e\u7684\u6bcf\u4e2a\u5143\u7d20\u901a\u8fc7\u5f02\u6216\u64cd\u4f5c\u7d2f\u79ef\u5230\u4e00\u4e2a\u54c8\u5e0c\u503c\u4e2d\u3002
    • \u65cb\u8f6c\u54c8\u5e0c\uff1a\u5c06\u6bcf\u4e2a\u5b57\u7b26\u7684 ASCII \u7801\u7d2f\u79ef\u5230\u4e00\u4e2a\u54c8\u5e0c\u503c\u4e2d\uff0c\u6bcf\u6b21\u7d2f\u79ef\u4e4b\u524d\u90fd\u4f1a\u5bf9\u54c8\u5e0c\u503c\u8fdb\u884c\u65cb\u8f6c\u64cd\u4f5c\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart simple_hash.java
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(String key) {\nlong hash = 0;\nfinal int MODULUS = 1000000007;\nfor (char c : key.toCharArray()) {\nhash = (hash + (int) c) % MODULUS;\n}\nreturn (int) hash;\n}\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(String key) {\nlong hash = 0;\nfinal int MODULUS = 1000000007;\nfor (char c : key.toCharArray()) {\nhash = (31 * hash + (int) c) % MODULUS;\n}\nreturn (int) hash;\n}\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(String key) {\nint hash = 0;\nfinal int MODULUS = 1000000007;\nfor (char c : key.toCharArray()) {\nhash ^= (int) c;\n}\nreturn hash & MODULUS;\n}\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(String key) {\nlong hash = 0;\nfinal int MODULUS = 1000000007;\nfor (char c : key.toCharArray()) {\nhash = ((hash << 4) ^ (hash >> 28) ^ (int) c) % MODULUS;\n}\nreturn (int) hash;\n}\n
    simple_hash.cpp
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(string key) {\nlong long hash = 0;\nconst int MODULUS = 1000000007;\nfor (unsigned char c : key) {\nhash = (hash + (int)c) % MODULUS;\n}\nreturn (int)hash;\n}\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(string key) {\nlong long hash = 0;\nconst int MODULUS = 1000000007;\nfor (unsigned char c : key) {\nhash = (31 * hash + (int)c) % MODULUS;\n}\nreturn (int)hash;\n}\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(string key) {\nint hash = 0;\nconst int MODULUS = 1000000007;\nfor (unsigned char c : key) {\ncout<<(int)c<<endl;\nhash ^= (int)c;\n}\nreturn hash & MODULUS;\n}\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(string key) {\nlong long hash = 0;\nconst int MODULUS = 1000000007;\nfor (unsigned char c : key) {\nhash = ((hash << 4) ^ (hash >> 28) ^ (int)c) % MODULUS;\n}\nreturn (int)hash;\n}\n
    simple_hash.py
    def add_hash(key: str) -> int:\n\"\"\"\u52a0\u6cd5\u54c8\u5e0c\"\"\"\nhash = 0\nmodulus = 1000000007\nfor c in key:\nhash += ord(c)\nreturn hash % modulus\ndef mul_hash(key: str) -> int:\n\"\"\"\u4e58\u6cd5\u54c8\u5e0c\"\"\"\nhash = 0\nmodulus = 1000000007\nfor c in key:\nhash = 31 * hash + ord(c)\nreturn hash % modulus\ndef xor_hash(key: str) -> int:\n\"\"\"\u5f02\u6216\u54c8\u5e0c\"\"\"\nhash = 0\nmodulus = 1000000007\nfor c in key:\nhash ^= ord(c)\nreturn hash % modulus\ndef rot_hash(key: str) -> int:\n\"\"\"\u65cb\u8f6c\u54c8\u5e0c\"\"\"\nhash = 0\nmodulus = 1000000007\nfor c in key:\nhash = (hash << 4) ^ (hash >> 28) ^ ord(c)\nreturn hash % modulus\n
    simple_hash.go
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key string) int {\nvar hash int64\nvar modulus int64\nmodulus = 1000000007\nfor _, b := range []byte(key) {\nhash = (hash + int64(b)) % modulus\n}\nreturn int(hash)\n}\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key string) int {\nvar hash int64\nvar modulus int64\nmodulus = 1000000007\nfor _, b := range []byte(key) {\nhash = (31*hash + int64(b)) % modulus\n}\nreturn int(hash)\n}\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key string) int {\nhash := 0\nmodulus := 1000000007\nfor _, b := range []byte(key) {\nfmt.Println(int(b))\nhash ^= int(b)\nhash = (31*hash + int(b)) % modulus\n}\nreturn hash & modulus\n}\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key string) int {\nvar hash int64\nvar modulus int64\nmodulus = 1000000007\nfor _, b := range []byte(key) {\nhash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus\n}\nreturn int(hash)\n}\n
    simple_hash.js
    [class]{}-[func]{addHash}\n[class]{}-[func]{mulHash}\n[class]{}-[func]{xorHash}\n[class]{}-[func]{rotHash}\n
    simple_hash.ts
    [class]{}-[func]{addHash}\n[class]{}-[func]{mulHash}\n[class]{}-[func]{xorHash}\n[class]{}-[func]{rotHash}\n
    simple_hash.c
    [class]{}-[func]{addHash}\n[class]{}-[func]{mulHash}\n[class]{}-[func]{xorHash}\n[class]{}-[func]{rotHash}\n
    simple_hash.cs
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(string key) {\nlong hash = 0;\nconst int MODULUS = 1000000007;\nforeach (char c in key) {\nhash = (hash + c) % MODULUS;\n}\nreturn (int)hash;\n}\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(string key) {\nlong hash = 0;\nconst int MODULUS = 1000000007;\nforeach (char c in key) {\nhash = (31 * hash + c) % MODULUS;\n}\nreturn (int)hash;\n}\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(string key) {\nint hash = 0;\nconst int MODULUS = 1000000007;\nforeach (char c in key) {\nhash ^= c;\n}\nreturn hash & MODULUS;\n}\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(string key) {\nlong hash = 0;\nconst int MODULUS = 1000000007;\nforeach (char c in key) {\nhash = ((hash << 4) ^ (hash >> 28) ^ c) % MODULUS;\n}\nreturn (int)hash;\n}\n
    simple_hash.swift
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key: String) -> Int {\nvar hash = 0\nlet MODULUS = 1_000_000_007\nfor c in key {\nfor scalar in c.unicodeScalars {\nhash = (hash + Int(scalar.value)) % MODULUS\n}\n}\nreturn hash\n}\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key: String) -> Int {\nvar hash = 0\nlet MODULUS = 1_000_000_007\nfor c in key {\nfor scalar in c.unicodeScalars {\nhash = (31 * hash + Int(scalar.value)) % MODULUS\n}\n}\nreturn hash\n}\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key: String) -> Int {\nvar hash = 0\nlet MODULUS = 1_000_000_007\nfor c in key {\nfor scalar in c.unicodeScalars {\nhash ^= Int(scalar.value)\n}\n}\nreturn hash & MODULUS\n}\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key: String) -> Int {\nvar hash = 0\nlet MODULUS = 1_000_000_007\nfor c in key {\nfor scalar in c.unicodeScalars {\nhash = ((hash << 4) ^ (hash >> 28) ^ Int(scalar.value)) % MODULUS\n}\n}\nreturn hash\n}\n
    simple_hash.zig
    [class]{}-[func]{addHash}\n[class]{}-[func]{mulHash}\n[class]{}-[func]{xorHash}\n[class]{}-[func]{rotHash}\n
    simple_hash.dart
    [class]{}-[func]{add_hash}\n[class]{}-[func]{mul_hash}\n[class]{}-[func]{xor_hash}\n[class]{}-[func]{rot_hash}\n

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u6bcf\u79cd\u54c8\u5e0c\u7b97\u6cd5\u7684\u6700\u540e\u4e00\u6b65\u90fd\u662f\u5bf9\u5927\u8d28\u6570 \\(1000000007\\) \u53d6\u6a21\uff0c\u4ee5\u786e\u4fdd\u54c8\u5e0c\u503c\u5728\u5408\u9002\u7684\u8303\u56f4\u5185\u3002\u503c\u5f97\u601d\u8003\u7684\u662f\uff0c\u4e3a\u4ec0\u4e48\u8981\u5f3a\u8c03\u5bf9\u8d28\u6570\u53d6\u6a21\uff0c\u5bf9\u5408\u6570\u53d6\u6a21\u7684\u5f0a\u7aef\u662f\u4ec0\u4e48\uff1f\u8fd9\u662f\u4e00\u4e2a\u6709\u8da3\u7684\u95ee\u9898\u3002

    \u5148\u629b\u51fa\u7ed3\u8bba\uff1a\u5f53\u6211\u4eec\u4f7f\u7528\u5927\u8d28\u6570\u4f5c\u4e3a\u6a21\u6570\u65f6\uff0c\u53ef\u4ee5\u6700\u5927\u5316\u5730\u4fdd\u8bc1\u54c8\u5e0c\u503c\u7684\u5747\u5300\u5206\u5e03\u3002\u56e0\u4e3a\u8d28\u6570\u4e0d\u4f1a\u4e0e\u5176\u4ed6\u6570\u5b57\u5b58\u5728\u516c\u7ea6\u6570\uff0c\u53ef\u4ee5\u51cf\u5c11\u56e0\u53d6\u6a21\u64cd\u4f5c\u800c\u4ea7\u751f\u7684\u5468\u671f\u6027\u6a21\u5f0f\uff0c\u4ece\u800c\u907f\u514d\u54c8\u5e0c\u51b2\u7a81\u3002

    \u4e3e\u4e2a\u4f8b\u5b50\uff0c\u5047\u8bbe\u6211\u4eec\u9009\u62e9\u5408\u6570 \\(9\\) \u4f5c\u4e3a\u6a21\u6570\uff0c\u5b83\u53ef\u4ee5\u88ab \\(3\\) \u6574\u9664\u3002\u90a3\u4e48\u6240\u6709\u53ef\u4ee5\u88ab \\(3\\) \u6574\u9664\u7684 key \u90fd\u4f1a\u88ab\u6620\u5c04\u5230 \\(0\\) , \\(3\\) , \\(6\\) \u8fd9\u4e09\u4e2a\u54c8\u5e0c\u503c\u3002

    \\[ \\begin{aligned} \\text{modulus} & = 9 \\newline \\text{key} & = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\cdots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\cdots \\} \\end{aligned} \\]

    \u5982\u679c\u8f93\u5165 key \u6070\u597d\u6ee1\u8db3\u8fd9\u79cd\u7b49\u5dee\u6570\u5217\u7684\u6570\u636e\u5206\u5e03\uff0c\u90a3\u4e48\u54c8\u5e0c\u503c\u5c31\u4f1a\u51fa\u73b0\u805a\u5806\uff0c\u4ece\u800c\u52a0\u91cd\u54c8\u5e0c\u51b2\u7a81\u3002\u73b0\u5728\uff0c\u5047\u8bbe\u5c06 modulus \u66ff\u6362\u4e3a\u8d28\u6570 \\(13\\) \uff0c\u7531\u4e8e key \u548c modulus \u4e4b\u95f4\u4e0d\u5b58\u5728\u516c\u7ea6\u6570\uff0c\u8f93\u51fa\u7684\u54c8\u5e0c\u503c\u7684\u5747\u5300\u6027\u4f1a\u660e\u663e\u63d0\u5347\u3002

    \\[ \\begin{aligned} \\text{modulus} & = 13 \\newline \\text{key} & = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\cdots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\cdots \\} \\end{aligned} \\]

    \u503c\u5f97\u5f3a\u8c03\u7684\u662f\uff0c\u5982\u679c\u80fd\u591f\u4fdd\u8bc1 key \u662f\u968f\u673a\u5747\u5300\u5206\u5e03\u7684\uff0c\u90a3\u4e48\u9009\u62e9\u8d28\u6570\u6216\u8005\u5408\u6570\u4f5c\u4e3a\u6a21\u6570\u90fd\u662f\u53ef\u4ee5\u7684\uff0c\u5b83\u4eec\u90fd\u80fd\u8f93\u51fa\u5747\u5300\u5206\u5e03\u7684\u54c8\u5e0c\u503c\u3002\u800c\u5f53 key \u7684\u5206\u5e03\u5b58\u5728\u67d0\u79cd\u5468\u671f\u6027\u65f6\uff0c\u5bf9\u5408\u6570\u53d6\u6a21\u66f4\u5bb9\u6613\u51fa\u73b0\u805a\u96c6\u73b0\u8c61\u3002

    \u603b\u800c\u8a00\u4e4b\uff0c\u6211\u4eec\u901a\u5e38\u9009\u53d6\u8d28\u6570\u4f5c\u4e3a\u6a21\u6570\uff0c\u5e76\u4e14\u8fd9\u4e2a\u8d28\u6570\u6700\u597d\u5927\u4e00\u4e9b\uff0c\u4ee5\u63d0\u5347\u54c8\u5e0c\u7b97\u6cd5\u7684\u7a33\u5065\u6027\u3002

    "},{"location":"chapter_hashing/hash_algorithm/#633","title":"6.3.3. \u00a0 \u5e38\u89c1\u54c8\u5e0c\u7b97\u6cd5","text":"

    \u4e0d\u96be\u53d1\u73b0\uff0c\u4ee5\u4e0a\u4ecb\u7ecd\u7684\u7b80\u5355\u54c8\u5e0c\u7b97\u6cd5\u90fd\u6bd4\u8f83\u201c\u8106\u5f31\u201d\uff0c\u8fdc\u8fdc\u6ca1\u6709\u8fbe\u5230\u54c8\u5e0c\u7b97\u6cd5\u7684\u8bbe\u8ba1\u76ee\u6807\u3002\u4f8b\u5982\uff0c\u7531\u4e8e\u52a0\u6cd5\u548c\u5f02\u6216\u6ee1\u8db3\u4ea4\u6362\u5f8b\uff0c\u56e0\u6b64\u52a0\u6cd5\u54c8\u5e0c\u548c\u5f02\u6216\u54c8\u5e0c\u65e0\u6cd5\u533a\u5206\u5185\u5bb9\u76f8\u540c\u4f46\u987a\u5e8f\u4e0d\u540c\u7684\u5b57\u7b26\u4e32\uff0c\u8fd9\u53ef\u80fd\u4f1a\u52a0\u5267\u54c8\u5e0c\u51b2\u7a81\uff0c\u5e76\u5f15\u8d77\u4e00\u4e9b\u5b89\u5168\u95ee\u9898\u3002

    \u5728\u5b9e\u9645\u4e2d\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u7528\u4e00\u4e9b\u6807\u51c6\u54c8\u5e0c\u7b97\u6cd5\uff0c\u4f8b\u5982 MD5, SHA-1, SHA-2, SHA3 \u7b49\u3002\u5b83\u4eec\u53ef\u4ee5\u5c06\u4efb\u610f\u957f\u5ea6\u7684\u8f93\u5165\u6570\u636e\u6620\u5c04\u5230\u6052\u5b9a\u957f\u5ea6\u7684\u54c8\u5e0c\u503c\u3002\u8fd1\u4e00\u4e2a\u4e16\u7eaa\u4ee5\u6765\uff0c\u54c8\u5e0c\u7b97\u6cd5\u5904\u5728\u4e0d\u65ad\u5347\u7ea7\u4e0e\u4f18\u5316\u7684\u8fc7\u7a0b\u4e2d\u3002\u4e00\u90e8\u5206\u7814\u7a76\u4eba\u5458\u52aa\u529b\u63d0\u5347\u54c8\u5e0c\u7b97\u6cd5\u7684\u6027\u80fd\uff0c\u53e6\u4e00\u90e8\u5206\u7814\u7a76\u4eba\u5458\u548c\u9ed1\u5ba2\u5219\u81f4\u529b\u4e8e\u5bfb\u627e\u54c8\u5e0c\u7b97\u6cd5\u7684\u5b89\u5168\u6027\u95ee\u9898\u3002

    \u76f4\u81f3\u76ee\u524d\uff0cMD5 \u548c SHA-1 \u5df2\u591a\u6b21\u88ab\u6210\u529f\u653b\u51fb\uff0c\u56e0\u6b64\u5b83\u4eec\u88ab\u5404\u7c7b\u5b89\u5168\u5e94\u7528\u5f03\u7528\u3002SHA-2 \u7cfb\u5217\u4e2d\u7684 SHA-256 \u662f\u6700\u5b89\u5168\u7684\u54c8\u5e0c\u7b97\u6cd5\u4e4b\u4e00\uff0c\u4ecd\u672a\u51fa\u73b0\u6210\u529f\u7684\u653b\u51fb\u6848\u4f8b\uff0c\u56e0\u6b64\u5e38\u88ab\u7528\u5728\u5404\u7c7b\u5b89\u5168\u5e94\u7528\u4e0e\u534f\u8bae\u4e2d\u3002SHA-3 \u76f8\u8f83 SHA-2 \u7684\u5b9e\u73b0\u5f00\u9500\u66f4\u4f4e\u3001\u8ba1\u7b97\u6548\u7387\u66f4\u9ad8\uff0c\u4f46\u76ee\u524d\u4f7f\u7528\u8986\u76d6\u5ea6\u4e0d\u5982 SHA-2 \u7cfb\u5217\u3002

    MD5 SHA-1 SHA-2 SHA-3 \u63a8\u51fa\u65f6\u95f4 1992 1995 2002 2008 \u8f93\u51fa\u957f\u5ea6 128 bits 160 bits 256 / 512 bits 224/256/384/512 bits \u54c8\u5e0c\u51b2\u7a81 \u8f83\u591a \u8f83\u591a \u5f88\u5c11 \u5f88\u5c11 \u5b89\u5168\u7b49\u7ea7 \u4f4e\uff0c\u5df2\u88ab\u6210\u529f\u653b\u51fb \u4f4e\uff0c\u5df2\u88ab\u6210\u529f\u653b\u51fb \u9ad8 \u9ad8 \u5e94\u7528 \u5df2\u88ab\u5f03\u7528\uff0c\u4ecd\u7528\u4e8e\u6570\u636e\u5b8c\u6574\u6027\u68c0\u67e5 \u5df2\u88ab\u5f03\u7528 \u52a0\u5bc6\u8d27\u5e01\u4ea4\u6613\u9a8c\u8bc1\u3001\u6570\u5b57\u7b7e\u540d\u7b49 \u53ef\u7528\u4e8e\u66ff\u4ee3 SHA-2"},{"location":"chapter_hashing/hash_algorithm/#634","title":"6.3.4. \u00a0 \u6570\u636e\u7ed3\u6784\u7684\u54c8\u5e0c\u503c","text":"

    \u6211\u4eec\u77e5\u9053\uff0c\u54c8\u5e0c\u8868\u7684 key \u53ef\u4ee5\u662f\u6574\u6570\u3001\u5c0f\u6570\u6216\u5b57\u7b26\u4e32\u7b49\u6570\u636e\u7c7b\u578b\u3002\u7f16\u7a0b\u8bed\u8a00\u901a\u5e38\u4f1a\u4e3a\u8fd9\u4e9b\u6570\u636e\u7c7b\u578b\u63d0\u4f9b\u5185\u7f6e\u7684\u54c8\u5e0c\u7b97\u6cd5\uff0c\u7528\u4e8e\u8ba1\u7b97\u54c8\u5e0c\u8868\u4e2d\u7684\u6876\u7d22\u5f15\u3002\u4ee5 Python \u4e3a\u4f8b\uff0c\u6211\u4eec\u53ef\u4ee5\u8c03\u7528 hash() \u51fd\u6570\u6765\u8ba1\u7b97\u5404\u79cd\u6570\u636e\u7c7b\u578b\u7684\u54c8\u5e0c\u503c\uff0c\u5305\u62ec\uff1a

    • \u6574\u6570\u548c\u5e03\u5c14\u91cf\u7684\u54c8\u5e0c\u503c\u5c31\u662f\u5176\u672c\u8eab\u3002
    • \u6d6e\u70b9\u6570\u548c\u5b57\u7b26\u4e32\u7684\u54c8\u5e0c\u503c\u8ba1\u7b97\u8f83\u4e3a\u590d\u6742\uff0c\u6709\u5174\u8da3\u7684\u540c\u5b66\u8bf7\u81ea\u884c\u5b66\u4e60\u3002
    • \u5143\u7ec4\u7684\u54c8\u5e0c\u503c\u662f\u5bf9\u5176\u4e2d\u6bcf\u4e00\u4e2a\u5143\u7d20\u8fdb\u884c\u54c8\u5e0c\uff0c\u7136\u540e\u5c06\u8fd9\u4e9b\u54c8\u5e0c\u503c\u7ec4\u5408\u8d77\u6765\uff0c\u5f97\u5230\u5355\u4e00\u7684\u54c8\u5e0c\u503c\u3002
    • \u5bf9\u8c61\u7684\u54c8\u5e0c\u503c\u57fa\u4e8e\u5176\u5185\u5b58\u5730\u5740\u751f\u6210\u3002\u901a\u8fc7\u91cd\u5199\u5bf9\u8c61\u7684\u54c8\u5e0c\u65b9\u6cd5\uff0c\u53ef\u5b9e\u73b0\u57fa\u4e8e\u5185\u5bb9\u751f\u6210\u54c8\u5e0c\u503c\u3002

    Tip

    \u8bf7\u6ce8\u610f\uff0c\u4e0d\u540c\u7f16\u7a0b\u8bed\u8a00\u7684\u5185\u7f6e\u54c8\u5e0c\u503c\u8ba1\u7b97\u51fd\u6570\u7684\u5b9a\u4e49\u548c\u65b9\u6cd5\u4e0d\u540c\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart built_in_hash.java
    int num = 3;\nint hashNum = Integer.hashCode(num);\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 1231\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -1340954729\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode();\n// \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a -727081396\nObject[] arr = { 12836, \"\u5c0f\u54c8\" };\nint hashTup = Arrays.hashCode(arr);\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 1151158\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// \u8282\u70b9\u5bf9\u8c61 utils.ListNode@7dc5e7b4 \u7684\u54c8\u5e0c\u503c\u4e3a 2110121908\n
    built_in_hash.cpp
    int num = 3;\nsize_t hashNum = hash<int>()(num);\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\nbool bol = true;\nsize_t hashBol = hash<bool>()(bol);\n// \u5e03\u5c14\u91cf 1 \u7684\u54c8\u5e0c\u503c\u4e3a 1\ndouble dec = 3.14159;\nsize_t hashDec = hash<double>()(dec);\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 4614256650576692846\nstring str = \"Hello \u7b97\u6cd5\";\nsize_t hashStr = hash<string>()(str);\n// \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a 15466937326284535026\n// \u5728 C++ \u4e2d\uff0c\u5185\u7f6e std:hash() \u4ec5\u63d0\u4f9b\u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u54c8\u5e0c\u503c\u8ba1\u7b97\n// \u6570\u7ec4\u3001\u5bf9\u8c61\u7684\u54c8\u5e0c\u503c\u8ba1\u7b97\u9700\u8981\u81ea\u884c\u5b9e\u73b0\n
    built_in_hash.py
    num = 3\nhash_num = hash(num)\n# \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\nbol = True\nhash_bol = hash(bol)\n# \u5e03\u5c14\u91cf True \u7684\u54c8\u5e0c\u503c\u4e3a 1\ndec = 3.14159\nhash_dec = hash(dec) \n# \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 326484311674566659\nstr = \"Hello \u7b97\u6cd5\"\nhash_str = hash(str)\n# \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a 4617003410720528961\ntup = (12836, \"\u5c0f\u54c8\")\nhash_tup = hash(tup)\n# \u5143\u7ec4 (12836, '\u5c0f\u54c8') \u7684\u54c8\u5e0c\u503c\u4e3a 1029005403108185979\nobj = ListNode(0)\nhash_obj = hash(obj)\n# \u8282\u70b9\u5bf9\u8c61 <ListNode object at 0x1058fd810> \u7684\u54c8\u5e0c\u503c\u4e3a 274267521\n
    built_in_hash.go
    \n
    built_in_hash.js
    \n
    built_in_hash.ts
    \n
    built_in_hash.c
    \n
    built_in_hash.cs
    int num = 3;\nint hashNum = num.GetHashCode();\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3;\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 1;\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -1340954729;\nstring str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.GetHashCode();\n// \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a -586107568;\nobject[] arr = { 12836, \"\u5c0f\u54c8\" };\nint hashTup = arr.GetHashCode();\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 42931033;\nListNode obj = new ListNode(0);\nint hashObj = obj.GetHashCode();\n// \u8282\u70b9\u5bf9\u8c61 0 \u7684\u54c8\u5e0c\u503c\u4e3a 39053774;\n
    built_in_hash.swift
    let num = 3\nlet hashNum = num.hashValue\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 9047044699613009734\nlet bol = true\nlet hashBol = bol.hashValue\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a -4431640247352757451\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -2465384235396674631\nlet str = \"Hello \u7b97\u6cd5\"\nlet hashStr = str.hashValue\n// \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a -7850626797806988787\nlet arr = [AnyHashable(12836), AnyHashable(\"\u5c0f\u54c8\")]\nlet hashTup = arr.hashValue\n// \u6570\u7ec4 [AnyHashable(12836), AnyHashable(\"\u5c0f\u54c8\")] \u7684\u54c8\u5e0c\u503c\u4e3a -2308633508154532996\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// \u8282\u70b9\u5bf9\u8c61 utils.ListNode \u7684\u54c8\u5e0c\u503c\u4e3a -2434780518035996159\n
    built_in_hash.zig
    \n
    built_in_hash.dart
    int num = 3;\nint hashNum = num.hashCode;\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 34803\nbool bol = true;\nint hashBol = bol.hashCode;\n// \u5e03\u5c14\u503c true \u7684\u54c8\u5e0c\u503c\u4e3a 1231\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 2570631074981783\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode;\n// \u5b57\u7b26\u4e32 Hello \u7b97\u6cd5 \u7684\u54c8\u5e0c\u503c\u4e3a 468167534\nList arr = [12836, \"\u5c0f\u54c8\"];\nint hashArr = arr.hashCode;\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 976512528\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// \u8282\u70b9\u5bf9\u8c61 Instance of 'ListNode' \u7684\u54c8\u5e0c\u503c\u4e3a 1033450432\n

    \u5728\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u53ea\u6709\u4e0d\u53ef\u53d8\u5bf9\u8c61\u624d\u53ef\u4f5c\u4e3a\u54c8\u5e0c\u8868\u7684 key \u3002\u5047\u5982\u6211\u4eec\u5c06\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\u4f5c\u4e3a key \uff0c\u5f53\u5217\u8868\u7684\u5185\u5bb9\u53d1\u751f\u53d8\u5316\u65f6\uff0c\u5b83\u7684\u54c8\u5e0c\u503c\u4e5f\u968f\u4e4b\u6539\u53d8\uff0c\u6211\u4eec\u5c31\u65e0\u6cd5\u5728\u54c8\u5e0c\u8868\u4e2d\u67e5\u8be2\u5230\u539f\u5148\u7684 value \u4e86\u3002

    \u867d\u7136\u81ea\u5b9a\u4e49\u5bf9\u8c61\uff08\u4f8b\u5982\u94fe\u8868\u8282\u70b9\uff09\u7684\u6210\u5458\u53d8\u91cf\u662f\u53ef\u53d8\u7684\uff0c\u4f46\u5b83\u662f\u53ef\u54c8\u5e0c\u7684\uff0c\u8fd9\u662f\u56e0\u4e3a\u5bf9\u8c61\u7684\u54c8\u5e0c\u503c\u9ed8\u8ba4\u57fa\u4e8e\u5185\u5b58\u5730\u5740\u751f\u6210\u3002\u5373\u4f7f\u5bf9\u8c61\u7684\u5185\u5bb9\u53d1\u751f\u4e86\u53d8\u5316\uff0c\u4f46\u5b83\u7684\u5185\u5b58\u5730\u5740\u4e0d\u53d8\uff0c\u54c8\u5e0c\u503c\u4ecd\u7136\u662f\u4e0d\u53d8\u7684\u3002

    \u5411\u54c8\u5e0c\u51fd\u6570\u52a0\u76d0

    Python \u89e3\u91ca\u5668\u5728\u6bcf\u6b21\u542f\u52a8\u65f6\uff0c\u90fd\u4f1a\u4e3a\u5b57\u7b26\u4e32\u54c8\u5e0c\u51fd\u6570\u52a0\u5165\u4e00\u4e2a\u968f\u673a\u7684\u76d0\uff08Salt\uff09\u503c\u3002\u56e0\u6b64\u5728\u4e0d\u540c\u7684 Python \u8fd0\u884c\u5b9e\u4f8b\u4e2d\uff0c\u540c\u4e00\u5b57\u7b26\u4e32\u7684\u54c8\u5e0c\u503c\u901a\u5e38\u662f\u4e0d\u540c\u7684\u3002\u6b64\u505a\u6cd5\u53ef\u4ee5\u6709\u6548\u9632\u6b62 HashDoS \u653b\u51fb\uff0c\u63d0\u5347\u54c8\u5e0c\u7b97\u6cd5\u7684\u5b89\u5168\u6027\u3002

    "},{"location":"chapter_hashing/hash_collision/","title":"6.2. \u00a0 \u54c8\u5e0c\u51b2\u7a81","text":"

    \u4e0a\u8282\u63d0\u5230\uff0c\u901a\u5e38\u60c5\u51b5\u4e0b\u54c8\u5e0c\u51fd\u6570\u7684\u8f93\u5165\u7a7a\u95f4\u8fdc\u5927\u4e8e\u8f93\u51fa\u7a7a\u95f4\uff0c\u56e0\u6b64\u54c8\u5e0c\u51b2\u7a81\u662f\u4e0d\u53ef\u907f\u514d\u7684\u3002\u4f8b\u5982\uff0c\u8f93\u5165\u7a7a\u95f4\u4e3a\u5168\u4f53\u6574\u6570\uff0c\u8f93\u51fa\u7a7a\u95f4\u4e3a\u6570\u7ec4\u5bb9\u91cf\u5927\u5c0f\uff0c\u5219\u5fc5\u7136\u6709\u591a\u4e2a\u6574\u6570\u6620\u5c04\u81f3\u540c\u4e00\u6570\u7ec4\u7d22\u5f15\u3002

    \u54c8\u5e0c\u51b2\u7a81\u4f1a\u5bfc\u81f4\u67e5\u8be2\u7ed3\u679c\u9519\u8bef\uff0c\u4e25\u91cd\u5f71\u54cd\u54c8\u5e0c\u8868\u7684\u53ef\u7528\u6027\u3002\u4e3a\u89e3\u51b3\u8be5\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u6bcf\u5f53\u9047\u5230\u54c8\u5e0c\u51b2\u7a81\u65f6\u5c31\u8fdb\u884c\u54c8\u5e0c\u8868\u6269\u5bb9\uff0c\u76f4\u81f3\u51b2\u7a81\u6d88\u5931\u4e3a\u6b62\u3002\u6b64\u65b9\u6cd5\u7b80\u5355\u7c97\u66b4\u4e14\u6709\u6548\uff0c\u4f46\u6548\u7387\u592a\u4f4e\uff0c\u56e0\u4e3a\u54c8\u5e0c\u8868\u6269\u5bb9\u9700\u8981\u8fdb\u884c\u5927\u91cf\u7684\u6570\u636e\u642c\u8fd0\u4e0e\u54c8\u5e0c\u503c\u8ba1\u7b97\u3002\u4e3a\u4e86\u63d0\u5347\u6548\u7387\uff0c\u6211\u4eec\u6362\u4e00\u79cd\u601d\u8def\uff1a

    1. \u6539\u826f\u54c8\u5e0c\u8868\u6570\u636e\u7ed3\u6784\uff0c\u4f7f\u5f97\u54c8\u5e0c\u8868\u53ef\u4ee5\u5728\u5b58\u5728\u54c8\u5e0c\u51b2\u7a81\u65f6\u6b63\u5e38\u5de5\u4f5c\u3002
    2. \u4ec5\u5728\u5fc5\u8981\u65f6\uff0c\u5373\u5f53\u54c8\u5e0c\u51b2\u7a81\u6bd4\u8f83\u4e25\u91cd\u65f6\uff0c\u6267\u884c\u6269\u5bb9\u64cd\u4f5c\u3002

    \u54c8\u5e0c\u8868\u7684\u7ed3\u6784\u6539\u826f\u65b9\u6cd5\u4e3b\u8981\u5305\u62ec\u94fe\u5f0f\u5730\u5740\u548c\u5f00\u653e\u5bfb\u5740\u3002

    "},{"location":"chapter_hashing/hash_collision/#621","title":"6.2.1. \u00a0 \u94fe\u5f0f\u5730\u5740","text":"

    \u5728\u539f\u59cb\u54c8\u5e0c\u8868\u4e2d\uff0c\u6bcf\u4e2a\u6876\u4ec5\u80fd\u5b58\u50a8\u4e00\u4e2a\u952e\u503c\u5bf9\u3002\u300c\u94fe\u5f0f\u5730\u5740 Separate Chaining\u300d\u5c06\u5355\u4e2a\u5143\u7d20\u8f6c\u6362\u4e3a\u94fe\u8868\uff0c\u5c06\u952e\u503c\u5bf9\u4f5c\u4e3a\u94fe\u8868\u8282\u70b9\uff0c\u5c06\u6240\u6709\u53d1\u751f\u51b2\u7a81\u7684\u952e\u503c\u5bf9\u90fd\u5b58\u50a8\u5728\u540c\u4e00\u94fe\u8868\u4e2d\u3002

    Fig. \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868

    \u94fe\u5f0f\u5730\u5740\u4e0b\uff0c\u54c8\u5e0c\u8868\u7684\u64cd\u4f5c\u65b9\u6cd5\u5305\u62ec\uff1a

    • \u67e5\u8be2\u5143\u7d20\uff1a\u8f93\u5165 key \uff0c\u7ecf\u8fc7\u54c8\u5e0c\u51fd\u6570\u5f97\u5230\u6570\u7ec4\u7d22\u5f15\uff0c\u5373\u53ef\u8bbf\u95ee\u94fe\u8868\u5934\u8282\u70b9\uff0c\u7136\u540e\u904d\u5386\u94fe\u8868\u5e76\u5bf9\u6bd4 key \u4ee5\u67e5\u627e\u76ee\u6807\u952e\u503c\u5bf9\u3002
    • \u6dfb\u52a0\u5143\u7d20\uff1a\u5148\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u8bbf\u95ee\u94fe\u8868\u5934\u8282\u70b9\uff0c\u7136\u540e\u5c06\u8282\u70b9\uff08\u5373\u952e\u503c\u5bf9\uff09\u6dfb\u52a0\u5230\u94fe\u8868\u4e2d\u3002
    • \u5220\u9664\u5143\u7d20\uff1a\u6839\u636e\u54c8\u5e0c\u51fd\u6570\u7684\u7ed3\u679c\u8bbf\u95ee\u94fe\u8868\u5934\u90e8\uff0c\u63a5\u7740\u904d\u5386\u94fe\u8868\u4ee5\u67e5\u627e\u76ee\u6807\u8282\u70b9\uff0c\u5e76\u5c06\u5176\u5220\u9664\u3002

    \u8be5\u65b9\u6cd5\u5b58\u5728\u4e00\u4e9b\u5c40\u9650\u6027\uff0c\u5305\u62ec\uff1a

    • \u5360\u7528\u7a7a\u95f4\u589e\u5927\uff0c\u7531\u4e8e\u94fe\u8868\u6216\u4e8c\u53c9\u6811\u5305\u542b\u8282\u70b9\u6307\u9488\uff0c\u76f8\u6bd4\u6570\u7ec4\u66f4\u52a0\u8017\u8d39\u5185\u5b58\u7a7a\u95f4\uff1b
    • \u67e5\u8be2\u6548\u7387\u964d\u4f4e\uff0c\u56e0\u4e3a\u9700\u8981\u7ebf\u6027\u904d\u5386\u94fe\u8868\u6765\u67e5\u627e\u5bf9\u5e94\u5143\u7d20\uff1b

    \u4ee5\u4e0b\u7ed9\u51fa\u4e86\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\u7684\u7b80\u5355\u5b9e\u73b0\uff0c\u9700\u8981\u6ce8\u610f\uff1a

    • \u4e3a\u4e86\u4f7f\u5f97\u4ee3\u7801\u5c3d\u91cf\u7b80\u77ed\uff0c\u6211\u4eec\u4f7f\u7528\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\u4ee3\u66ff\u94fe\u8868\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u54c8\u5e0c\u8868\uff08\u6570\u7ec4\uff09\u5305\u542b\u591a\u4e2a\u6876\uff0c\u6bcf\u4e2a\u6876\u90fd\u662f\u4e00\u4e2a\u5217\u8868\u3002
    • \u4ee5\u4e0b\u4ee3\u7801\u5b9e\u73b0\u4e86\u54c8\u5e0c\u8868\u6269\u5bb9\u65b9\u6cd5\u3002\u5177\u4f53\u6765\u770b\uff0c\u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7 \\(0.75\\) \u65f6\uff0c\u6211\u4eec\u5c06\u54c8\u5e0c\u8868\u6269\u5bb9\u81f3 \\(2\\) \u500d\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart hash_map_chaining.java
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\nint size; // \u952e\u503c\u5bf9\u6570\u91cf\nint capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\ndouble loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nint extendRatio; // \u6269\u5bb9\u500d\u6570\nList<List<Pair>> buckets; // \u6876\u6570\u7ec4\n/* \u6784\u9020\u65b9\u6cd5 */\npublic HashMapChaining() {\nsize = 0;\ncapacity = 4;\nloadThres = 2 / 3.0;\nextendRatio = 2;\nbuckets = new ArrayList<>(capacity);\nfor (int i = 0; i < capacity; i++) {\nbuckets.add(new ArrayList<>());\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor() {\nreturn (double) size / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nString get(int key) {\nint index = hashFunc(key);\nList<Pair> bucket = buckets.get(index);\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor (Pair pair : bucket) {\nif (pair.key == key) {\nreturn pair.val;\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de null\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, String val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\nList<Pair> bucket = buckets.get(index);\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor (Pair pair : bucket) {\nif (pair.key == key) {\npair.val = val;\nreturn;\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\nPair pair = new Pair(key, val);\nbucket.add(pair);\nsize++;\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\nList<Pair> bucket = buckets.get(index);\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nfor (Pair pair : bucket) {\nif (pair.key == key)\nbucket.remove(pair);\n}\nsize--;\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nList<List<Pair>> bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = new ArrayList<>(capacity);\nfor (int i = 0; i < capacity; i++) {\nbuckets.add(new ArrayList<>());\n}\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (List<Pair> bucket : bucketsTmp) {\nfor (Pair pair : bucket) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print() {\nfor (List<Pair> bucket : buckets) {\nList<String> res = new ArrayList<>();\nfor (Pair pair : bucket) {\nres.add(pair.key + \" -> \" + pair.val);\n}\nSystem.out.println(res);\n}\n}\n}\n
    hash_map_chaining.cpp
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\nprivate:\nint size;                       // \u952e\u503c\u5bf9\u6570\u91cf\nint capacity;                   // \u54c8\u5e0c\u8868\u5bb9\u91cf\ndouble loadThres;               // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nint extendRatio;                // \u6269\u5bb9\u500d\u6570\nvector<vector<Pair *>> buckets; // \u6876\u6570\u7ec4\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nHashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3), extendRatio(2) {\nbuckets.resize(capacity);\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor() {\nreturn (double)size / (double)capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nstring get(int key) {\nint index = hashFunc(key);\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor (Pair *pair : buckets[index]) {\nif (pair->key == key) {\nreturn pair->val;\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de nullptr\nreturn nullptr;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, string val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor (Pair *pair : buckets[index]) {\nif (pair->key == key) {\npair->val = val;\nreturn;\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\nbuckets[index].push_back(new Pair(key, val));\nsize++;\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\nauto &bucket = buckets[index];\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nfor (int i = 0; i < bucket.size(); i++) {\nif (bucket[i]->key == key) {\nPair *tmp = bucket[i];\nbucket.erase(bucket.begin() + i); // \u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\ndelete tmp;                       // \u91ca\u653e\u5185\u5b58\nsize--;\nreturn;\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nvector<vector<Pair *>> bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets.clear();\nbuckets.resize(capacity);\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (auto &bucket : bucketsTmp) {\nfor (Pair *pair : bucket) {\nput(pair->key, pair->val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print() {\nfor (auto &bucket : buckets) {\ncout << \"[\";\nfor (Pair *pair : bucket) {\ncout << pair->key << \" -> \" << pair->val << \", \";\n}\ncout << \"]\\n\";\n}\n}\n};\n
    hash_map_chaining.py
    class HashMapChaining:\n\"\"\"\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\nself.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\nself.load_thres = 2 / 3  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nself.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\nself.buckets = [[] for _ in range(self.capacity)]  # \u6876\u6570\u7ec4\ndef hash_func(self, key: int) -> int:\n\"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\nreturn key % self.capacity\ndef load_factor(self) -> float:\n\"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\nreturn self.size / self.capacity\ndef get(self, key: int) -> str:\n\"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\nindex = self.hash_func(key)\nbucket = self.buckets[index]\n# \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor pair in bucket:\nif pair.key == key:\nreturn pair.val\n# \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de None\nreturn None\ndef put(self, key: int, val: str):\n\"\"\"\u6dfb\u52a0\u64cd\u4f5c\"\"\"\n# \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif self.load_factor() > self.load_thres:\nself.extend()\nindex = self.hash_func(key)\nbucket = self.buckets[index]\n# \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor pair in bucket:\nif pair.key == key:\npair.val = val\nreturn\n# \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\npair = Pair(key, val)\nbucket.append(pair)\nself.size += 1\ndef remove(self, key: int):\n\"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\nindex = self.hash_func(key)\nbucket = self.buckets[index]\n# \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nfor pair in bucket:\nif pair.key == key:\nbucket.remove(pair)\nself.size -= 1\nreturn\ndef extend(self):\n\"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n# \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nbuckets = self.buckets\n# \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\nself.capacity *= self.extend_ratio\nself.buckets = [[] for _ in range(self.capacity)]\nself.size = 0\n# \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor bucket in buckets:\nfor pair in bucket:\nself.put(pair.key, pair.val)\ndef print(self):\n\"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\nfor bucket in self.buckets:\nres = []\nfor pair in bucket:\nres.append(str(pair.key) + \" -> \" + pair.val)\nprint(res)\n
    hash_map_chaining.go
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntype hashMapChaining struct {\nsize        int      // \u952e\u503c\u5bf9\u6570\u91cf\ncapacity    int      // \u54c8\u5e0c\u8868\u5bb9\u91cf\nloadThres   float64  // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nextendRatio int      // \u6269\u5bb9\u500d\u6570\nbuckets     [][]pair // \u6876\u6570\u7ec4\n}\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapChaining() *hashMapChaining {\nbuckets := make([][]pair, 4)\nfor i := 0; i < 4; i++ {\nbuckets[i] = make([]pair, 0)\n}\nreturn &hashMapChaining{\nsize:        0,\ncapacity:    4,\nloadThres:   2 / 3.0,\nextendRatio: 2,\nbuckets:     buckets,\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (m *hashMapChaining) hashFunc(key int) int {\nreturn key % m.capacity\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (m *hashMapChaining) loadFactor() float64 {\nreturn float64(m.size / m.capacity)\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (m *hashMapChaining) get(key int) string {\nidx := m.hashFunc(key)\nbucket := m.buckets[idx]\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor _, p := range bucket {\nif p.key == key {\nreturn p.val\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\nreturn \"\"\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (m *hashMapChaining) put(key int, val string) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif m.loadFactor() > m.loadThres {\nm.extend()\n}\nidx := m.hashFunc(key)\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor _, p := range m.buckets[idx] {\nif p.key == key {\np.val = val\nreturn\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\np := pair{\nkey: key,\nval: val,\n}\nm.buckets[idx] = append(m.buckets[idx], p)\nm.size += 1\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (m *hashMapChaining) remove(key int) {\nidx := m.hashFunc(key)\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nfor i, p := range m.buckets[idx] {\nif p.key == key {\n// \u5207\u7247\u5220\u9664\nm.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\nbreak\n}\n}\nm.size -= 1\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\ntmpBuckets := make([][]pair, len(m.buckets))\nfor i := 0; i < len(m.buckets); i++ {\ntmpBuckets[i] = make([]pair, len(m.buckets[i]))\ncopy(tmpBuckets[i], m.buckets[i])\n}\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\nm.capacity *= m.extendRatio\nm.buckets = make([][]pair, m.capacity)\nfor i := 0; i < m.capacity; i++ {\nm.buckets[i] = make([]pair, 0)\n}\nm.size = 0\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor _, bucket := range tmpBuckets {\nfor _, p := range bucket {\nm.put(p.key, p.val)\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) print() {\nvar builder strings.Builder\nfor _, bucket := range m.buckets {\nbuilder.WriteString(\"[\")\nfor _, p := range bucket {\nbuilder.WriteString(strconv.Itoa(p.key) + \" -> \" + p.val + \" \")\n}\nbuilder.WriteString(\"]\")\nfmt.Println(builder.String())\nbuilder.Reset()\n}\n}\n
    hash_map_chaining.js
    [class]{HashMapChaining}-[func]{}\n
    hash_map_chaining.ts
    [class]{HashMapChaining}-[func]{}\n
    hash_map_chaining.c
    [class]{hashMapChaining}-[func]{}\n
    hash_map_chaining.cs
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\nint size; // \u952e\u503c\u5bf9\u6570\u91cf\nint capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\ndouble loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nint extendRatio; // \u6269\u5bb9\u500d\u6570\nList<List<Pair>> buckets; // \u6876\u6570\u7ec4\n/* \u6784\u9020\u65b9\u6cd5 */\npublic HashMapChaining() {\nsize = 0;\ncapacity = 4;\nloadThres = 2 / 3.0;\nextendRatio = 2;\nbuckets = new List<List<Pair>>(capacity);\nfor (int i = 0; i < capacity; i++) {\nbuckets.Add(new List<Pair>());\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate int hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nprivate double loadFactor() {\nreturn (double)size / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic string get(int key) {\nint index = hashFunc(key);\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nforeach (Pair pair in buckets[index]) {\nif (pair.key == key) {\nreturn pair.val;\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de null\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic void put(int key, string val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nforeach (Pair pair in buckets[index]) {\nif (pair.key == key) {\npair.val = val;\nreturn;\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\nbuckets[index].Add(new Pair(key, val));\nsize++;\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic void remove(int key) {\nint index = hashFunc(key);\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nforeach (Pair pair in buckets[index].ToList()) { if (pair.key == key) {\nbuckets[index].Remove(pair);\n}\n}\nsize--;   }\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nprivate void extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nList<List<Pair>> bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = new List<List<Pair>>(capacity);\nfor (int i = 0; i < capacity; i++) {\nbuckets.Add(new List<Pair>());\n}\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nforeach (List<Pair> bucket in bucketsTmp) {\nforeach (Pair pair in bucket) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic void print() {\nforeach (List<Pair> bucket in buckets) {\nList<string> res = new List<string>();\nforeach (Pair pair in bucket) {\nres.Add(pair.key + \" -> \" + pair.val);\n}\nforeach (string kv in res) {\nConsole.WriteLine(kv);\n}\n}\n}\n}\n
    hash_map_chaining.swift
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\nvar size: Int // \u952e\u503c\u5bf9\u6570\u91cf\nvar capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\nvar loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nvar extendRatio: Int // \u6269\u5bb9\u500d\u6570\nvar buckets: [[Pair]] // \u6876\u6570\u7ec4\n/* \u6784\u9020\u65b9\u6cd5 */\ninit() {\nsize = 0\ncapacity = 4\nloadThres = 2 / 3\nextendRatio = 2\nbuckets = Array(repeating: [], count: capacity)\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc hashFunc(key: Int) -> Int {\nkey % capacity\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc loadFactor() -> Double {\nDouble(size / capacity)\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc get(key: Int) -> String? {\nlet index = hashFunc(key: key)\nlet bucket = buckets[index]\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor pair in bucket {\nif pair.key == key {\nreturn pair.val\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de nil\nreturn nil\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc put(key: Int, val: String) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif loadFactor() > loadThres {\nextend()\n}\nlet index = hashFunc(key: key)\nlet bucket = buckets[index]\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor pair in bucket {\nif pair.key == key {\npair.val = val\nreturn\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\nlet pair = Pair(key: key, val: val)\nbuckets[index].append(pair)\nsize += 1\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc remove(key: Int) {\nlet index = hashFunc(key: key)\nlet bucket = buckets[index]\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nfor (pairIndex, pair) in bucket.enumerated() {\nif pair.key == key {\nbuckets[index].remove(at: pairIndex)\n}\n}\nsize -= 1\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nlet bucketsTmp = buckets\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio\nbuckets = Array(repeating: [], count: capacity)\nsize = 0\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor bucket in bucketsTmp {\nfor pair in bucket {\nput(key: pair.key, val: pair.val)\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc print() {\nfor bucket in buckets {\nlet res = bucket.map { \"\\($0.key) -> \\($0.val)\" }\nSwift.print(res)\n}\n}\n}\n
    hash_map_chaining.zig
    [class]{HashMapChaining}-[func]{}\n
    hash_map_chaining.dart
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\nlate int size; // \u952e\u503c\u5bf9\u6570\u91cf\nlate int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\nlate double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nlate int extendRatio; // \u6269\u5bb9\u500d\u6570\nlate List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n/* \u6784\u9020\u65b9\u6cd5 */\nHashMapChaining() {\nsize = 0;\ncapacity = 4;\nloadThres = 2 / 3.0;\nextendRatio = 2;\nbuckets = List.generate(capacity, (_) => []);\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor() {\nreturn size / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nString? get(int key) {\nint index = hashFunc(key);\nList<Pair> bucket = buckets[index];\n// \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \u5219\u8fd4\u56de\u5bf9\u5e94 val\nfor (Pair pair in bucket) {\nif (pair.key == key) {\nreturn pair.val;\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de null\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, String val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\nList<Pair> bucket = buckets[index];\n// \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\nfor (Pair pair in bucket) {\nif (pair.key == key) {\npair.val = val;\nreturn;\n}\n}\n// \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\nPair pair = Pair(key, val);\nbucket.add(pair);\nsize++;\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\nList<Pair> bucket = buckets[index];\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\nbucket.removeWhere((Pair pair) => pair.key == key);\nsize--;\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nList<List<Pair>> bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = List.generate(capacity, (_) => []);\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (List<Pair> bucket in bucketsTmp) {\nfor (Pair pair in bucket) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid printHashMap() {\nfor (List<Pair> bucket in buckets) {\nList<String> res = [];\nfor (Pair pair in bucket) {\nres.add(\"${pair.key} -> ${pair.val}\");\n}\nprint(res);\n}\n}\n}\n

    Tip

    \u4e3a\u4e86\u63d0\u9ad8\u6548\u7387\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u300cAVL \u6811\u300d\u6216\u300c\u7ea2\u9ed1\u6811\u300d\uff0c\u4ece\u800c\u5c06\u67e5\u8be2\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u81f3 \\(O(\\log n)\\) \u3002

    "},{"location":"chapter_hashing/hash_collision/#622","title":"6.2.2. \u00a0 \u5f00\u653e\u5bfb\u5740","text":"

    \u300c\u5f00\u653e\u5bfb\u5740 Open Addressing\u300d\u4e0d\u5f15\u5165\u989d\u5916\u7684\u6570\u636e\u7ed3\u6784\uff0c\u800c\u662f\u901a\u8fc7\u201c\u591a\u6b21\u63a2\u6d4b\u201d\u6765\u5904\u7406\u54c8\u5e0c\u51b2\u7a81\uff0c\u63a2\u6d4b\u65b9\u5f0f\u4e3b\u8981\u5305\u62ec\u7ebf\u6027\u63a2\u6d4b\u3001\u5e73\u65b9\u63a2\u6d4b\u3001\u591a\u6b21\u54c8\u5e0c\u3002

    "},{"location":"chapter_hashing/hash_collision/#_1","title":"\u7ebf\u6027\u63a2\u6d4b","text":"

    \u7ebf\u6027\u63a2\u6d4b\u91c7\u7528\u56fa\u5b9a\u6b65\u957f\u7684\u7ebf\u6027\u67e5\u627e\u6765\u8fdb\u884c\u63a2\u6d4b\uff0c\u5bf9\u5e94\u7684\u54c8\u5e0c\u8868\u64cd\u4f5c\u65b9\u6cd5\u4e3a\uff1a

    • \u63d2\u5165\u5143\u7d20\uff1a\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u8ba1\u7b97\u6570\u7ec4\u7d22\u5f15\uff0c\u82e5\u53d1\u73b0\u6876\u5185\u5df2\u6709\u5143\u7d20\uff0c\u5219\u4ece\u51b2\u7a81\u4f4d\u7f6e\u5411\u540e\u7ebf\u6027\u904d\u5386\uff08\u6b65\u957f\u901a\u5e38\u4e3a \\(1\\) \uff09\uff0c\u76f4\u81f3\u627e\u5230\u7a7a\u4f4d\uff0c\u5c06\u5143\u7d20\u63d2\u5165\u5176\u4e2d\u3002
    • \u67e5\u627e\u5143\u7d20\uff1a\u82e5\u53d1\u73b0\u54c8\u5e0c\u51b2\u7a81\uff0c\u5219\u4f7f\u7528\u76f8\u540c\u6b65\u957f\u5411\u540e\u7ebf\u6027\u904d\u5386\uff0c\u76f4\u5230\u627e\u5230\u5bf9\u5e94\u5143\u7d20\uff0c\u8fd4\u56de value \u5373\u53ef\uff1b\u6216\u8005\u82e5\u9047\u5230\u7a7a\u4f4d\uff0c\u8bf4\u660e\u76ee\u6807\u952e\u503c\u5bf9\u4e0d\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u8fd4\u56de \\(\\text{None}\\) \u3002

    Fig. \u7ebf\u6027\u63a2\u6d4b

    \u7136\u800c\uff0c\u7ebf\u6027\u63a2\u6d4b\u5b58\u5728\u4ee5\u4e0b\u7f3a\u9677\uff1a

    • \u4e0d\u80fd\u76f4\u63a5\u5220\u9664\u5143\u7d20\u3002\u5220\u9664\u5143\u7d20\u4f1a\u5728\u6570\u7ec4\u5185\u4ea7\u751f\u4e00\u4e2a\u7a7a\u4f4d\uff0c\u67e5\u627e\u5176\u4ed6\u5143\u7d20\u65f6\uff0c\u8be5\u7a7a\u4f4d\u53ef\u80fd\u5bfc\u81f4\u7a0b\u5e8f\u8bef\u5224\u5143\u7d20\u4e0d\u5b58\u5728\u3002\u56e0\u6b64\uff0c\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u6807\u5fd7\u4f4d\u6765\u6807\u8bb0\u5df2\u5220\u9664\u5143\u7d20\u3002
    • \u5bb9\u6613\u4ea7\u751f\u805a\u96c6\u3002\u6570\u7ec4\u5185\u8fde\u7eed\u88ab\u5360\u7528\u4f4d\u7f6e\u8d8a\u957f\uff0c\u8fd9\u4e9b\u8fde\u7eed\u4f4d\u7f6e\u53d1\u751f\u54c8\u5e0c\u51b2\u7a81\u7684\u53ef\u80fd\u6027\u8d8a\u5927\uff0c\u8fdb\u4e00\u6b65\u4fc3\u4f7f\u8fd9\u4e00\u4f4d\u7f6e\u7684\u201c\u805a\u5806\u751f\u957f\u201d\uff0c\u6700\u7ec8\u5bfc\u81f4\u589e\u5220\u67e5\u6539\u64cd\u4f5c\u6548\u7387\u964d\u4f4e\u3002

    \u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u4e3a\u5f00\u653e\u5bfb\u5740\uff08\u7ebf\u6027\u63a2\u6d4b\uff09\u54c8\u5e0c\u8868\u7684\u7b80\u5355\u5b9e\u73b0\uff0c\u91cd\u70b9\u5305\u62ec\uff1a

    • \u6211\u4eec\u4f7f\u7528\u4e00\u4e2a\u56fa\u5b9a\u7684\u952e\u503c\u5bf9\u5b9e\u4f8b removed \u6765\u6807\u8bb0\u5df2\u5220\u9664\u5143\u7d20\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u5f53\u4e00\u4e2a\u6876\u4e3a \\(\\text{None}\\) \u6216 removed \u65f6\uff0c\u8fd9\u4e2a\u6876\u90fd\u662f\u7a7a\u7684\uff0c\u53ef\u7528\u4e8e\u653e\u7f6e\u952e\u503c\u5bf9\u3002
    • \u88ab\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u7a7a\u95f4\u662f\u53ef\u4ee5\u518d\u6b21\u88ab\u4f7f\u7528\u7684\u3002\u5f53\u63d2\u5165\u5143\u7d20\u65f6\uff0c\u82e5\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u627e\u5230\u4e86\u88ab\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u7d22\u5f15\uff0c\u5219\u53ef\u5c06\u8be5\u5143\u7d20\u653e\u7f6e\u5230\u8be5\u7d22\u5f15\u3002
    • \u5728\u7ebf\u6027\u63a2\u6d4b\u65f6\uff0c\u6211\u4eec\u4ece\u5f53\u524d\u7d22\u5f15 index \u5411\u540e\u904d\u5386\uff1b\u800c\u5f53\u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u9700\u8981\u56de\u5230\u5934\u90e8\u7ee7\u7eed\u904d\u5386\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart hash_map_open_addressing.java
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\nprivate int size; // \u952e\u503c\u5bf9\u6570\u91cf\nprivate int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\nprivate double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nprivate int extendRatio; // \u6269\u5bb9\u500d\u6570\nprivate Pair[] buckets; // \u6876\u6570\u7ec4\nprivate Pair removed; // \u5220\u9664\u6807\u8bb0\n/* \u6784\u9020\u65b9\u6cd5 */\npublic HashMapOpenAddressing() {\nsize = 0;\ncapacity = 4;\nloadThres = 2.0 / 3.0;\nextendRatio = 2;\nbuckets = new Pair[capacity];\nremoved = new Pair(-1, \"-1\");\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\npublic int hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\npublic double loadFactor() {\nreturn (double) size / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic String get(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de null\nif (buckets[j] == null)\nreturn null;\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif (buckets[j].key == key && buckets[j] != removed)\nreturn buckets[j].val;\n}\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic void put(int key, String val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif (buckets[j] == null || buckets[j] == removed) {\nbuckets[j] = new Pair(key, val);\nsize += 1;\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif (buckets[j].key == key) {\nbuckets[j].val = val;\nreturn;\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic void remove(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (buckets[j] == null) {\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif (buckets[j].key == key) {\nbuckets[j] = removed;\nsize -= 1;\nreturn;\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\npublic void extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nPair[] bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = new Pair[capacity];\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (Pair pair : bucketsTmp) {\nif (pair != null && pair != removed) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic void print() {\nfor (Pair pair : buckets) {\nif (pair != null) {\nSystem.out.println(pair.key + \" -> \" + pair.val);\n} else {\nSystem.out.println(\"null\");\n}\n}\n}\n}\n
    hash_map_open_addressing.cpp
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\nprivate:\nint size;               // \u952e\u503c\u5bf9\u6570\u91cf\nint capacity;           // \u54c8\u5e0c\u8868\u5bb9\u91cf\ndouble loadThres;       // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nint extendRatio;        // \u6269\u5bb9\u500d\u6570\nvector<Pair *> buckets; // \u6876\u6570\u7ec4\nPair *removed;          // \u5220\u9664\u6807\u8bb0\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nHashMapOpenAddressing() {\n// \u6784\u9020\u65b9\u6cd5\nsize = 0;\ncapacity = 4;\nloadThres = 2.0 / 3.0;\nextendRatio = 2;\nbuckets = vector<Pair *>(capacity, nullptr);\nremoved = new Pair(-1, \"-1\");\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor() {\nreturn static_cast<double>(size) / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nstring get(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de nullptr\nif (buckets[j] == nullptr)\nreturn nullptr;\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif (buckets[j]->key == key && buckets[j] != removed)\nreturn buckets[j]->val;\n}\nreturn nullptr;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, string val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres)\nextend();\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif (buckets[j] == nullptr || buckets[j] == removed) {\nbuckets[j] = new Pair(key, val);\nsize += 1;\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif (buckets[j]->key == key) {\nbuckets[j]->val = val;\nreturn;\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (buckets[j] == nullptr)\nreturn;\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif (buckets[j]->key == key) {\ndelete buckets[j]; // \u91ca\u653e\u5185\u5b58\nbuckets[j] = removed;\nsize -= 1;\nreturn;\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nvector<Pair *> bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = vector<Pair *>(capacity, nullptr);\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (Pair *pair : bucketsTmp) {\nif (pair != nullptr && pair != removed) {\nput(pair->key, pair->val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print() {\nfor (auto &pair : buckets) {\nif (pair != nullptr) {\ncout << pair->key << \" -> \" << pair->val << endl;\n} else {\ncout << \"nullptr\" << endl;\n}\n}\n}\n};\n
    hash_map_open_addressing.py
    class HashMapOpenAddressing:\n\"\"\"\u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\nself.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\nself.load_thres = 2 / 3  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nself.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\nself.buckets: list[Pair | None] = [None] * self.capacity  # \u6876\u6570\u7ec4\nself.removed = Pair(-1, \"-1\")  # \u5220\u9664\u6807\u8bb0\ndef hash_func(self, key: int) -> int:\n\"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\nreturn key % self.capacity\ndef load_factor(self) -> float:\n\"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\nreturn self.size / self.capacity\ndef get(self, key: int) -> str:\n\"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\nindex = self.hash_func(key)\n# \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in range(self.capacity):\n# \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj = (index + i) % self.capacity\n# \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de None\nif self.buckets[j] is None:\nreturn None\n# \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif self.buckets[j].key == key and self.buckets[j] != self.removed:\nreturn self.buckets[j].val\ndef put(self, key: int, val: str):\n\"\"\"\u6dfb\u52a0\u64cd\u4f5c\"\"\"\n# \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif self.load_factor() > self.load_thres:\nself.extend()\nindex = self.hash_func(key)\n# \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in range(self.capacity):\n# \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj = (index + i) % self.capacity\n# \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif self.buckets[j] in [None, self.removed]:\nself.buckets[j] = Pair(key, val)\nself.size += 1\nreturn\n# \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif self.buckets[j].key == key:\nself.buckets[j].val = val\nreturn\ndef remove(self, key: int):\n\"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\nindex = self.hash_func(key)\n# \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in range(self.capacity):\n# \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj = (index + i) % self.capacity\n# \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif self.buckets[j] is None:\nreturn\n# \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif self.buckets[j].key == key:\nself.buckets[j] = self.removed\nself.size -= 1\nreturn\ndef extend(self):\n\"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n# \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nbuckets_tmp = self.buckets\n# \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\nself.capacity *= self.extend_ratio\nself.buckets = [None] * self.capacity\nself.size = 0\n# \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor pair in buckets_tmp:\nif pair not in [None, self.removed]:\nself.put(pair.key, pair.val)\ndef print(self) -> None:\n\"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\nfor pair in self.buckets:\nif pair is not None:\nprint(pair.key, \"->\", pair.val)\nelse:\nprint(\"None\")\n
    hash_map_open_addressing.go
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntype hashMapOpenAddressing struct {\nsize        int     // \u952e\u503c\u5bf9\u6570\u91cf\ncapacity    int     // \u54c8\u5e0c\u8868\u5bb9\u91cf\nloadThres   float64 // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nextendRatio int     // \u6269\u5bb9\u500d\u6570\nbuckets     []pair  // \u6876\u6570\u7ec4\nremoved     pair    // \u5220\u9664\u6807\u8bb0\n}\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\nbuckets := make([]pair, 4)\nreturn &hashMapOpenAddressing{\nsize:        0,\ncapacity:    4,\nloadThres:   2 / 3.0,\nextendRatio: 2,\nbuckets:     buckets,\nremoved: pair{\nkey: -1,\nval: \"-1\",\n},\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (m *hashMapOpenAddressing) hashFunc(key int) int {\nreturn key % m.capacity\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (m *hashMapOpenAddressing) loadFactor() float64 {\nreturn float64(m.size) / float64(m.capacity)\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (m *hashMapOpenAddressing) get(key int) string {\nidx := m.hashFunc(key)\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i := 0; i < m.capacity; i++ {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj := (idx + 1) % m.capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de null\nif m.buckets[j] == (pair{}) {\nreturn \"\"\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif m.buckets[j].key == key && m.buckets[j] != m.removed {\nreturn m.buckets[j].val\n}\n}\n// \u82e5\u672a\u627e\u5230 key \u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\nreturn \"\"\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (m *hashMapOpenAddressing) put(key int, val string) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif m.loadFactor() > m.loadThres {\nm.extend()\n}\nidx := m.hashFunc(key)\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i := 0; i < m.capacity; i++ {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj := (idx + i) % m.capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif m.buckets[j] == (pair{}) || m.buckets[j] == m.removed {\nm.buckets[j] = pair{\nkey: key,\nval: val,\n}\nm.size += 1\nreturn\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif m.buckets[j].key == key {\nm.buckets[j].val = val\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (m *hashMapOpenAddressing) remove(key int) {\nidx := m.hashFunc(key)\n// \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i := 0; i < m.capacity; i++ {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nj := (idx + 1) % m.capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif m.buckets[j] == (pair{}) {\nreturn\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif m.buckets[j].key == key {\nm.buckets[j] = m.removed\nm.size -= 1\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (m *hashMapOpenAddressing) extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\ntmpBuckets := make([]pair, len(m.buckets))\ncopy(tmpBuckets, m.buckets)\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\nm.capacity *= m.extendRatio\nm.buckets = make([]pair, m.capacity)\nm.size = 0\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor _, p := range tmpBuckets {\nif p != (pair{}) && p != m.removed {\nm.put(p.key, p.val)\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (m *hashMapOpenAddressing) print() {\nfor _, p := range m.buckets {\nif p != (pair{}) {\nfmt.Println(strconv.Itoa(p.key) + \" -> \" + p.val)\n} else {\nfmt.Println(\"nil\")\n}\n}\n}\n
    hash_map_open_addressing.js
    [class]{HashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.ts
    [class]{HashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.c
    [class]{hashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.cs
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\nint size; // \u952e\u503c\u5bf9\u6570\u91cf\nint capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\ndouble loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nint extendRatio; // \u6269\u5bb9\u500d\u6570\nPair[] buckets; // \u6876\u6570\u7ec4\nPair removed; // \u5220\u9664\u6807\u8bb0\n/* \u6784\u9020\u65b9\u6cd5 */\npublic HashMapOpenAddressing() {\nsize = 0;\ncapacity = 4;\nloadThres = 2.0 / 3.0;\nextendRatio = 2;\nbuckets = new Pair[capacity];\nremoved = new Pair(-1, \"-1\");\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate int hashFunc(int key) {\nreturn key % capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nprivate double loadFactor() {\nreturn (double)size / capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic string get(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de null\nif (buckets[j] == null)\nreturn null;\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif (buckets[j].key == key && buckets[j] != removed)\nreturn buckets[j].val;\n}\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic void put(int key, string val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > loadThres) {\nextend();\n}\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif (buckets[j] == null || buckets[j] == removed) {\nbuckets[j] = new Pair(key, val);\nsize += 1;\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif (buckets[j].key == key) {\nbuckets[j].val = val;\nreturn;\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic void remove(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (buckets[j] == null) {\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif (buckets[j].key == key) {\nbuckets[j] = removed;\nsize -= 1;\nreturn;\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nprivate void extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nPair[] bucketsTmp = buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio;\nbuckets = new Pair[capacity];\nsize = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nforeach (Pair pair in bucketsTmp) {\nif (pair != null && pair != removed) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic void print() {\nforeach (Pair pair in buckets) {\nif (pair != null) {\nConsole.WriteLine(pair.key + \" -> \" + pair.val);\n} else {\nConsole.WriteLine(\"null\");\n}\n}\n}\n}\n
    hash_map_open_addressing.swift
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\nvar size: Int // \u952e\u503c\u5bf9\u6570\u91cf\nvar capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\nvar loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nvar extendRatio: Int // \u6269\u5bb9\u500d\u6570\nvar buckets: [Pair?] // \u6876\u6570\u7ec4\nvar removed: Pair // \u5220\u9664\u6807\u8bb0\n/* \u6784\u9020\u65b9\u6cd5 */\ninit() {\nsize = 0\ncapacity = 4\nloadThres = 2 / 3\nextendRatio = 2\nbuckets = Array(repeating: nil, count: capacity)\nremoved = Pair(key: -1, val: \"-1\")\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc hashFunc(key: Int) -> Int {\nkey % capacity\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc loadFactor() -> Double {\nDouble(size / capacity)\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc get(key: Int) -> String? {\nlet index = hashFunc(key: key)\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in stride(from: 0, to: capacity, by: 1) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nlet j = (index + i) % capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de nil\nif buckets[j] == nil {\nreturn nil\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif buckets[j]?.key == key, buckets[j] != removed {\nreturn buckets[j]?.val\n}\n}\nreturn nil\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc put(key: Int, val: String) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif loadFactor() > loadThres {\nextend()\n}\nlet index = hashFunc(key: key)\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in stride(from: 0, through: capacity, by: 1) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nlet j = (index + i) % capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif buckets[j] == nil || buckets[j] == removed {\nbuckets[j] = Pair(key: key, val: val)\nsize += 1\nreturn\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif buckets[j]?.key == key {\nbuckets[j]?.val = val\nreturn\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc remove(key: Int) {\nlet index = hashFunc(key: key)\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor i in stride(from: 0, to: capacity, by: 1) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nlet j = (index + i) % capacity\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif buckets[j] == nil {\nreturn\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif buckets[j]?.key == key {\nbuckets[j] = removed\nsize -= 1\nreturn\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nlet bucketsTmp = buckets\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\ncapacity *= extendRatio\nbuckets = Array(repeating: nil, count: capacity)\nsize = 0\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor pair in bucketsTmp {\nif let pair, pair != removed {\nput(key: pair.key, val: pair.val)\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc print() {\nfor pair in buckets {\nif let pair {\nSwift.print(\"\\(pair.key) -> \\(pair.val)\")\n} else {\nSwift.print(\"null\")\n}\n}\n}\n}\n
    hash_map_open_addressing.zig
    [class]{HashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.dart
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\nlate int _size; // \u952e\u503c\u5bf9\u6570\u91cf\nlate int _capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\nlate double _loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\nlate int _extendRatio; // \u6269\u5bb9\u500d\u6570\nlate List<Pair?> _buckets; // \u6876\u6570\u7ec4\nlate Pair _removed; // \u5220\u9664\u6807\u8bb0\n/* \u6784\u9020\u65b9\u6cd5 */\nHashMapOpenAddressing() {\n_size = 0;\n_capacity = 4;\n_loadThres = 2.0 / 3.0;\n_extendRatio = 2;\n_buckets = List.generate(_capacity, (index) => null);\n_removed = Pair(-1, \"-1\");\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nreturn key % _capacity;\n}\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor() {\nreturn _size / _capacity;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nString? get(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < _capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % _capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u8fd4\u56de null\nif (_buckets[j] == null) return null;\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\nif (_buckets[j]!.key == key && _buckets[j] != _removed)\nreturn _buckets[j]!.val;\n}\nreturn null;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, String val) {\n// \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\nif (loadFactor() > _loadThres) {\nextend();\n}\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < _capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % _capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\u3001\u6216\u5e26\u6709\u5220\u9664\u6807\u8bb0\u7684\u6876\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u653e\u5165\u8be5\u6876\nif (_buckets[j] == null || _buckets[j] == _removed) {\n_buckets[j] = new Pair(key, val);\n_size += 1;\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val\nif (_buckets[j]!.key == key) {\n_buckets[j]!.val = val;\nreturn;\n}\n}\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\n// \u7ebf\u6027\u63a2\u6d4b\uff0c\u4ece index \u5f00\u59cb\u5411\u540e\u904d\u5386\nfor (int i = 0; i < _capacity; i++) {\n// \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u8fd4\u56de\u5934\u90e8\nint j = (index + i) % _capacity;\n// \u82e5\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u65e0\u6b64 key \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (_buckets[j] == null) {\nreturn;\n}\n// \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u6807\u8bb0\u5220\u9664\u5e76\u8fd4\u56de\nif (_buckets[j]!.key == key) {\n_buckets[j] = _removed;\n_size -= 1;\nreturn;\n}\n}\n}\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend() {\n// \u6682\u5b58\u539f\u54c8\u5e0c\u8868\nList<Pair?> bucketsTmp = _buckets;\n// \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n_capacity *= _extendRatio;\n_buckets = List.generate(_capacity, (index) => null);\n_size = 0;\n// \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\nfor (Pair? pair in bucketsTmp) {\nif (pair != null && pair != _removed) {\nput(pair.key, pair.val);\n}\n}\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid printHashMap() {\nfor (Pair? pair in _buckets) {\nif (pair != null) {\nprint(\"${pair.key} -> ${pair.val}\");\n} else {\nprint(null);\n}\n}\n}\n}\n
    "},{"location":"chapter_hashing/hash_collision/#_2","title":"\u591a\u6b21\u54c8\u5e0c","text":"

    \u987e\u540d\u601d\u4e49\uff0c\u591a\u6b21\u54c8\u5e0c\u65b9\u6cd5\u662f\u4f7f\u7528\u591a\u4e2a\u54c8\u5e0c\u51fd\u6570 \\(f_1(x)\\) , \\(f_2(x)\\) , \\(f_3(x)\\) , \\(\\cdots\\) \u8fdb\u884c\u63a2\u6d4b\u3002

    • \u63d2\u5165\u5143\u7d20\uff1a\u82e5\u54c8\u5e0c\u51fd\u6570 \\(f_1(x)\\) \u51fa\u73b0\u51b2\u7a81\uff0c\u5219\u5c1d\u8bd5 \\(f_2(x)\\) \uff0c\u4ee5\u6b64\u7c7b\u63a8\uff0c\u76f4\u5230\u627e\u5230\u7a7a\u4f4d\u540e\u63d2\u5165\u5143\u7d20\u3002
    • \u67e5\u627e\u5143\u7d20\uff1a\u5728\u76f8\u540c\u7684\u54c8\u5e0c\u51fd\u6570\u987a\u5e8f\u4e0b\u8fdb\u884c\u67e5\u627e\uff0c\u76f4\u5230\u627e\u5230\u76ee\u6807\u5143\u7d20\u65f6\u8fd4\u56de\uff1b\u6216\u9047\u5230\u7a7a\u4f4d\u6216\u5df2\u5c1d\u8bd5\u6240\u6709\u54c8\u5e0c\u51fd\u6570\uff0c\u8bf4\u660e\u54c8\u5e0c\u8868\u4e2d\u4e0d\u5b58\u5728\u8be5\u5143\u7d20\uff0c\u5219\u8fd4\u56de \\(\\text{None}\\) \u3002

    \u4e0e\u7ebf\u6027\u63a2\u6d4b\u76f8\u6bd4\uff0c\u591a\u6b21\u54c8\u5e0c\u65b9\u6cd5\u4e0d\u6613\u4ea7\u751f\u805a\u96c6\uff0c\u4f46\u591a\u4e2a\u54c8\u5e0c\u51fd\u6570\u4f1a\u589e\u52a0\u989d\u5916\u7684\u8ba1\u7b97\u91cf\u3002

    \u7f16\u7a0b\u8bed\u8a00\u7684\u9009\u62e9

    Java \u91c7\u7528\u94fe\u5f0f\u5730\u5740\u3002\u81ea JDK 1.8 \u4ee5\u6765\uff0c\u5f53 HashMap \u5185\u6570\u7ec4\u957f\u5ea6\u8fbe\u5230 64 \u4e14\u94fe\u8868\u957f\u5ea6\u8fbe\u5230 8 \u65f6\uff0c\u94fe\u8868\u4f1a\u88ab\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811\u4ee5\u63d0\u5347\u67e5\u627e\u6027\u80fd\u3002

    Python \u91c7\u7528\u5f00\u653e\u5bfb\u5740\u3002\u5b57\u5178 dict \u4f7f\u7528\u4f2a\u968f\u673a\u6570\u8fdb\u884c\u63a2\u6d4b\u3002

    Golang \u91c7\u7528\u94fe\u5f0f\u5730\u5740\u3002Go \u89c4\u5b9a\u6bcf\u4e2a\u6876\u6700\u591a\u5b58\u50a8 8 \u4e2a\u952e\u503c\u5bf9\uff0c\u8d85\u51fa\u5bb9\u91cf\u5219\u8fde\u63a5\u4e00\u4e2a\u6ea2\u51fa\u6876\uff1b\u5f53\u6ea2\u51fa\u6876\u8fc7\u591a\u65f6\uff0c\u4f1a\u6267\u884c\u4e00\u6b21\u7279\u6b8a\u7684\u7b49\u91cf\u6269\u5bb9\u64cd\u4f5c\uff0c\u4ee5\u786e\u4fdd\u6027\u80fd\u3002

    "},{"location":"chapter_hashing/hash_map/","title":"6.1. \u00a0 \u54c8\u5e0c\u8868","text":"

    \u300c\u54c8\u5e0c\u8868 Hash Table\u300d\u901a\u8fc7\u5efa\u7acb\u952e key \u4e0e\u503c value \u4e4b\u95f4\u7684\u6620\u5c04\uff0c\u5b9e\u73b0\u9ad8\u6548\u7684\u5143\u7d20\u67e5\u8be2\u3002\u5177\u4f53\u800c\u8a00\uff0c\u6211\u4eec\u5411\u54c8\u5e0c\u8868\u8f93\u5165\u4e00\u4e2a key \uff0c\u5219\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u83b7\u53d6\u5bf9\u5e94\u7684 value \u3002

    \u4ee5\u4e00\u4e2a\u5305\u542b \\(n\\) \u4e2a\u5b66\u751f\u7684\u6570\u636e\u5e93\u4e3a\u4f8b\uff0c\u6bcf\u4e2a\u5b66\u751f\u90fd\u6709\u201c\u59d3\u540d\u201d\u548c\u201c\u5b66\u53f7\u201d\u4e24\u9879\u6570\u636e\u3002\u5047\u5982\u6211\u4eec\u5e0c\u671b\u5b9e\u73b0\u201c\u8f93\u5165\u4e00\u4e2a\u5b66\u53f7\uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u59d3\u540d\u201d\u7684\u67e5\u8be2\u529f\u80fd\uff0c\u5219\u53ef\u4ee5\u91c7\u7528\u54c8\u5e0c\u8868\u6765\u5b9e\u73b0\u3002

    Fig. \u54c8\u5e0c\u8868\u7684\u62bd\u8c61\u8868\u793a

    \u9664\u54c8\u5e0c\u8868\u5916\uff0c\u6211\u4eec\u8fd8\u53ef\u4ee5\u4f7f\u7528\u6570\u7ec4\u6216\u94fe\u8868\u5b9e\u73b0\u67e5\u8be2\u529f\u80fd\u3002\u82e5\u5c06\u5b66\u751f\u6570\u636e\u770b\u4f5c\u6570\u7ec4\uff08\u94fe\u8868\uff09\u5143\u7d20\uff0c\u5219\u6709\uff1a

    • \u6dfb\u52a0\u5143\u7d20\uff1a\u4ec5\u9700\u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u6570\u7ec4\uff08\u94fe\u8868\uff09\u7684\u5c3e\u90e8\u5373\u53ef\uff0c\u4f7f\u7528 \\(O(1)\\) \u65f6\u95f4\uff1b
    • \u67e5\u8be2\u5143\u7d20\uff1a\u7531\u4e8e\u6570\u7ec4\uff08\u94fe\u8868\uff09\u662f\u4e71\u5e8f\u7684\uff0c\u56e0\u6b64\u9700\u8981\u904d\u5386\u6570\u7ec4\uff08\u94fe\u8868\uff09\u4e2d\u7684\u6240\u6709\u5143\u7d20\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\uff1b
    • \u5220\u9664\u5143\u7d20\uff1a\u9700\u8981\u5148\u67e5\u8be2\u5230\u5143\u7d20\uff0c\u518d\u4ece\u6570\u7ec4\u4e2d\u5220\u9664\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\uff1b
    \u6570\u7ec4 \u94fe\u8868 \u54c8\u5e0c\u8868 \u67e5\u627e\u5143\u7d20 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) \u6dfb\u52a0\u5143\u7d20 \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) \u5220\u9664\u5143\u7d20 \\(O(n)\\) \\(O(n)\\) \\(O(1)\\)

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u5728\u54c8\u5e0c\u8868\u4e2d\u8fdb\u884c\u589e\u5220\u67e5\u6539\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u662f \\(O(1)\\) \uff0c\u975e\u5e38\u9ad8\u6548\u3002\u56e0\u6b64\uff0c\u54c8\u5e0c\u8868\u5e38\u7528\u4e8e\u5bf9\u67e5\u627e\u6548\u7387\u8981\u6c42\u8f83\u9ad8\u7684\u573a\u666f\u3002

    "},{"location":"chapter_hashing/hash_map/#611","title":"6.1.1. \u00a0 \u54c8\u5e0c\u8868\u5e38\u7528\u64cd\u4f5c","text":"

    \u54c8\u5e0c\u8868\u7684\u5e38\u89c1\u64cd\u4f5c\u5305\u62ec\uff1a\u521d\u59cb\u5316\u3001\u67e5\u8be2\u64cd\u4f5c\u3001\u6dfb\u52a0\u952e\u503c\u5bf9\u548c\u5220\u9664\u952e\u503c\u5bf9\u7b49\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart hash_map.java
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nMap<Integer, String> map = new HashMap<>();\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.put(12836, \"\u5c0f\u54c8\");   map.put(15937, \"\u5c0f\u5570\");   map.put(16750, \"\u5c0f\u7b97\");   map.put(13276, \"\u5c0f\u6cd5\");\nmap.put(10583, \"\u5c0f\u9e2d\");\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nString name = map.get(15937);\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.remove(10583);\n
    hash_map.cpp
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nunordered_map<int, string> map;\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap[12836] = \"\u5c0f\u54c8\";\nmap[15937] = \"\u5c0f\u5570\";\nmap[16750] = \"\u5c0f\u7b97\";\nmap[13276] = \"\u5c0f\u6cd5\";\nmap[10583] = \"\u5c0f\u9e2d\";\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nstring name = map[15937];\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.erase(10583);\n
    hash_map.py
    # \u521d\u59cb\u5316\u54c8\u5e0c\u8868\nmapp: Dict = {}\n# \u6dfb\u52a0\u64cd\u4f5c\n# \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmapp[12836] = \"\u5c0f\u54c8\"\nmapp[15937] = \"\u5c0f\u5570\"\nmapp[16750] = \"\u5c0f\u7b97\"\nmapp[13276] = \"\u5c0f\u6cd5\"\nmapp[10583] = \"\u5c0f\u9e2d\"\n# \u67e5\u8be2\u64cd\u4f5c\n# \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nname: str = mapp[15937]\n# \u5220\u9664\u64cd\u4f5c\n# \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmapp.pop(10583)\n
    hash_map.go
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nmapp := make(map[int]string)\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmapp[12836] = \"\u5c0f\u54c8\"\nmapp[15937] = \"\u5c0f\u5570\"\nmapp[16750] = \"\u5c0f\u7b97\"\nmapp[13276] = \"\u5c0f\u6cd5\"\nmapp[10583] = \"\u5c0f\u9e2d\"\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nname := mapp[15937]\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\ndelete(mapp, 10583)\n
    hash_map.js
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nconst map = new ArrayHashMap();\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.set(12836, '\u5c0f\u54c8');\nmap.set(15937, '\u5c0f\u5570');\nmap.set(16750, '\u5c0f\u7b97');\nmap.set(13276, '\u5c0f\u6cd5');\nmap.set(10583, '\u5c0f\u9e2d');\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet name = map.get(15937);\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.delete(10583);\n
    hash_map.ts
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nconst map = new Map<number, string>();\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.set(12836, '\u5c0f\u54c8');\nmap.set(15937, '\u5c0f\u5570');\nmap.set(16750, '\u5c0f\u7b97');\nmap.set(13276, '\u5c0f\u6cd5');\nmap.set(10583, '\u5c0f\u9e2d');\nconsole.info('\\n\u6dfb\u52a0\u5b8c\u6210\u540e\uff0c\u54c8\u5e0c\u8868\u4e3a\\nKey -> Value');\nconsole.info(map);\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet name = map.get(15937);\nconsole.info('\\n\u8f93\u5165\u5b66\u53f7 15937 \uff0c\u67e5\u8be2\u5230\u59d3\u540d ' + name);\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.delete(10583);\nconsole.info('\\n\u5220\u9664 10583 \u540e\uff0c\u54c8\u5e0c\u8868\u4e3a\\nKey -> Value');\nconsole.info(map);\n
    hash_map.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u54c8\u5e0c\u8868\n
    hash_map.cs
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nDictionary<int, String> map = new ();\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.Add(12836, \"\u5c0f\u54c8\");\nmap.Add(15937, \"\u5c0f\u5570\");\nmap.Add(16750, \"\u5c0f\u7b97\");\nmap.Add(13276, \"\u5c0f\u6cd5\");\nmap.Add(10583, \"\u5c0f\u9e2d\");\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nString name = map[15937];\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.Remove(10583);\n
    hash_map.swift
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nvar map: [Int: String] = [:]\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap[12836] = \"\u5c0f\u54c8\"\nmap[15937] = \"\u5c0f\u5570\"\nmap[16750] = \"\u5c0f\u7b97\"\nmap[13276] = \"\u5c0f\u6cd5\"\nmap[10583] = \"\u5c0f\u9e2d\"\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet name = map[15937]!\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.removeValue(forKey: 10583)\n
    hash_map.zig
    \n
    hash_map.dart
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nMap<int, String> map = {};\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap[12836] = \"\u5c0f\u54c8\";\nmap[15937] = \"\u5c0f\u5570\";\nmap[16750] = \"\u5c0f\u7b97\";\nmap[13276] = \"\u5c0f\u6cd5\";\nmap[10583] = \"\u5c0f\u9e2d\";\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nString name = map[15937];\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.remove(10583);\n

    \u54c8\u5e0c\u8868\u6709\u4e09\u79cd\u5e38\u7528\u904d\u5386\u65b9\u5f0f\uff1a\u904d\u5386\u952e\u503c\u5bf9\u3001\u904d\u5386\u952e\u548c\u904d\u5386\u503c\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart hash_map.java
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor (Map.Entry <Integer, String> kv: map.entrySet()) {\nSystem.out.println(kv.getKey() + \" -> \" + kv.getValue());\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor (int key: map.keySet()) {\nSystem.out.println(key);\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor (String val: map.values()) {\nSystem.out.println(val);\n}\n
    hash_map.cpp
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor (auto kv: map) {\ncout << kv.first << \" -> \" << kv.second << endl;\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor (auto key: map) {\ncout << key.first << endl;\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor (auto val: map) {\ncout << val.second << endl;\n}\n
    hash_map.py
    # \u904d\u5386\u54c8\u5e0c\u8868\n# \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor key, value in mapp.items():\nprint(key, \"->\", value)\n# \u5355\u72ec\u904d\u5386\u952e key\nfor key in mapp.keys():\nprint(key)\n# \u5355\u72ec\u904d\u5386\u503c value\nfor value in mapp.values():\nprint(value)\n
    hash_map_test.go
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor key, value := range mapp {\nfmt.Println(key, \"->\", value)\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor key := range mapp {\nfmt.Println(key)\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor _, value := range mapp {\nfmt.Println(value)\n}\n
    hash_map.js
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\nconsole.info('\\n\u904d\u5386\u952e\u503c\u5bf9 Key->Value');\nfor (const [k, v] of map.entries()) {\nconsole.info(k + ' -> ' + v);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u952e Key');\nfor (const k of map.keys()) {\nconsole.info(k);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u503c Value');\nfor (const v of map.values()) {\nconsole.info(v);\n}\n
    hash_map.ts
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\nconsole.info('\\n\u904d\u5386\u952e\u503c\u5bf9 Key->Value');\nfor (const [k, v] of map.entries()) {\nconsole.info(k + ' -> ' + v);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u952e Key');\nfor (const k of map.keys()) {\nconsole.info(k);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u503c Value');\nfor (const v of map.values()) {\nconsole.info(v);\n}\n
    hash_map.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u54c8\u5e0c\u8868\n
    hash_map.cs
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nforeach (var kv in map)\n{\nConsole.WriteLine(kv.Key + \" -> \" + kv.Value);\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nforeach (int key in map.Keys)\n{\nConsole.WriteLine(key);\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nforeach (String val in map.Values)\n{\nConsole.WriteLine(val);\n}\n
    hash_map.swift
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nfor (key, value) in map {\nprint(\"\\(key) -> \\(value)\")\n}\n// \u5355\u72ec\u904d\u5386\u952e Key\nfor key in map.keys {\nprint(key)\n}\n// \u5355\u72ec\u904d\u5386\u503c Value\nfor value in map.values {\nprint(value)\n}\n
    hash_map.zig
    \n
    hash_map.dart
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nmap.forEach((key, value) {\nprint('$key -> $value');\n});\n// \u5355\u72ec\u904d\u5386\u952e Key\nmap.keys.forEach((key) {\nprint(key);\n});\n// \u5355\u72ec\u904d\u5386\u503c Value\nmap.values.forEach((value) {\nprint(value);\n});\n
    "},{"location":"chapter_hashing/hash_map/#612","title":"6.1.2. \u00a0 \u54c8\u5e0c\u8868\u7b80\u5355\u5b9e\u73b0","text":"

    \u6211\u4eec\u5148\u8003\u8651\u6700\u7b80\u5355\u7684\u60c5\u51b5\uff0c\u4ec5\u7528\u4e00\u4e2a\u6570\u7ec4\u6765\u5b9e\u73b0\u54c8\u5e0c\u8868\u3002\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u6211\u4eec\u5c06\u6570\u7ec4\u4e2d\u7684\u6bcf\u4e2a\u7a7a\u4f4d\u79f0\u4e3a\u300c\u6876 Bucket\u300d\uff0c\u6bcf\u4e2a\u6876\u53ef\u5b58\u50a8\u4e00\u4e2a\u952e\u503c\u5bf9\u3002\u56e0\u6b64\uff0c\u67e5\u8be2\u64cd\u4f5c\u5c31\u662f\u627e\u5230 key \u5bf9\u5e94\u7684\u6876\uff0c\u5e76\u5728\u6876\u4e2d\u83b7\u53d6 value \u3002

    \u90a3\u4e48\uff0c\u5982\u4f55\u57fa\u4e8e key \u6765\u5b9a\u4f4d\u5bf9\u5e94\u7684\u6876\u5462\uff1f\u8fd9\u662f\u901a\u8fc7\u300c\u54c8\u5e0c\u51fd\u6570 Hash Function\u300d\u5b9e\u73b0\u7684\u3002\u54c8\u5e0c\u51fd\u6570\u7684\u4f5c\u7528\u662f\u5c06\u4e00\u4e2a\u8f83\u5927\u7684\u8f93\u5165\u7a7a\u95f4\u6620\u5c04\u5230\u4e00\u4e2a\u8f83\u5c0f\u7684\u8f93\u51fa\u7a7a\u95f4\u3002\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u8f93\u5165\u7a7a\u95f4\u662f\u6240\u6709 key \uff0c\u8f93\u51fa\u7a7a\u95f4\u662f\u6240\u6709\u6876\uff08\u6570\u7ec4\u7d22\u5f15\uff09\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u8f93\u5165\u4e00\u4e2a key \uff0c\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u5f97\u5230\u8be5 key \u5bf9\u5e94\u7684\u952e\u503c\u5bf9\u5728\u6570\u7ec4\u4e2d\u7684\u5b58\u50a8\u4f4d\u7f6e\u3002

    \u8f93\u5165\u4e00\u4e2a key \uff0c\u54c8\u5e0c\u51fd\u6570\u7684\u8ba1\u7b97\u8fc7\u7a0b\u5206\u4e3a\u4e24\u6b65\uff1a\u9996\u5148\uff0c\u901a\u8fc7\u54c8\u5e0c\u7b97\u6cd5 hash() \u8ba1\u7b97\u5f97\u5230\u54c8\u5e0c\u503c\uff1b\u63a5\u4e0b\u6765\uff0c\u5c06\u54c8\u5e0c\u503c\u5bf9\u6876\u6570\u91cf\uff08\u6570\u7ec4\u957f\u5ea6\uff09capacity \u53d6\u6a21\uff0c\u4ece\u800c\u83b7\u53d6\u8be5 key \u5bf9\u5e94\u7684\u6570\u7ec4\u7d22\u5f15 index \u3002

    index = hash(key) % capacity\n

    \u968f\u540e\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5229\u7528 index \u5728\u54c8\u5e0c\u8868\u4e2d\u8bbf\u95ee\u5bf9\u5e94\u7684\u6876\uff0c\u4ece\u800c\u83b7\u53d6 value \u3002

    \u8bbe\u6570\u7ec4\u957f\u5ea6 capacity = 100 \u3001\u54c8\u5e0c\u7b97\u6cd5 hash(key) = key \uff0c\u6613\u5f97\u54c8\u5e0c\u51fd\u6570\u4e3a key % 100 \u3002\u4e0b\u56fe\u4ee5 key \u5b66\u53f7\u548c value \u59d3\u540d\u4e3a\u4f8b\uff0c\u5c55\u793a\u4e86\u54c8\u5e0c\u51fd\u6570\u7684\u5de5\u4f5c\u539f\u7406\u3002

    Fig. \u54c8\u5e0c\u51fd\u6570\u5de5\u4f5c\u539f\u7406

    \u4ee5\u4e0b\u4ee3\u7801\u7ed9\u51fa\u4e86\u4e00\u4e2a\u7b80\u5355\u54c8\u5e0c\u8868\u5b9e\u73b0\u3002\u5176\u4e2d\uff0c\u6211\u4eec\u5c06 key \u548c value \u5c01\u88c5\u6210\u4e00\u4e2a\u7c7b Pair \uff0c\u4ee5\u8868\u793a\u952e\u503c\u5bf9\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array_hash_map.java
    /* \u952e\u503c\u5bf9 */\nclass Pair {\npublic int key;\npublic String val;\npublic Pair(int key, String val) {\nthis.key = key;\nthis.val = val;\n}\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nprivate List<Pair> buckets;\npublic ArrayHashMap() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nbuckets = new ArrayList<>();\nfor (int i = 0; i < 100; i++) {\nbuckets.add(null);\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate int hashFunc(int key) {\nint index = key % 100;\nreturn index;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic String get(int key) {\nint index = hashFunc(key);\nPair pair = buckets.get(index);\nif (pair == null)\nreturn null;\nreturn pair.val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic void put(int key, String val) {\nPair pair = new Pair(key, val);\nint index = hashFunc(key);\nbuckets.set(index, pair);\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic void remove(int key) {\nint index = hashFunc(key);\n// \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\nbuckets.set(index, null);\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\npublic List<Pair> pairSet() {\nList<Pair> pairSet = new ArrayList<>();\nfor (Pair pair : buckets) {\nif (pair != null)\npairSet.add(pair);\n}\nreturn pairSet;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\npublic List<Integer> keySet() {\nList<Integer> keySet = new ArrayList<>();\nfor (Pair pair : buckets) {\nif (pair != null)\nkeySet.add(pair.key);\n}\nreturn keySet;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\npublic List<String> valueSet() {\nList<String> valueSet = new ArrayList<>();\nfor (Pair pair : buckets) {\nif (pair != null)\nvalueSet.add(pair.val);\n}\nreturn valueSet;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic void print() {\nfor (Pair kv : pairSet()) {\nSystem.out.println(kv.key + \" -> \" + kv.val);\n}\n}\n}\n
    array_hash_map.cpp
    /* \u952e\u503c\u5bf9 */\nstruct Pair {\npublic:\nint key;\nstring val;\nPair(int key, string val) {\nthis->key = key;\nthis->val = val;\n}\n};\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nprivate:\nvector<Pair *> buckets;\npublic:\nArrayHashMap() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nbuckets = vector<Pair *>(100);\n}\n~ArrayHashMap() {\n// \u91ca\u653e\u5185\u5b58\nfor (const auto &bucket : buckets) {\ndelete bucket;\n}\nbuckets.clear();\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(int key) {\nint index = key % 100;\nreturn index;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nstring get(int key) {\nint index = hashFunc(key);\nPair *pair = buckets[index];\nif (pair == nullptr)\nreturn nullptr;\nreturn pair->val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, string val) {\nPair *pair = new Pair(key, val);\nint index = hashFunc(key);\nbuckets[index] = pair;\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nint index = hashFunc(key);\n// \u91ca\u653e\u5185\u5b58\u5e76\u7f6e\u4e3a nullptr\ndelete buckets[index];\nbuckets[index] = nullptr;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nvector<Pair *> pairSet() {\nvector<Pair *> pairSet;\nfor (Pair *pair : buckets) {\nif (pair != nullptr) {\npairSet.push_back(pair);\n}\n}\nreturn pairSet;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\nvector<int> keySet() {\nvector<int> keySet;\nfor (Pair *pair : buckets) {\nif (pair != nullptr) {\nkeySet.push_back(pair->key);\n}\n}\nreturn keySet;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\nvector<string> valueSet() {\nvector<string> valueSet;\nfor (Pair *pair : buckets) {\nif (pair != nullptr) {\nvalueSet.push_back(pair->val);\n}\n}\nreturn valueSet;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print() {\nfor (Pair *kv : pairSet()) {\ncout << kv->key << \" -> \" << kv->val << endl;\n}\n}\n};\n
    array_hash_map.py
    class Pair:\n\"\"\"\u952e\u503c\u5bf9\"\"\"\ndef __init__(self, key: int, val: str):\nself.key = key\nself.val = val\nclass ArrayHashMap:\n\"\"\"\u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n# \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nself.buckets: list[Pair | None] = [None] * 100\ndef hash_func(self, key: int) -> int:\n\"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\nindex = key % 100\nreturn index\ndef get(self, key: int) -> str:\n\"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\nindex: int = self.hash_func(key)\npair: Pair = self.buckets[index]\nif pair is None:\nreturn None\nreturn pair.val\ndef put(self, key: int, val: str):\n\"\"\"\u6dfb\u52a0\u64cd\u4f5c\"\"\"\npair = Pair(key, val)\nindex: int = self.hash_func(key)\nself.buckets[index] = pair\ndef remove(self, key: int):\n\"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\nindex: int = self.hash_func(key)\n# \u7f6e\u4e3a None \uff0c\u4ee3\u8868\u5220\u9664\nself.buckets[index] = None\ndef entry_set(self) -> list[Pair]:\n\"\"\"\u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\"\"\"\nresult: list[Pair] = []\nfor pair in self.buckets:\nif pair is not None:\nresult.append(pair)\nreturn result\ndef key_set(self) -> list[int]:\n\"\"\"\u83b7\u53d6\u6240\u6709\u952e\"\"\"\nresult = []\nfor pair in self.buckets:\nif pair is not None:\nresult.append(pair.key)\nreturn result\ndef value_set(self) -> list[str]:\n\"\"\"\u83b7\u53d6\u6240\u6709\u503c\"\"\"\nresult = []\nfor pair in self.buckets:\nif pair is not None:\nresult.append(pair.val)\nreturn result\ndef print(self):\n\"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\nfor pair in self.buckets:\nif pair is not None:\nprint(pair.key, \"->\", pair.val)\n
    array_hash_map.go
    /* \u952e\u503c\u5bf9 */\ntype pair struct {\nkey int\nval string\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\ntype arrayHashMap struct {\nbuckets []*pair\n}\n/* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nfunc newArrayHashMap() *arrayHashMap {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nbuckets := make([]*pair, 100)\nreturn &arrayHashMap{buckets: buckets}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (a *arrayHashMap) hashFunc(key int) int {\nindex := key % 100\nreturn index\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (a *arrayHashMap) get(key int) string {\nindex := a.hashFunc(key)\npair := a.buckets[index]\nif pair == nil {\nreturn \"Not Found\"\n}\nreturn pair.val\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (a *arrayHashMap) put(key int, val string) {\npair := &pair{key: key, val: val}\nindex := a.hashFunc(key)\na.buckets[index] = pair\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (a *arrayHashMap) remove(key int) {\nindex := a.hashFunc(key)\n// \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\na.buckets[index] = nil\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u5bf9 */\nfunc (a *arrayHashMap) pairSet() []*pair {\nvar pairs []*pair\nfor _, pair := range a.buckets {\nif pair != nil {\npairs = append(pairs, pair)\n}\n}\nreturn pairs\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\nfunc (a *arrayHashMap) keySet() []int {\nvar keys []int\nfor _, pair := range a.buckets {\nif pair != nil {\nkeys = append(keys, pair.key)\n}\n}\nreturn keys\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\nfunc (a *arrayHashMap) valueSet() []string {\nvar values []string\nfor _, pair := range a.buckets {\nif pair != nil {\nvalues = append(values, pair.val)\n}\n}\nreturn values\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (a *arrayHashMap) print() {\nfor _, pair := range a.buckets {\nif pair != nil {\nfmt.Println(pair.key, \"->\", pair.val)\n}\n}\n}\n
    array_hash_map.js
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\nconstructor(key, val) {\nthis.key = key;\nthis.val = val;\n}\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n#buckets;\nconstructor() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nthis.#buckets = new Array(100).fill(null);\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\n#hashFunc(key) {\nreturn key % 100;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nget(key) {\nlet index = this.#hashFunc(key);\nlet pair = this.#buckets[index];\nif (pair === null) return null;\nreturn pair.val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nset(key, val) {\nlet index = this.#hashFunc(key);\nthis.#buckets[index] = new Pair(key, val);\n}\n/* \u5220\u9664\u64cd\u4f5c */\ndelete(key) {\nlet index = this.#hashFunc(key);\n// \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\nthis.#buckets[index] = null;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nentries() {\nlet arr = [];\nfor (let i = 0; i < this.#buckets.length; i++) {\nif (this.#buckets[i]) {\narr.push(this.#buckets[i]);\n}\n}\nreturn arr;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\nkeys() {\nlet arr = [];\nfor (let i = 0; i < this.#buckets.length; i++) {\nif (this.#buckets[i]) {\narr.push(this.#buckets[i]?.key);\n}\n}\nreturn arr;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\nvalues() {\nlet arr = [];\nfor (let i = 0; i < this.#buckets.length; i++) {\nif (this.#buckets[i]) {\narr.push(this.#buckets[i]?.val);\n}\n}\nreturn arr;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nprint() {\nlet pairSet = this.entries();\nfor (const pair of pairSet) {\nif (!pair) continue;\nconsole.info(`${pair.key} -> ${pair.val}`);\n}\n}\n}\n
    array_hash_map.ts
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\npublic key: number;\npublic val: string;\nconstructor(key: number, val: string) {\nthis.key = key;\nthis.val = val;\n}\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nprivate readonly buckets: (Pair | null)[];\nconstructor() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nthis.buckets = new Array(100).fill(null);\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate hashFunc(key: number): number {\nreturn key % 100;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic get(key: number): string | null {\nlet index = this.hashFunc(key);\nlet pair = this.buckets[index];\nif (pair === null) return null;\nreturn pair.val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic set(key: number, val: string) {\nlet index = this.hashFunc(key);\nthis.buckets[index] = new Pair(key, val);\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic delete(key: number) {\nlet index = this.hashFunc(key);\n// \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\nthis.buckets[index] = null;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\npublic entries(): (Pair | null)[] {\nlet arr: (Pair | null)[] = [];\nfor (let i = 0; i < this.buckets.length; i++) {\nif (this.buckets[i]) {\narr.push(this.buckets[i]);\n}\n}\nreturn arr;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\npublic keys(): (number | undefined)[] {\nlet arr: (number | undefined)[] = [];\nfor (let i = 0; i < this.buckets.length; i++) {\nif (this.buckets[i]) {\narr.push(this.buckets[i]?.key);\n}\n}\nreturn arr;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\npublic values(): (string | undefined)[] {\nlet arr: (string | undefined)[] = [];\nfor (let i = 0; i < this.buckets.length; i++) {\nif (this.buckets[i]) {\narr.push(this.buckets[i]?.val);\n}\n}\nreturn arr;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic print() {\nlet pairSet = this.entries();\nfor (const pair of pairSet) {\nif (!pair) continue;\nconsole.info(`${pair.key} -> ${pair.val}`);\n}\n}\n}\n
    array_hash_map.c
    /* \u952e\u503c\u5bf9 int->string */\nstruct pair {\nint key;\nchar *val;\n};\ntypedef struct pair pair;\n[class]{arrayHashMap}-[func]{}\n
    array_hash_map.cs
    /* \u952e\u503c\u5bf9 int->string */\nclass Pair {\npublic int key;\npublic string val;\npublic Pair(int key, string val) {\nthis.key = key;\nthis.val = val;\n}\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nprivate List<Pair?> buckets;\npublic ArrayHashMap() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nbuckets = new();\nfor (int i = 0; i < 100; i++) {\nbuckets.Add(null);\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate int hashFunc(int key) {\nint index = key % 100;\nreturn index;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\npublic string? get(int key) {\nint index = hashFunc(key);\nPair? pair = buckets[index];\nif (pair == null) return null;\nreturn pair.val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\npublic void put(int key, string val) {\nPair pair = new Pair(key, val);\nint index = hashFunc(key);\nbuckets[index] = pair;\n}\n/* \u5220\u9664\u64cd\u4f5c */\npublic void remove(int key) {\nint index = hashFunc(key);\n// \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\nbuckets[index] = null;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\npublic List<Pair> pairSet() {\nList<Pair> pairSet = new();\nforeach (Pair? pair in buckets) {\nif (pair != null)\npairSet.Add(pair);\n}\nreturn pairSet;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\npublic List<int> keySet() {\nList<int> keySet = new();\nforeach (Pair? pair in buckets) {\nif (pair != null)\nkeySet.Add(pair.key);\n}\nreturn keySet;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\npublic List<string> valueSet() {\nList<string> valueSet = new();\nforeach (Pair? pair in buckets) {\nif (pair != null)\nvalueSet.Add(pair.val);\n}\nreturn valueSet;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\npublic void print() {\nforeach (Pair kv in pairSet()) {\nConsole.WriteLine(kv.key + \" -> \" + kv.val);\n}\n}\n}\n
    array_hash_map.swift
    /* \u952e\u503c\u5bf9 */\nclass Pair {\nvar key: Int\nvar val: String\ninit(key: Int, val: String) {\nself.key = key\nself.val = val\n}\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nprivate var buckets: [Pair?] = []\ninit() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\nfor _ in 0 ..< 100 {\nbuckets.append(nil)\n}\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nprivate func hashFunc(key: Int) -> Int {\nlet index = key % 100\nreturn index\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc get(key: Int) -> String? {\nlet index = hashFunc(key: key)\nlet pair = buckets[index]\nreturn pair?.val\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc put(key: Int, val: String) {\nlet pair = Pair(key: key, val: val)\nlet index = hashFunc(key: key)\nbuckets[index] = pair\n}\n/* \u5220\u9664\u64cd\u4f5c */\nfunc remove(key: Int) {\nlet index = hashFunc(key: key)\n// \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\nbuckets[index] = nil\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nfunc pairSet() -> [Pair] {\nvar pairSet: [Pair] = []\nfor pair in buckets {\nif let pair = pair {\npairSet.append(pair)\n}\n}\nreturn pairSet\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\nfunc keySet() -> [Int] {\nvar keySet: [Int] = []\nfor pair in buckets {\nif let pair = pair {\nkeySet.append(pair.key)\n}\n}\nreturn keySet\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\nfunc valueSet() -> [String] {\nvar valueSet: [String] = []\nfor pair in buckets {\nif let pair = pair {\nvalueSet.append(pair.val)\n}\n}\nreturn valueSet\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc print() {\nfor pair in pairSet() {\nSwift.print(\"\\(pair.key) -> \\(pair.val)\")\n}\n}\n}\n
    array_hash_map.zig
    // \u952e\u503c\u5bf9\nconst Pair = struct {\nkey: usize = undefined,\nval: []const u8 = undefined,\npub fn init(key: usize, val: []const u8) Pair {\nreturn Pair {\n.key = key,\n.val = val,\n};\n}\n};\n// \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\nfn ArrayHashMap(comptime T: type) type {\nreturn struct {\nbucket: ?std.ArrayList(?T) = null,\nmem_allocator: std.mem.Allocator = undefined,\nconst Self = @This();\n// \u6784\u9020\u51fd\u6570\npub fn init(self: *Self, allocator: std.mem.Allocator) !void {\nself.mem_allocator = allocator;\n// \u521d\u59cb\u5316\u4e00\u4e2a\u957f\u5ea6\u4e3a 100 \u7684\u6876\uff08\u6570\u7ec4\uff09\nself.bucket = std.ArrayList(?T).init(self.mem_allocator);\nvar i: i32 = 0;\nwhile (i < 100) : (i += 1) {\ntry self.bucket.?.append(null);\n}\n}\n// \u6790\u6784\u51fd\u6570\npub fn deinit(self: *Self) void {\nif (self.bucket != null) self.bucket.?.deinit();\n}\n// \u54c8\u5e0c\u51fd\u6570\nfn hashFunc(key: usize) usize {\nvar index = key % 100;\nreturn index;\n}\n// \u67e5\u8be2\u64cd\u4f5c\npub fn get(self: *Self, key: usize) []const u8 {\nvar index = hashFunc(key);\nvar pair = self.bucket.?.items[index];\nreturn pair.?.val;\n}\n// \u6dfb\u52a0\u64cd\u4f5c\npub fn put(self: *Self, key: usize, val: []const u8) !void {\nvar pair = Pair.init(key, val);\nvar index = hashFunc(key);\nself.bucket.?.items[index] = pair;\n}\n// \u5220\u9664\u64cd\u4f5c\npub fn remove(self: *Self, key: usize) !void {\nvar index = hashFunc(key);\n// \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\nself.bucket.?.items[index] = null;\n}       // \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\npub fn pairSet(self: *Self) !std.ArrayList(T) {\nvar entry_set = std.ArrayList(T).init(self.mem_allocator);\nfor (self.bucket.?.items) |item| {\nif (item == null) continue;\ntry entry_set.append(item.?);\n}\nreturn entry_set;\n}  // \u83b7\u53d6\u6240\u6709\u952e\npub fn keySet(self: *Self) !std.ArrayList(usize) {\nvar key_set = std.ArrayList(usize).init(self.mem_allocator);\nfor (self.bucket.?.items) |item| {\nif (item == null) continue;\ntry key_set.append(item.?.key);\n}\nreturn key_set;\n}  // \u83b7\u53d6\u6240\u6709\u503c\npub fn valueSet(self: *Self) !std.ArrayList([]const u8) {\nvar value_set = std.ArrayList([]const u8).init(self.mem_allocator);\nfor (self.bucket.?.items) |item| {\nif (item == null) continue;\ntry value_set.append(item.?.val);\n}\nreturn value_set;\n}\n// \u6253\u5370\u54c8\u5e0c\u8868\npub fn print(self: *Self) !void {\nvar entry_set = try self.pairSet();\ndefer entry_set.deinit();\nfor (entry_set.items) |item| {\nstd.debug.print(\"{} -> {s}\\n\", .{item.key, item.val});\n}\n}\n};\n}\n
    array_hash_map.dart
    /* \u952e\u503c\u5bf9 */\nclass Pair {\nint key;\nString val;\nPair(this.key, this.val);\n}\n/* \u57fa\u4e8e\u6570\u7ec4\u7b80\u6613\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\nlate List<Pair?> _buckets;\nArrayHashMap() {\n// \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n_buckets = List.filled(100, null);\n}\n/* \u54c8\u5e0c\u51fd\u6570 */\nint _hashFunc(int key) {\nfinal int index = key % 100;\nreturn index;\n}\n/* \u67e5\u8be2\u64cd\u4f5c */\nString? get(int key) {\nfinal int index = _hashFunc(key);\nfinal Pair? pair = _buckets[index];\nif (pair == null) {\nreturn null;\n}\nreturn pair.val;\n}\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(int key, String val) {\nfinal Pair pair = Pair(key, val);\nfinal int index = _hashFunc(key);\n_buckets[index] = pair;\n}\n/* \u5220\u9664\u64cd\u4f5c */\nvoid remove(int key) {\nfinal int index = _hashFunc(key);\n_buckets[index] = null;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nList<Pair> pairSet() {\nList<Pair> pairSet = [];\nfor (final Pair? pair in _buckets) {\nif (pair != null) {\npairSet.add(pair);\n}\n}\nreturn pairSet;\n}\n/* \u83b7\u53d6\u6240\u6709\u952e */\nList<int> keySet() {\nList<int> keySet = [];\nfor (final Pair? pair in _buckets) {\nif (pair != null) {\nkeySet.add(pair.key);\n}\n}\nreturn keySet;\n}\n/* \u83b7\u53d6\u6240\u6709\u503c */\nList<String> values() {\nList<String> valueSet = [];\nfor (final Pair? pair in _buckets) {\nif (pair != null) {\nvalueSet.add(pair.val);\n}\n}\nreturn valueSet;\n}\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid printHashMap() {\nfor (final Pair kv in pairSet()) {\nprint(\"${kv.key} -> ${kv.val}\");\n}\n}\n}\n
    "},{"location":"chapter_hashing/hash_map/#613","title":"6.1.3. \u00a0 \u54c8\u5e0c\u51b2\u7a81\u4e0e\u6269\u5bb9","text":"

    \u672c\u8d28\u4e0a\u770b\uff0c\u54c8\u5e0c\u51fd\u6570\u7684\u4f5c\u7528\u662f\u5c06\u8f93\u5165\u7a7a\u95f4\uff08key \u8303\u56f4\uff09\u6620\u5c04\u5230\u8f93\u51fa\u7a7a\u95f4\uff08\u6570\u7ec4\u7d22\u5f15\u8303\u56f4\uff09\uff0c\u800c\u8f93\u5165\u7a7a\u95f4\u5f80\u5f80\u8fdc\u5927\u4e8e\u8f93\u51fa\u7a7a\u95f4\u3002\u56e0\u6b64\uff0c\u7406\u8bba\u4e0a\u4e00\u5b9a\u5b58\u5728\u201c\u591a\u4e2a\u8f93\u5165\u5bf9\u5e94\u76f8\u540c\u8f93\u51fa\u201d\u7684\u60c5\u51b5\u3002

    \u5bf9\u4e8e\u4e0a\u8ff0\u793a\u4f8b\u4e2d\u7684\u54c8\u5e0c\u51fd\u6570\uff0c\u5f53\u8f93\u5165\u7684 key \u540e\u4e24\u4f4d\u76f8\u540c\u65f6\uff0c\u54c8\u5e0c\u51fd\u6570\u7684\u8f93\u51fa\u7ed3\u679c\u4e5f\u76f8\u540c\u3002\u4f8b\u5982\uff0c\u67e5\u8be2\u5b66\u53f7\u4e3a 12836 \u548c 20336 \u7684\u4e24\u4e2a\u5b66\u751f\u65f6\uff0c\u6211\u4eec\u5f97\u5230\uff1a

    12386 % 100 = 36\n20386 % 100 = 36\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u4e24\u4e2a\u5b66\u53f7\u6307\u5411\u4e86\u540c\u4e00\u4e2a\u59d3\u540d\uff0c\u8fd9\u663e\u7136\u662f\u4e0d\u5bf9\u7684\u3002\u6211\u4eec\u5c06\u8fd9\u79cd\u591a\u4e2a\u8f93\u5165\u5bf9\u5e94\u540c\u4e00\u8f93\u51fa\u7684\u60c5\u51b5\u79f0\u4e3a\u300c\u54c8\u5e0c\u51b2\u7a81 Hash Collision\u300d\u3002

    Fig. \u54c8\u5e0c\u51b2\u7a81\u793a\u4f8b

    \u5bb9\u6613\u60f3\u5230\uff0c\u54c8\u5e0c\u8868\u5bb9\u91cf \\(n\\) \u8d8a\u5927\uff0c\u591a\u4e2a key \u88ab\u5206\u914d\u5230\u540c\u4e00\u4e2a\u6876\u4e2d\u7684\u6982\u7387\u5c31\u8d8a\u4f4e\uff0c\u51b2\u7a81\u5c31\u8d8a\u5c11\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u6269\u5bb9\u54c8\u5e0c\u8868\u6765\u51cf\u5c11\u54c8\u5e0c\u51b2\u7a81\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u6269\u5bb9\u524d\u952e\u503c\u5bf9 (136, A) \u548c (236, D) \u53d1\u751f\u51b2\u7a81\uff0c\u6269\u5bb9\u540e\u51b2\u7a81\u6d88\u5931\u3002

    Fig. \u54c8\u5e0c\u8868\u6269\u5bb9

    \u7c7b\u4f3c\u4e8e\u6570\u7ec4\u6269\u5bb9\uff0c\u54c8\u5e0c\u8868\u6269\u5bb9\u9700\u5c06\u6240\u6709\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u8fc1\u79fb\u81f3\u65b0\u54c8\u5e0c\u8868\uff0c\u975e\u5e38\u8017\u65f6\u3002\u5e76\u4e14\u7531\u4e8e\u54c8\u5e0c\u8868\u5bb9\u91cf capacity \u6539\u53d8\uff0c\u6211\u4eec\u9700\u8981\u91cd\u65b0\u8ba1\u7b97\u6240\u6709\u952e\u503c\u5bf9\u7684\u5b58\u50a8\u4f4d\u7f6e\uff0c\u8fdb\u4e00\u6b65\u63d0\u9ad8\u4e86\u6269\u5bb9\u8fc7\u7a0b\u7684\u8ba1\u7b97\u5f00\u9500\u3002\u56e0\u6b64\uff0c\u7f16\u7a0b\u8bed\u8a00\u901a\u5e38\u4f1a\u9884\u7559\u8db3\u591f\u5927\u7684\u54c8\u5e0c\u8868\u5bb9\u91cf\uff0c\u9632\u6b62\u9891\u7e41\u6269\u5bb9\u3002

    \u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u300c\u8d1f\u8f7d\u56e0\u5b50 Load Factor\u300d\u662f\u4e00\u4e2a\u91cd\u8981\u6982\u5ff5\uff0c\u5176\u5b9a\u4e49\u4e3a\u54c8\u5e0c\u8868\u7684\u5143\u7d20\u6570\u91cf\u9664\u4ee5\u6876\u6570\u91cf\uff0c\u4e3a\u4e86\u8861\u91cf\u54c8\u5e0c\u51b2\u7a81\u7684\u4e25\u91cd\u7a0b\u5ea6\uff0c\u4e5f\u5e38\u88ab\u4f5c\u4e3a\u54c8\u5e0c\u8868\u6269\u5bb9\u7684\u89e6\u53d1\u6761\u4ef6\u3002\u4f8b\u5982\u5728 Java \u4e2d\uff0c\u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7 \\(0.75\\) \u65f6\uff0c\u7cfb\u7edf\u4f1a\u5c06\u54c8\u5e0c\u8868\u5bb9\u91cf\u6269\u5c55\u4e3a\u539f\u5148\u7684 \\(2\\) \u500d\u3002

    "},{"location":"chapter_hashing/summary/","title":"6.4. \u00a0 \u5c0f\u7ed3","text":"
    • \u8f93\u5165 key \uff0c\u54c8\u5e0c\u8868\u80fd\u591f\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u67e5\u8be2\u5230 value \uff0c\u6548\u7387\u975e\u5e38\u9ad8\u3002
    • \u5e38\u89c1\u7684\u54c8\u5e0c\u8868\u64cd\u4f5c\u5305\u62ec\u67e5\u8be2\u3001\u6dfb\u52a0\u952e\u503c\u5bf9\u3001\u5220\u9664\u952e\u503c\u5bf9\u548c\u904d\u5386\u54c8\u5e0c\u8868\u7b49\u3002
    • \u54c8\u5e0c\u51fd\u6570\u5c06 key \u6620\u5c04\u4e3a\u6570\u7ec4\u7d22\u5f15\uff0c\u4ece\u800c\u8bbf\u95ee\u5bf9\u5e94\u6876\u5e76\u83b7\u53d6 value \u3002
    • \u4e24\u4e2a\u4e0d\u540c\u7684 key \u53ef\u80fd\u5728\u7ecf\u8fc7\u54c8\u5e0c\u51fd\u6570\u540e\u5f97\u5230\u76f8\u540c\u7684\u6570\u7ec4\u7d22\u5f15\uff0c\u5bfc\u81f4\u67e5\u8be2\u7ed3\u679c\u51fa\u9519\uff0c\u8fd9\u79cd\u73b0\u8c61\u88ab\u79f0\u4e3a\u54c8\u5e0c\u51b2\u7a81\u3002
    • \u54c8\u5e0c\u8868\u5bb9\u91cf\u8d8a\u5927\uff0c\u54c8\u5e0c\u51b2\u7a81\u7684\u6982\u7387\u5c31\u8d8a\u4f4e\u3002\u56e0\u6b64\u53ef\u4ee5\u901a\u8fc7\u6269\u5bb9\u54c8\u5e0c\u8868\u6765\u7f13\u89e3\u54c8\u5e0c\u51b2\u7a81\u3002\u4e0e\u6570\u7ec4\u6269\u5bb9\u7c7b\u4f3c\uff0c\u54c8\u5e0c\u8868\u6269\u5bb9\u64cd\u4f5c\u7684\u5f00\u9500\u5f88\u5927\u3002
    • \u8d1f\u8f7d\u56e0\u5b50\u5b9a\u4e49\u4e3a\u54c8\u5e0c\u8868\u4e2d\u5143\u7d20\u6570\u91cf\u9664\u4ee5\u6876\u6570\u91cf\uff0c\u53cd\u6620\u4e86\u54c8\u5e0c\u51b2\u7a81\u7684\u4e25\u91cd\u7a0b\u5ea6\uff0c\u5e38\u7528\u4f5c\u89e6\u53d1\u54c8\u5e0c\u8868\u6269\u5bb9\u7684\u6761\u4ef6\u3002
    • \u94fe\u5f0f\u5730\u5740\u901a\u8fc7\u5c06\u5355\u4e2a\u5143\u7d20\u8f6c\u5316\u4e3a\u94fe\u8868\uff0c\u5c06\u6240\u6709\u51b2\u7a81\u5143\u7d20\u5b58\u50a8\u5728\u540c\u4e00\u4e2a\u94fe\u8868\u4e2d\u3002\u7136\u800c\uff0c\u94fe\u8868\u8fc7\u957f\u4f1a\u964d\u4f4e\u67e5\u8be2\u6548\u7387\uff0c\u53ef\u4ee5\u8fdb\u4e00\u6b65\u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811\u6765\u63d0\u9ad8\u6548\u7387\u3002
    • \u5f00\u653e\u5bfb\u5740\u901a\u8fc7\u591a\u6b21\u63a2\u6d4b\u6765\u5904\u7406\u54c8\u5e0c\u51b2\u7a81\u3002\u7ebf\u6027\u63a2\u6d4b\u4f7f\u7528\u56fa\u5b9a\u6b65\u957f\uff0c\u7f3a\u70b9\u662f\u4e0d\u80fd\u5220\u9664\u5143\u7d20\uff0c\u4e14\u5bb9\u6613\u4ea7\u751f\u805a\u96c6\u3002\u591a\u6b21\u54c8\u5e0c\u4f7f\u7528\u591a\u4e2a\u54c8\u5e0c\u51fd\u6570\u8fdb\u884c\u63a2\u6d4b\uff0c\u76f8\u8f83\u7ebf\u6027\u63a2\u6d4b\u66f4\u4e0d\u6613\u4ea7\u751f\u805a\u96c6\uff0c\u4f46\u591a\u4e2a\u54c8\u5e0c\u51fd\u6570\u589e\u52a0\u4e86\u8ba1\u7b97\u91cf\u3002
    • \u4e0d\u540c\u7f16\u7a0b\u8bed\u8a00\u91c7\u53d6\u4e86\u4e0d\u540c\u7684\u54c8\u5e0c\u8868\u5b9e\u73b0\u3002\u4f8b\u5982\uff0cJava \u7684 HashMap \u4f7f\u7528\u94fe\u5f0f\u5730\u5740\uff0c\u800c Python \u7684 Dict \u91c7\u7528\u5f00\u653e\u5bfb\u5740\u3002
    • \u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u6211\u4eec\u5e0c\u671b\u54c8\u5e0c\u7b97\u6cd5\u5177\u6709\u786e\u5b9a\u6027\u3001\u9ad8\u6548\u7387\u548c\u5747\u5300\u5206\u5e03\u7684\u7279\u70b9\u3002\u5728\u5bc6\u7801\u5b66\u4e2d\uff0c\u54c8\u5e0c\u7b97\u6cd5\u8fd8\u5e94\u8be5\u5177\u5907\u6297\u78b0\u649e\u6027\u548c\u96ea\u5d29\u6548\u5e94\u3002
    • \u54c8\u5e0c\u7b97\u6cd5\u901a\u5e38\u91c7\u7528\u5927\u8d28\u6570\u4f5c\u4e3a\u6a21\u6570\uff0c\u4ee5\u6700\u5927\u5316\u5730\u4fdd\u8bc1\u54c8\u5e0c\u503c\u7684\u5747\u5300\u5206\u5e03\uff0c\u51cf\u5c11\u54c8\u5e0c\u51b2\u7a81\u3002
    • \u5e38\u89c1\u7684\u54c8\u5e0c\u7b97\u6cd5\u5305\u62ec MD5, SHA-1, SHA-2, SHA3 \u7b49\u3002MD5 \u5e38\u7528\u8bed\u6821\u9a8c\u6587\u4ef6\u5b8c\u6574\u6027\uff0cSHA-2 \u5e38\u7528\u4e8e\u5b89\u5168\u5e94\u7528\u4e0e\u534f\u8bae\u3002
    • \u7f16\u7a0b\u8bed\u8a00\u901a\u5e38\u4f1a\u4e3a\u6570\u636e\u7c7b\u578b\u63d0\u4f9b\u5185\u7f6e\u54c8\u5e0c\u7b97\u6cd5\uff0c\u7528\u4e8e\u8ba1\u7b97\u54c8\u5e0c\u8868\u4e2d\u7684\u6876\u7d22\u5f15\u3002\u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\u53ea\u6709\u4e0d\u53ef\u53d8\u5bf9\u8c61\u662f\u53ef\u54c8\u5e0c\u7684\u3002
    "},{"location":"chapter_hashing/summary/#641-q-a","title":"6.4.1. \u00a0 Q & A","text":"

    \u54c8\u5e0c\u8868\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a\u4ec0\u4e48\u4e0d\u662f \\(O(n)\\) \uff1f

    \u5f53\u54c8\u5e0c\u51b2\u7a81\u6bd4\u8f83\u4e25\u91cd\u65f6\uff0c\u54c8\u5e0c\u8868\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4f1a\u9000\u5316\u81f3 \\(O(n)\\) \u3002\u5f53\u54c8\u5e0c\u51fd\u6570\u8bbe\u8ba1\u7684\u6bd4\u8f83\u597d\u3001\u5bb9\u91cf\u8bbe\u7f6e\u6bd4\u8f83\u5408\u7406\u3001\u51b2\u7a81\u6bd4\u8f83\u5e73\u5747\u65f6\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(1)\\) \u3002\u6211\u4eec\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u5185\u7f6e\u7684\u54c8\u5e0c\u8868\u65f6\uff0c\u901a\u5e38\u8ba4\u4e3a\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(1)\\) \u3002

    \u4e3a\u4ec0\u4e48\u4e0d\u4f7f\u7528\u54c8\u5e0c\u51fd\u6570 \\(f(x) = x\\) \u5462\uff1f\u8fd9\u6837\u5c31\u4e0d\u4f1a\u6709\u51b2\u7a81\u4e86

    \u5728 \\(f(x) = x\\) \u54c8\u5e0c\u51fd\u6570\u4e0b\uff0c\u6bcf\u4e2a\u5143\u7d20\u5bf9\u5e94\u552f\u4e00\u7684\u6876\u7d22\u5f15\uff0c\u8fd9\u4e0e\u6570\u7ec4\u7b49\u4ef7\u3002\u7136\u800c\uff0c\u8f93\u5165\u7a7a\u95f4\u901a\u5e38\u8fdc\u5927\u4e8e\u8f93\u51fa\u7a7a\u95f4\uff08\u6570\u7ec4\u957f\u5ea6\uff09\uff0c\u56e0\u6b64\u54c8\u5e0c\u51fd\u6570\u7684\u6700\u540e\u4e00\u6b65\u5f80\u5f80\u662f\u5bf9\u6570\u7ec4\u957f\u5ea6\u53d6\u6a21\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u54c8\u5e0c\u8868\u7684\u76ee\u6807\u662f\u5c06\u4e00\u4e2a\u8f83\u5927\u7684\u72b6\u6001\u7a7a\u95f4\u6620\u5c04\u5230\u4e00\u4e2a\u8f83\u5c0f\u7684\u7a7a\u95f4\uff0c\u5e76\u63d0\u4f9b \\(O(1)\\) \u7684\u67e5\u8be2\u6548\u7387\u3002

    \u54c8\u5e0c\u8868\u5e95\u5c42\u5b9e\u73b0\u662f\u6570\u7ec4\u3001\u94fe\u8868\u3001\u4e8c\u53c9\u6811\uff0c\u4f46\u4e3a\u4ec0\u4e48\u6548\u7387\u53ef\u4ee5\u6bd4\u4ed6\u4eec\u66f4\u9ad8\u5462\uff1f

    \u9996\u5148\uff0c\u54c8\u5e0c\u8868\u7684\u65f6\u95f4\u6548\u7387\u53d8\u9ad8\uff0c\u4f46\u7a7a\u95f4\u6548\u7387\u53d8\u4f4e\u4e86\u3002\u54c8\u5e0c\u8868\u6709\u76f8\u5f53\u4e00\u90e8\u5206\u7684\u5185\u5b58\u662f\u672a\u4f7f\u7528\u7684\uff0c

    \u5176\u6b21\uff0c\u53ea\u662f\u5728\u7279\u5b9a\u4f7f\u7528\u573a\u666f\u4e0b\u65f6\u95f4\u6548\u7387\u53d8\u9ad8\u4e86\u3002\u5982\u679c\u4e00\u4e2a\u529f\u80fd\u80fd\u591f\u5728\u76f8\u540c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e0b\u4f7f\u7528\u6570\u7ec4\u6216\u94fe\u8868\u5b9e\u73b0\uff0c\u90a3\u4e48\u901a\u5e38\u6bd4\u54c8\u5e0c\u8868\u66f4\u5feb\u3002\u8fd9\u662f\u56e0\u4e3a\u54c8\u5e0c\u51fd\u6570\u8ba1\u7b97\u9700\u8981\u5f00\u9500\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u7684\u5e38\u6570\u9879\u66f4\u5927\u3002

    \u6700\u540e\uff0c\u54c8\u5e0c\u8868\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u80fd\u53d1\u751f\u52a3\u5316\u3002\u4f8b\u5982\u5728\u94fe\u5f0f\u5730\u5740\u4e2d\uff0c\u6211\u4eec\u91c7\u53d6\u5728\u94fe\u8868\u6216\u7ea2\u9ed1\u6811\u4e2d\u6267\u884c\u67e5\u627e\u64cd\u4f5c\uff0c\u4ecd\u7136\u6709\u9000\u5316\u81f3 \\(O(n)\\) \u65f6\u95f4\u7684\u98ce\u9669\u3002

    \u591a\u6b21\u54c8\u5e0c\u6709\u4e0d\u80fd\u76f4\u63a5\u5220\u9664\u5143\u7d20\u7684\u7f3a\u9677\u5417\uff1f\u5bf9\u4e8e\u6807\u8bb0\u5df2\u5220\u9664\u7684\u7a7a\u95f4\uff0c\u8fd9\u4e2a\u7a7a\u95f4\u8fd8\u80fd\u518d\u6b21\u4f7f\u7528\u5417\uff1f

    \u591a\u6b21\u54c8\u5e0c\u662f\u5f00\u653e\u5bfb\u5740\u7684\u4e00\u79cd\uff0c\u5f00\u653e\u5bfb\u5740\u6cd5\u90fd\u6709\u4e0d\u80fd\u76f4\u63a5\u5220\u9664\u5143\u7d20\u7684\u7f3a\u9677\uff0c\u9700\u8981\u901a\u8fc7\u6807\u8bb0\u5220\u9664\u3002\u88ab\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u7a7a\u95f4\u662f\u53ef\u4ee5\u518d\u6b21\u88ab\u4f7f\u7528\u7684\u3002\u5f53\u5c06\u65b0\u5143\u7d20\u63d2\u5165\u54c8\u5e0c\u8868\uff0c\u5e76\u4e14\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u627e\u5230\u4e86\u88ab\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u4f4d\u7f6e\u65f6\uff0c\u8be5\u4f4d\u7f6e\u53ef\u4ee5\u88ab\u65b0\u7684\u5143\u7d20\u4f7f\u7528\u3002\u8fd9\u6837\u505a\u65e2\u80fd\u4fdd\u6301\u54c8\u5e0c\u8868\u7684\u63a2\u6d4b\u5e8f\u5217\u4e0d\u53d8\uff0c\u53c8\u80fd\u4fdd\u8bc1\u54c8\u5e0c\u8868\u7684\u7a7a\u95f4\u4f7f\u7528\u7387\u3002

    \u4e3a\u4ec0\u4e48\u5728\u7ebf\u6027\u63a2\u6d4b\u4e2d\uff0c\u67e5\u627e\u5143\u7d20\u7684\u65f6\u5019\u4f1a\u51fa\u73b0\u54c8\u5e0c\u51b2\u7a81\u5462\uff1f

    \u67e5\u627e\u7684\u65f6\u5019\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u627e\u5230\u5bf9\u5e94\u7684\u6876\u548c\u952e\u503c\u5bf9\uff0c\u53d1\u73b0 key \u4e0d\u5339\u914d\uff0c\u8fd9\u5c31\u4ee3\u8868\u6709\u54c8\u5e0c\u51b2\u7a81\u3002\u56e0\u6b64\uff0c\u7ebf\u6027\u63a2\u6d4b\u6cd5\u4f1a\u6839\u636e\u9884\u5148\u8bbe\u5b9a\u7684\u6b65\u957f\u4f9d\u6b21\u5411\u4e0b\u67e5\u627e\uff0c\u76f4\u81f3\u627e\u5230\u6b63\u786e\u7684\u952e\u503c\u5bf9\u6216\u65e0\u6cd5\u627e\u5230\u8df3\u51fa\u4e3a\u6b62\u3002

    \u4e3a\u4ec0\u4e48\u54c8\u5e0c\u8868\u6269\u5bb9\u80fd\u591f\u7f13\u89e3\u54c8\u5e0c\u51b2\u7a81\uff1f

    \u54c8\u5e0c\u51fd\u6570\u7684\u6700\u540e\u4e00\u6b65\u5f80\u5f80\u662f\u5bf9\u6570\u7ec4\u957f\u5ea6 \\(n\\) \u53d6\u4f59\uff0c\u8ba9\u8f93\u51fa\u503c\u843d\u5165\u5728\u6570\u7ec4\u7d22\u5f15\u8303\u56f4\uff1b\u5728\u6269\u5bb9\u540e\uff0c\u6570\u7ec4\u957f\u5ea6 \\(n\\) \u53d1\u751f\u53d8\u5316\uff0c\u800c key \u5bf9\u5e94\u7684\u7d22\u5f15\u4e5f\u53ef\u80fd\u53d1\u751f\u53d8\u5316\u3002\u539f\u5148\u843d\u5728\u540c\u4e00\u4e2a\u6876\u7684\u591a\u4e2a key \uff0c\u5728\u6269\u5bb9\u540e\u53ef\u80fd\u4f1a\u88ab\u5206\u914d\u5230\u591a\u4e2a\u6876\u4e2d\uff0c\u4ece\u800c\u5b9e\u73b0\u54c8\u5e0c\u51b2\u7a81\u7684\u7f13\u89e3\u3002

    "},{"location":"chapter_heap/","title":"8. \u00a0 \u5806","text":""},{"location":"chapter_heap/build_heap/","title":"8.2. \u00a0 \u5efa\u5806\u64cd\u4f5c","text":"

    \u5982\u679c\u6211\u4eec\u60f3\u8981\u6839\u636e\u8f93\u5165\u5217\u8868\u751f\u6210\u4e00\u4e2a\u5806\uff0c\u8fd9\u4e2a\u8fc7\u7a0b\u88ab\u79f0\u4e3a\u300c\u5efa\u5806\u300d\u3002

    "},{"location":"chapter_heap/build_heap/#821","title":"8.2.1. \u00a0 \u501f\u52a9\u5165\u5806\u65b9\u6cd5\u5b9e\u73b0","text":"

    \u6700\u76f4\u63a5\u7684\u65b9\u6cd5\u662f\u501f\u52a9\u201c\u5143\u7d20\u5165\u5806\u64cd\u4f5c\u201d\u5b9e\u73b0\uff0c\u9996\u5148\u521b\u5efa\u4e00\u4e2a\u7a7a\u5806\uff0c\u7136\u540e\u5c06\u5217\u8868\u5143\u7d20\u4f9d\u6b21\u6dfb\u52a0\u5230\u5806\u4e2d\u3002

    \u8bbe\u5143\u7d20\u6570\u91cf\u4e3a \\(n\\) \uff0c\u5219\u6700\u540e\u4e00\u4e2a\u5143\u7d20\u5165\u5806\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u3002\u5728\u4f9d\u6b21\u6dfb\u52a0\u5143\u7d20\u65f6\uff0c\u5806\u7684\u5e73\u5747\u957f\u5ea6\u4e3a \\(\\frac{n}{2}\\) \uff0c\u56e0\u6b64\u8be5\u65b9\u6cd5\u7684\u603b\u4f53\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002

    "},{"location":"chapter_heap/build_heap/#822","title":"8.2.2. \u00a0 \u57fa\u4e8e\u5806\u5316\u64cd\u4f5c\u5b9e\u73b0","text":"

    \u6709\u8da3\u7684\u662f\uff0c\u5b58\u5728\u4e00\u79cd\u66f4\u9ad8\u6548\u7684\u5efa\u5806\u65b9\u6cd5\uff0c\u5176\u65f6\u95f4\u590d\u6742\u5ea6\u4ec5\u4e3a \\(O(n)\\) \u3002\u6211\u4eec\u5148\u5c06\u5217\u8868\u6240\u6709\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u5230\u5806\u4e2d\uff0c\u7136\u540e\u8fed\u4ee3\u5730\u5bf9\u5404\u4e2a\u8282\u70b9\u6267\u884c\u201c\u4ece\u9876\u81f3\u5e95\u5806\u5316\u201d\u3002\u5f53\u7136\uff0c\u6211\u4eec\u4e0d\u9700\u8981\u5bf9\u53f6\u8282\u70b9\u6267\u884c\u5806\u5316\u64cd\u4f5c\uff0c\u56e0\u4e3a\u5b83\u4eec\u6ca1\u6709\u5b50\u8282\u70b9\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_heap.java
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nMaxHeap(List<Integer> nums) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nmaxHeap = new ArrayList<>(nums);\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = parent(size() - 1); i >= 0; i--) {\nsiftDown(i);\n}\n}\n
    my_heap.cpp
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nMaxHeap(vector<int> nums) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nmaxHeap = nums;\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = parent(size() - 1); i >= 0; i--) {\nsiftDown(i);\n}\n}\n
    my_heap.py
    def __init__(self, nums: list[int]):\n\"\"\"\u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806\"\"\"\n# \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nself.max_heap = nums\n# \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor i in range(self.parent(self.size() - 1), -1, -1):\nself.sift_down(i)\n
    my_heap.go
    /* \u6784\u9020\u51fd\u6570\uff0c\u6839\u636e\u5207\u7247\u5efa\u5806 */\nfunc newMaxHeap(nums []any) *maxHeap {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nh := &maxHeap{data: nums}\nfor i := len(h.data) - 1; i >= 0; i-- {\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nh.siftDown(i)\n}\nreturn h\n}\n
    my_heap.js
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u5efa\u7acb\u7a7a\u5806\u6216\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nconstructor(nums) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nthis.#maxHeap = nums === undefined ? [] : [...nums];\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (let i = this.#parent(this.size() - 1); i >= 0; i--) {\nthis.#siftDown(i);\n}\n}\n
    my_heap.ts
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u5efa\u7acb\u7a7a\u5806\u6216\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nconstructor(nums?: number[]) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nthis.maxHeap = nums === undefined ? [] : [...nums];\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (let i = this.parent(this.size() - 1); i >= 0; i--) {\nthis.siftDown(i);\n}\n}\n
    my_heap.c
    /* \u6784\u9020\u51fd\u6570\uff0c\u6839\u636e\u5207\u7247\u5efa\u5806 */\nmaxHeap *newMaxHeap(int nums[], int size) {\n// \u6240\u6709\u5143\u7d20\u5165\u5806\nmaxHeap *h = (maxHeap *)malloc(sizeof(maxHeap));\nh->size = size;\nmemcpy(h->data, nums, size * sizeof(int));\nfor (int i = size - 1; i >= 0; i--) {\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nsiftDown(h, i);\n}\nreturn h;\n}\n
    my_heap.cs
    /* \u6784\u9020\u51fd\u6570\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nMaxHeap(IEnumerable<int> nums) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nmaxHeap = new List<int>(nums);\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nvar size = parent(this.size() - 1);\nfor (int i = size; i >= 0; i--) {\nsiftDown(i);\n}\n}\n
    my_heap.swift
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\ninit(nums: [Int]) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\nmaxHeap = nums\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor i in stride(from: parent(i: size() - 1), through: 0, by: -1) {\nsiftDown(i: i)\n}\n}\n
    my_heap.zig
    // \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806\nfn init(self: *Self, allocator: std.mem.Allocator, nums: []const T) !void {\nif (self.max_heap != null) return;\nself.max_heap = std.ArrayList(T).init(allocator);\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\ntry self.max_heap.?.appendSlice(nums);\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nvar i: usize = parent(self.size() - 1) + 1;\nwhile (i > 0) : (i -= 1) {\ntry self.siftDown(i - 1);\n}\n}\n
    my_heap.dart
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nMaxHeap(List<int> nums) {\n// \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\n_maxHeap = nums;\n// \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = _parent(size() - 1); i >= 0; i--) {\n_siftDown(i);\n}\n}\n
    "},{"location":"chapter_heap/build_heap/#823","title":"8.2.3. \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"

    \u4e3a\u4ec0\u4e48\u7b2c\u4e8c\u79cd\u5efa\u5806\u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(n)\\) \uff1f\u6211\u4eec\u6765\u5c55\u5f00\u63a8\u7b97\u4e00\u4e0b\u3002

    • \u5b8c\u5168\u4e8c\u53c9\u6811\u4e2d\uff0c\u8bbe\u8282\u70b9\u603b\u6570\u4e3a \\(n\\) \uff0c\u5219\u53f6\u8282\u70b9\u6570\u91cf\u4e3a \\((n + 1) / 2\\) \uff0c\u5176\u4e2d \\(/\\) \u4e3a\u5411\u4e0b\u6574\u9664\u3002\u56e0\u6b64\uff0c\u5728\u6392\u9664\u53f6\u8282\u70b9\u540e\uff0c\u9700\u8981\u5806\u5316\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\((n - 1)/2\\) \uff0c\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff1b
    • \u5728\u4ece\u9876\u81f3\u5e95\u5806\u5316\u7684\u8fc7\u7a0b\u4e2d\uff0c\u6bcf\u4e2a\u8282\u70b9\u6700\u591a\u5806\u5316\u5230\u53f6\u8282\u70b9\uff0c\u56e0\u6b64\u6700\u5927\u8fed\u4ee3\u6b21\u6570\u4e3a\u4e8c\u53c9\u6811\u9ad8\u5ea6 \\(O(\\log n)\\) \uff1b

    \u5c06\u4e0a\u8ff0\u4e24\u8005\u76f8\u4e58\uff0c\u53ef\u5f97\u5230\u5efa\u5806\u8fc7\u7a0b\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002\u7136\u800c\uff0c\u8fd9\u4e2a\u4f30\u7b97\u7ed3\u679c\u5e76\u4e0d\u51c6\u786e\uff0c\u56e0\u4e3a\u6211\u4eec\u6ca1\u6709\u8003\u8651\u5230\u4e8c\u53c9\u6811\u5e95\u5c42\u8282\u70b9\u6570\u91cf\u8fdc\u591a\u4e8e\u9876\u5c42\u8282\u70b9\u7684\u7279\u6027\u3002

    \u63a5\u4e0b\u6765\u6211\u4eec\u6765\u8fdb\u884c\u66f4\u4e3a\u8be6\u7ec6\u7684\u8ba1\u7b97\u3002\u4e3a\u4e86\u51cf\u5c0f\u8ba1\u7b97\u96be\u5ea6\uff0c\u6211\u4eec\u5047\u8bbe\u6811\u662f\u4e00\u4e2a\u201c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u201d\uff0c\u8be5\u5047\u8bbe\u4e0d\u4f1a\u5f71\u54cd\u8ba1\u7b97\u7ed3\u679c\u7684\u6b63\u786e\u6027\u3002\u8bbe\u4e8c\u53c9\u6811\uff08\u5373\u5806\uff09\u8282\u70b9\u6570\u91cf\u4e3a \\(n\\) \uff0c\u6811\u9ad8\u5ea6\u4e3a \\(h\\) \u3002\u4e0a\u6587\u63d0\u5230\uff0c\u8282\u70b9\u5806\u5316\u6700\u5927\u8fed\u4ee3\u6b21\u6570\u7b49\u4e8e\u8be5\u8282\u70b9\u5230\u53f6\u8282\u70b9\u7684\u8ddd\u79bb\uff0c\u800c\u8be5\u8ddd\u79bb\u6b63\u662f\u201c\u8282\u70b9\u9ad8\u5ea6\u201d\u3002

    Fig. \u5b8c\u7f8e\u4e8c\u53c9\u6811\u7684\u5404\u5c42\u8282\u70b9\u6570\u91cf

    \u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5404\u5c42\u7684\u201c\u8282\u70b9\u6570\u91cf \\(\\times\\) \u8282\u70b9\u9ad8\u5ea6\u201d\u6c42\u548c\uff0c\u4ece\u800c\u5f97\u5230\u6240\u6709\u8282\u70b9\u7684\u5806\u5316\u8fed\u4ee3\u6b21\u6570\u7684\u603b\u548c\u3002

    \\[ T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \\cdots + 2^{(h-1)}\\times1 \\]

    \u5316\u7b80\u4e0a\u5f0f\u9700\u8981\u501f\u52a9\u4e2d\u5b66\u7684\u6570\u5217\u77e5\u8bc6\uff0c\u5148\u5bf9 \\(T(h)\\) \u4e58\u4ee5 \\(2\\) \uff0c\u5f97\u5230

    \\[ \\begin{aligned} T(h) & = 2^0h + 2^1(h-1) + 2^2(h-2) + \\cdots + 2^{h-1}\\times1 \\newline 2 T(h) & = 2^1h + 2^2(h-1) + 2^3(h-2) + \\cdots + 2^{h}\\times1 \\newline \\end{aligned} \\]

    \u4f7f\u7528\u9519\u4f4d\u76f8\u51cf\u6cd5\uff0c\u4ee4\u4e0b\u5f0f \\(2 T(h)\\) \u51cf\u53bb\u4e0a\u5f0f \\(T(h)\\) \uff0c\u53ef\u5f97

    \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\cdots + 2^{h-1} + 2^h \\]

    \u89c2\u5bdf\u4e0a\u5f0f\uff0c\u53d1\u73b0 \\(T(h)\\) \u662f\u4e00\u4e2a\u7b49\u6bd4\u6570\u5217\uff0c\u53ef\u76f4\u63a5\u4f7f\u7528\u6c42\u548c\u516c\u5f0f\uff0c\u5f97\u5230\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a

    \\[ \\begin{aligned} T(h) & = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline & = 2^{h+1} - h \\newline & = O(2^h) \\end{aligned} \\]

    \u8fdb\u4e00\u6b65\u5730\uff0c\u9ad8\u5ea6\u4e3a \\(h\\) \u7684\u5b8c\u7f8e\u4e8c\u53c9\u6811\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\(n = 2^{h+1} - 1\\) \uff0c\u6613\u5f97\u590d\u6742\u5ea6\u4e3a \\(O(2^h) = O(n)\\) \u3002\u4ee5\u4e0a\u63a8\u7b97\u8868\u660e\uff0c\u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u975e\u5e38\u9ad8\u6548\u3002

    "},{"location":"chapter_heap/heap/","title":"8.1. \u00a0 \u5806","text":"

    \u300c\u5806 Heap\u300d\u662f\u4e00\u79cd\u6ee1\u8db3\u7279\u5b9a\u6761\u4ef6\u7684\u5b8c\u5168\u4e8c\u53c9\u6811\uff0c\u53ef\u5206\u4e3a\u4e24\u79cd\u7c7b\u578b\uff1a

    • \u300c\u5927\u9876\u5806 Max Heap\u300d\uff0c\u4efb\u610f\u8282\u70b9\u7684\u503c \\(\\geq\\) \u5176\u5b50\u8282\u70b9\u7684\u503c\uff1b
    • \u300c\u5c0f\u9876\u5806 Min Heap\u300d\uff0c\u4efb\u610f\u8282\u70b9\u7684\u503c \\(\\leq\\) \u5176\u5b50\u8282\u70b9\u7684\u503c\uff1b

    Fig. \u5c0f\u9876\u5806\u4e0e\u5927\u9876\u5806

    \u5806\u4f5c\u4e3a\u5b8c\u5168\u4e8c\u53c9\u6811\u7684\u4e00\u4e2a\u7279\u4f8b\uff0c\u5177\u6709\u4ee5\u4e0b\u7279\u6027\uff1a

    • \u6700\u5e95\u5c42\u8282\u70b9\u9760\u5de6\u586b\u5145\uff0c\u5176\u4ed6\u5c42\u7684\u8282\u70b9\u90fd\u88ab\u586b\u6ee1\u3002
    • \u6211\u4eec\u5c06\u4e8c\u53c9\u6811\u7684\u6839\u8282\u70b9\u79f0\u4e3a\u300c\u5806\u9876\u300d\uff0c\u5c06\u5e95\u5c42\u6700\u9760\u53f3\u7684\u8282\u70b9\u79f0\u4e3a\u300c\u5806\u5e95\u300d\u3002
    • \u5bf9\u4e8e\u5927\u9876\u5806\uff08\u5c0f\u9876\u5806\uff09\uff0c\u5806\u9876\u5143\u7d20\uff08\u5373\u6839\u8282\u70b9\uff09\u7684\u503c\u5206\u522b\u662f\u6700\u5927\uff08\u6700\u5c0f\uff09\u7684\u3002
    "},{"location":"chapter_heap/heap/#811","title":"8.1.1. \u00a0 \u5806\u5e38\u7528\u64cd\u4f5c","text":"

    \u9700\u8981\u6307\u51fa\u7684\u662f\uff0c\u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\u63d0\u4f9b\u7684\u662f\u300c\u4f18\u5148\u961f\u5217 Priority Queue\u300d\uff0c\u8fd9\u662f\u4e00\u79cd\u62bd\u8c61\u6570\u636e\u7ed3\u6784\uff0c\u5b9a\u4e49\u4e3a\u5177\u6709\u4f18\u5148\u7ea7\u6392\u5e8f\u7684\u961f\u5217\u3002

    \u5b9e\u9645\u4e0a\uff0c\u5806\u901a\u5e38\u7528\u4f5c\u5b9e\u73b0\u4f18\u5148\u961f\u5217\uff0c\u5927\u9876\u5806\u76f8\u5f53\u4e8e\u5143\u7d20\u6309\u4ece\u5927\u5230\u5c0f\u987a\u5e8f\u51fa\u961f\u7684\u4f18\u5148\u961f\u5217\u3002\u4ece\u4f7f\u7528\u89d2\u5ea6\u6765\u770b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u300c\u4f18\u5148\u961f\u5217\u300d\u548c\u300c\u5806\u300d\u770b\u4f5c\u7b49\u4ef7\u7684\u6570\u636e\u7ed3\u6784\u3002\u56e0\u6b64\uff0c\u672c\u4e66\u5bf9\u4e24\u8005\u4e0d\u505a\u7279\u522b\u533a\u5206\uff0c\u7edf\u4e00\u4f7f\u7528\u300c\u5806\u300d\u6765\u547d\u540d\u3002

    \u5806\u7684\u5e38\u7528\u64cd\u4f5c\u89c1\u4e0b\u8868\uff0c\u65b9\u6cd5\u540d\u9700\u8981\u6839\u636e\u7f16\u7a0b\u8bed\u8a00\u6765\u786e\u5b9a\u3002

    \u65b9\u6cd5\u540d \u63cf\u8ff0 \u65f6\u95f4\u590d\u6742\u5ea6 push() \u5143\u7d20\u5165\u5806 \\(O(\\log n)\\) pop() \u5806\u9876\u5143\u7d20\u51fa\u5806 \\(O(\\log n)\\) peek() \u8bbf\u95ee\u5806\u9876\u5143\u7d20\uff08\u5927 / \u5c0f\u9876\u5806\u5206\u522b\u4e3a\u6700\u5927 / \u5c0f\u503c\uff09 \\(O(1)\\) size() \u83b7\u53d6\u5806\u7684\u5143\u7d20\u6570\u91cf \\(O(1)\\) isEmpty() \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a \\(O(1)\\)

    \u5728\u5b9e\u9645\u5e94\u7528\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u63d0\u4f9b\u7684\u5806\u7c7b\uff08\u6216\u4f18\u5148\u961f\u5217\u7c7b\uff09\u3002

    Tip

    \u7c7b\u4f3c\u4e8e\u6392\u5e8f\u7b97\u6cd5\u4e2d\u7684\u201c\u4ece\u5c0f\u5230\u5927\u6392\u5217\u201d\u548c\u201c\u4ece\u5927\u5230\u5c0f\u6392\u5217\u201d\uff0c\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u4fee\u6539 Comparator \u6765\u5b9e\u73b0\u201c\u5c0f\u9876\u5806\u201d\u4e0e\u201c\u5927\u9876\u5806\u201d\u4e4b\u95f4\u7684\u8f6c\u6362\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart heap.java
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nQueue<Integer> minHeap = new PriorityQueue<>();\n// \u521d\u59cb\u5316\u5927\u9876\u5806\uff08\u4f7f\u7528 lambda \u8868\u8fbe\u5f0f\u4fee\u6539 Comparator \u5373\u53ef\uff09\nQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.peek(); // 5\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n// \u51fa\u5806\u5143\u7d20\u4f1a\u5f62\u6210\u4e00\u4e2a\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\npeek = heap.poll();  // 5\npeek = heap.poll();  // 4\npeek = heap.poll();  // 3\npeek = heap.poll();  // 2\npeek = heap.poll();  // 1\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.size();\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = maxHeap.isEmpty();\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = new PriorityQueue<>(Arrays.asList(1, 3, 2, 5, 4));\n
    heap.cpp
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\npriority_queue<int, vector<int>, greater<int>> minHeap;\n// \u521d\u59cb\u5316\u5927\u9876\u5806\npriority_queue<int, vector<int>, less<int>> maxHeap;\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.top(); // 5\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n// \u51fa\u5806\u5143\u7d20\u4f1a\u5f62\u6210\u4e00\u4e2a\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\nmaxHeap.pop(); // 5\nmaxHeap.pop(); // 4\nmaxHeap.pop(); // 3\nmaxHeap.pop(); // 2\nmaxHeap.pop(); // 1\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.size();\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = maxHeap.empty();\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nvector<int> input{1, 3, 2, 5, 4};\npriority_queue<int, vector<int>, greater<int>> minHeap(input.begin(), input.end());\n
    heap.py
    # \u521d\u59cb\u5316\u5c0f\u9876\u5806\nmin_heap, flag = [], 1\n# \u521d\u59cb\u5316\u5927\u9876\u5806\nmax_heap, flag = [], -1\n# Python \u7684 heapq \u6a21\u5757\u9ed8\u8ba4\u5b9e\u73b0\u5c0f\u9876\u5806\n# \u8003\u8651\u5c06\u201c\u5143\u7d20\u53d6\u8d1f\u201d\u540e\u518d\u5165\u5806\uff0c\u8fd9\u6837\u5c31\u53ef\u4ee5\u5c06\u5927\u5c0f\u5173\u7cfb\u98a0\u5012\uff0c\u4ece\u800c\u5b9e\u73b0\u5927\u9876\u5806\n# \u5728\u672c\u793a\u4f8b\u4e2d\uff0cflag = 1 \u65f6\u5bf9\u5e94\u5c0f\u9876\u5806\uff0cflag = -1 \u65f6\u5bf9\u5e94\u5927\u9876\u5806\n# \u5143\u7d20\u5165\u5806\nheapq.heappush(max_heap, flag * 1)\nheapq.heappush(max_heap, flag * 3)\nheapq.heappush(max_heap, flag * 2)\nheapq.heappush(max_heap, flag * 5)\nheapq.heappush(max_heap, flag * 4)\n# \u83b7\u53d6\u5806\u9876\u5143\u7d20\npeek: int = flag * max_heap[0] # 5\n# \u5806\u9876\u5143\u7d20\u51fa\u5806\n# \u51fa\u5806\u5143\u7d20\u4f1a\u5f62\u6210\u4e00\u4e2a\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\nval = flag * heapq.heappop(max_heap) # 5\nval = flag * heapq.heappop(max_heap) # 4\nval = flag * heapq.heappop(max_heap) # 3\nval = flag * heapq.heappop(max_heap) # 2\nval = flag * heapq.heappop(max_heap) # 1\n# \u83b7\u53d6\u5806\u5927\u5c0f\nsize: int = len(max_heap)\n# \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = not max_heap\n# \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806\nmin_heap: List[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\n
    heap.go
    // Go \u8bed\u8a00\u4e2d\u53ef\u4ee5\u901a\u8fc7\u5b9e\u73b0 heap.Interface \u6765\u6784\u5efa\u6574\u6570\u5927\u9876\u5806\n// \u5b9e\u73b0 heap.Interface \u9700\u8981\u540c\u65f6\u5b9e\u73b0 sort.Interface\ntype intHeap []any\n// Push heap.Interface \u7684\u65b9\u6cd5\uff0c\u5b9e\u73b0\u63a8\u5165\u5143\u7d20\u5230\u5806\nfunc (h *intHeap) Push(x any) {\n// Push \u548c Pop \u4f7f\u7528 pointer receiver \u4f5c\u4e3a\u53c2\u6570\n// \u56e0\u4e3a\u5b83\u4eec\u4e0d\u4ec5\u4f1a\u5bf9\u5207\u7247\u7684\u5185\u5bb9\u8fdb\u884c\u8c03\u6574\uff0c\u8fd8\u4f1a\u4fee\u6539\u5207\u7247\u7684\u957f\u5ea6\u3002\n*h = append(*h, x.(int))\n}\n// Pop heap.Interface \u7684\u65b9\u6cd5\uff0c\u5b9e\u73b0\u5f39\u51fa\u5806\u9876\u5143\u7d20\nfunc (h *intHeap) Pop() any {\n// \u5f85\u51fa\u5806\u5143\u7d20\u5b58\u653e\u5728\u6700\u540e\nlast := (*h)[len(*h)-1]\n*h = (*h)[:len(*h)-1]\nreturn last\n}\n// Len sort.Interface \u7684\u65b9\u6cd5\nfunc (h *intHeap) Len() int {\nreturn len(*h)\n}\n// Less sort.Interface \u7684\u65b9\u6cd5\nfunc (h *intHeap) Less(i, j int) bool {\n// \u5982\u679c\u5b9e\u73b0\u5c0f\u9876\u5806\uff0c\u5219\u9700\u8981\u8c03\u6574\u4e3a\u5c0f\u4e8e\u53f7\nreturn (*h)[i].(int) > (*h)[j].(int)\n}\n// Swap sort.Interface \u7684\u65b9\u6cd5\nfunc (h *intHeap) Swap(i, j int) {\n(*h)[i], (*h)[j] = (*h)[j], (*h)[i]\n}\n// Top \u83b7\u53d6\u5806\u9876\u5143\u7d20\nfunc (h *intHeap) Top() any {\nreturn (*h)[0]\n}\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n/* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5927\u9876\u5806\nmaxHeap := &intHeap{}\nheap.Init(maxHeap)\n/* \u5143\u7d20\u5165\u5806 */\n// \u8c03\u7528 heap.Interface \u7684\u65b9\u6cd5\uff0c\u6765\u6dfb\u52a0\u5143\u7d20\nheap.Push(maxHeap, 1)\nheap.Push(maxHeap, 3)\nheap.Push(maxHeap, 2)\nheap.Push(maxHeap, 4)\nheap.Push(maxHeap, 5)\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\ntop := maxHeap.Top()\nfmt.Printf(\"\u5806\u9876\u5143\u7d20\u4e3a %d\\n\", top)\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n// \u8c03\u7528 heap.Interface \u7684\u65b9\u6cd5\uff0c\u6765\u79fb\u9664\u5143\u7d20\nheap.Pop(maxHeap) // 5\nheap.Pop(maxHeap) // 4\nheap.Pop(maxHeap) // 3\nheap.Pop(maxHeap) // 2\nheap.Pop(maxHeap) // 1\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nsize := len(*maxHeap)\nfmt.Printf(\"\u5806\u5143\u7d20\u6570\u91cf\u4e3a %d\\n\", size)\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nisEmpty := len(*maxHeap) == 0\nfmt.Printf(\"\u5806\u662f\u5426\u4e3a\u7a7a %t\\n\", isEmpty)\n}\n
    heap.js
    // JavaScript \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.ts
    // TypeScript \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.cs
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nPriorityQueue<int, int> minHeap = new PriorityQueue<int, int>();\n// \u521d\u59cb\u5316\u5927\u9876\u5806\uff08\u4f7f\u7528 lambda \u8868\u8fbe\u5f0f\u4fee\u6539 Comparator \u5373\u53ef\uff09\nPriorityQueue<int, int> maxHeap = new PriorityQueue<int, int>(Comparer<int>.Create((x, y) => y - x));\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.Enqueue(1, 1);\nmaxHeap.Enqueue(3, 3);\nmaxHeap.Enqueue(2, 2);\nmaxHeap.Enqueue(5, 5);\nmaxHeap.Enqueue(4, 4);\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.Peek();//5\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n// \u51fa\u5806\u5143\u7d20\u4f1a\u5f62\u6210\u4e00\u4e2a\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\npeek = maxHeap.Dequeue();  // 5\npeek = maxHeap.Dequeue();  // 4\npeek = maxHeap.Dequeue();  // 3\npeek = maxHeap.Dequeue();  // 2\npeek = maxHeap.Dequeue();  // 1\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.Count;\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = maxHeap.Count == 0;\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = new PriorityQueue<int, int>(new List<(int, int)> { (1, 1), (3, 3), (2, 2), (5, 5), (4, 4), });\n
    heap.swift
    // Swift \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.zig
    \n
    heap.dart
    // Dart \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    "},{"location":"chapter_heap/heap/#812","title":"8.1.2. \u00a0 \u5806\u7684\u5b9e\u73b0","text":"

    \u4e0b\u6587\u5b9e\u73b0\u7684\u662f\u5927\u9876\u5806\u3002\u82e5\u8981\u5c06\u5176\u8f6c\u6362\u4e3a\u5c0f\u9876\u5806\uff0c\u53ea\u9700\u5c06\u6240\u6709\u5927\u5c0f\u903b\u8f91\u5224\u65ad\u53d6\u9006\uff08\u4f8b\u5982\uff0c\u5c06 \\(\\geq\\) \u66ff\u6362\u4e3a \\(\\leq\\) \uff09\u3002\u611f\u5174\u8da3\u7684\u8bfb\u8005\u53ef\u4ee5\u81ea\u884c\u5b9e\u73b0\u3002

    "},{"location":"chapter_heap/heap/#_1","title":"\u5806\u7684\u5b58\u50a8\u4e0e\u8868\u793a","text":"

    \u6211\u4eec\u5728\u4e8c\u53c9\u6811\u7ae0\u8282\u4e2d\u5b66\u4e60\u5230\uff0c\u5b8c\u5168\u4e8c\u53c9\u6811\u975e\u5e38\u9002\u5408\u7528\u6570\u7ec4\u6765\u8868\u793a\u3002\u7531\u4e8e\u5806\u6b63\u662f\u4e00\u79cd\u5b8c\u5168\u4e8c\u53c9\u6811\uff0c\u6211\u4eec\u5c06\u91c7\u7528\u6570\u7ec4\u6765\u5b58\u50a8\u5806\u3002

    \u5f53\u4f7f\u7528\u6570\u7ec4\u8868\u793a\u4e8c\u53c9\u6811\u65f6\uff0c\u5143\u7d20\u4ee3\u8868\u8282\u70b9\u503c\uff0c\u7d22\u5f15\u4ee3\u8868\u8282\u70b9\u5728\u4e8c\u53c9\u6811\u4e2d\u7684\u4f4d\u7f6e\u3002\u8282\u70b9\u6307\u9488\u901a\u8fc7\u7d22\u5f15\u6620\u5c04\u516c\u5f0f\u6765\u5b9e\u73b0\u3002

    \u5177\u4f53\u800c\u8a00\uff0c\u7ed9\u5b9a\u7d22\u5f15 \\(i\\) \uff0c\u5176\u5de6\u5b50\u8282\u70b9\u7d22\u5f15\u4e3a \\(2i + 1\\) \uff0c\u53f3\u5b50\u8282\u70b9\u7d22\u5f15\u4e3a \\(2i + 2\\) \uff0c\u7236\u8282\u70b9\u7d22\u5f15\u4e3a \\((i - 1) / 2\\)\uff08\u5411\u4e0b\u53d6\u6574\uff09\u3002\u5f53\u7d22\u5f15\u8d8a\u754c\u65f6\uff0c\u8868\u793a\u7a7a\u8282\u70b9\u6216\u8282\u70b9\u4e0d\u5b58\u5728\u3002

    Fig. \u5806\u7684\u8868\u793a\u4e0e\u5b58\u50a8

    \u6211\u4eec\u53ef\u4ee5\u5c06\u7d22\u5f15\u6620\u5c04\u516c\u5f0f\u5c01\u88c5\u6210\u51fd\u6570\uff0c\u65b9\u4fbf\u540e\u7eed\u4f7f\u7528\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_heap.java
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nint left(int i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nint right(int i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nint parent(int i) {\nreturn (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.cpp
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nint left(int i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nint right(int i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nint parent(int i) {\nreturn (i - 1) / 2; // \u5411\u4e0b\u53d6\u6574\n}\n
    my_heap.py
    def left(self, i: int) -> int:\n\"\"\"\u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15\"\"\"\nreturn 2 * i + 1\ndef right(self, i: int) -> int:\n\"\"\"\u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15\"\"\"\nreturn 2 * i + 2\ndef parent(self, i: int) -> int:\n\"\"\"\u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15\"\"\"\nreturn (i - 1) // 2  # \u5411\u4e0b\u6574\u9664\n
    my_heap.go
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nfunc (h *maxHeap) left(i int) int {\nreturn 2*i + 1\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nfunc (h *maxHeap) right(i int) int {\nreturn 2*i + 2\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nfunc (h *maxHeap) parent(i int) int {\n// \u5411\u4e0b\u6574\u9664\nreturn (i - 1) / 2\n}\n
    my_heap.js
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\n#left(i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\n#right(i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\n#parent(i) {\nreturn Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.ts
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nleft(i: number): number {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nright(i: number): number {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nparent(i: number): number {\nreturn Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.c
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nint left(maxHeap *h, int i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nint right(maxHeap *h, int i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nint parent(maxHeap *h, int i) {\nreturn (i - 1) / 2;\n}\n
    my_heap.cs
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nint left(int i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nint right(int i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nint parent(int i) {\nreturn (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.swift
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nfunc left(i: Int) -> Int {\n2 * i + 1\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nfunc right(i: Int) -> Int {\n2 * i + 2\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nfunc parent(i: Int) -> Int {\n(i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.zig
    // \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15\nfn left(i: usize) usize {\nreturn 2 * i + 1;\n}\n// \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15\nfn right(i: usize) usize {\nreturn 2 * i + 2;\n}\n// \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15\nfn parent(i: usize) usize {\n// return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\nreturn @divFloor(i - 1, 2);\n}\n
    my_heap.dart
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7d22\u5f15 */\nint _left(int i) {\nreturn 2 * i + 1;\n}\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7d22\u5f15 */\nint _right(int i) {\nreturn 2 * i + 2;\n}\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7d22\u5f15 */\nint _parent(int i) {\nreturn (i - 1) ~/ 2; // \u5411\u4e0b\u6574\u9664\n}\n
    "},{"location":"chapter_heap/heap/#_2","title":"\u8bbf\u95ee\u5806\u9876\u5143\u7d20","text":"

    \u5806\u9876\u5143\u7d20\u5373\u4e3a\u4e8c\u53c9\u6811\u7684\u6839\u8282\u70b9\uff0c\u4e5f\u5c31\u662f\u5217\u8868\u7684\u9996\u4e2a\u5143\u7d20\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_heap.java
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\nreturn maxHeap.get(0);\n}\n
    my_heap.cpp
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\nreturn maxHeap[0];\n}\n
    my_heap.py
    def peek(self) -> int:\n\"\"\"\u8bbf\u95ee\u5806\u9876\u5143\u7d20\"\"\"\nreturn self.max_heap[0]\n
    my_heap.go
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunc (h *maxHeap) peek() any {\nreturn h.data[0]\n}\n
    my_heap.js
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\npeek() {\nreturn this.#maxHeap[0];\n}\n
    my_heap.ts
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\npeek(): number {\nreturn this.maxHeap[0];\n}\n
    my_heap.c
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek(maxHeap *h) {\nreturn h->data[0];\n}\n
    my_heap.cs
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\nreturn maxHeap[0];\n}\n
    my_heap.swift
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunc peek() -> Int {\nmaxHeap[0]\n}\n
    my_heap.zig
    // \u8bbf\u95ee\u5806\u9876\u5143\u7d20\nfn peek(self: *Self) T {\nreturn self.max_heap.?.items[0];\n}
    my_heap.dart
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\nreturn _maxHeap[0];\n}\n
    "},{"location":"chapter_heap/heap/#_3","title":"\u5143\u7d20\u5165\u5806","text":"

    \u7ed9\u5b9a\u5143\u7d20 val \uff0c\u6211\u4eec\u9996\u5148\u5c06\u5176\u6dfb\u52a0\u5230\u5806\u5e95\u3002\u6dfb\u52a0\u4e4b\u540e\uff0c\u7531\u4e8e val \u53ef\u80fd\u5927\u4e8e\u5806\u4e2d\u5176\u4ed6\u5143\u7d20\uff0c\u5806\u7684\u6210\u7acb\u6761\u4ef6\u53ef\u80fd\u5df2\u88ab\u7834\u574f\u3002\u56e0\u6b64\uff0c\u9700\u8981\u4fee\u590d\u4ece\u63d2\u5165\u8282\u70b9\u5230\u6839\u8282\u70b9\u7684\u8def\u5f84\u4e0a\u7684\u5404\u4e2a\u8282\u70b9\uff0c\u8fd9\u4e2a\u64cd\u4f5c\u88ab\u79f0\u4e3a\u300c\u5806\u5316 Heapify\u300d\u3002

    \u8003\u8651\u4ece\u5165\u5806\u8282\u70b9\u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u6267\u884c\u5806\u5316\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u6211\u4eec\u6bd4\u8f83\u63d2\u5165\u8282\u70b9\u4e0e\u5176\u7236\u8282\u70b9\u7684\u503c\uff0c\u5982\u679c\u63d2\u5165\u8282\u70b9\u66f4\u5927\uff0c\u5219\u5c06\u5b83\u4eec\u4ea4\u6362\u3002\u7136\u540e\u7ee7\u7eed\u6267\u884c\u6b64\u64cd\u4f5c\uff0c\u4ece\u5e95\u81f3\u9876\u4fee\u590d\u5806\u4e2d\u7684\u5404\u4e2a\u8282\u70b9\uff0c\u76f4\u81f3\u8d8a\u8fc7\u6839\u8282\u70b9\u6216\u9047\u5230\u65e0\u9700\u4ea4\u6362\u7684\u8282\u70b9\u65f6\u7ed3\u675f\u3002

    <1><2><3><4><5><6><7><8><9>

    \u8bbe\u8282\u70b9\u603b\u6570\u4e3a \\(n\\) \uff0c\u5219\u6811\u7684\u9ad8\u5ea6\u4e3a \\(O(\\log n)\\) \u3002\u7531\u6b64\u53ef\u77e5\uff0c\u5806\u5316\u64cd\u4f5c\u7684\u5faa\u73af\u8f6e\u6570\u6700\u591a\u4e3a \\(O(\\log n)\\) \uff0c\u5143\u7d20\u5165\u5806\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_heap.java
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(int val) {\n// \u6dfb\u52a0\u8282\u70b9\nmaxHeap.add(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nsiftUp(size() - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nint p = parent(i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 || maxHeap.get(i) <= maxHeap.get(p))\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.cpp
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(int val) {\n// \u6dfb\u52a0\u8282\u70b9\nmaxHeap.push_back(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nsiftUp(size() - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nint p = parent(i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 || maxHeap[i] <= maxHeap[p])\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(maxHeap[i], maxHeap[p]);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.py
    def push(self, val: int):\n\"\"\"\u5143\u7d20\u5165\u5806\"\"\"\n# \u6dfb\u52a0\u8282\u70b9\nself.max_heap.append(val)\n# \u4ece\u5e95\u81f3\u9876\u5806\u5316\nself.sift_up(self.size() - 1)\ndef sift_up(self, i: int):\n\"\"\"\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316\"\"\"\nwhile True:\n# \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\np = self.parent(i)\n# \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif p < 0 or self.max_heap[i] <= self.max_heap[p]:\nbreak\n# \u4ea4\u6362\u4e24\u8282\u70b9\nself.swap(i, p)\n# \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p\n
    my_heap.go
    /* \u5143\u7d20\u5165\u5806 */\nfunc (h *maxHeap) push(val any) {\n// \u6dfb\u52a0\u8282\u70b9\nh.data = append(h.data, val)\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nh.siftUp(len(h.data) - 1)\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfunc (h *maxHeap) siftUp(i int) {\nfor true {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\np := h.parent(i)\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif p < 0 || h.data[i].(int) <= h.data[p].(int) {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nh.swap(i, p)\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p\n}\n}\n
    my_heap.js
    /* \u5143\u7d20\u5165\u5806 */\npush(val) {\n// \u6dfb\u52a0\u8282\u70b9\nthis.#maxHeap.push(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nthis.#siftUp(this.size() - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\n#siftUp(i) {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nconst p = this.#parent(i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nthis.#swap(i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.ts
    /* \u5143\u7d20\u5165\u5806 */\npush(val: number): void {\n// \u6dfb\u52a0\u8282\u70b9\nthis.maxHeap.push(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nthis.siftUp(this.size() - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nsiftUp(i: number): void {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nconst p = this.parent(i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nthis.swap(i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.c
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(maxHeap *h, int val) {\n// \u9ed8\u8ba4\u60c5\u51b5\u4e0b\uff0c\u4e0d\u5e94\u8be5\u6dfb\u52a0\u8fd9\u4e48\u591a\u8282\u70b9\nif (h->size == MAX_SIZE) {\nprintf(\"heap is full!\");\nreturn;\n}\n// \u6dfb\u52a0\u8282\u70b9\nh->data[h->size] = val;\nh->size++;\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nsiftUp(h, h->size - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(maxHeap *h, int i) {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nint p = parent(h, i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 || h->data[i] <= h->data[p]) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(h, i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.cs
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(int val) {\n// \u6dfb\u52a0\u8282\u70b9\nmaxHeap.Add(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nsiftUp(size() - 1);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nint p = parent(i);\n// \u82e5\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\uff0c\u5219\u7ed3\u675f\u5806\u5316\nif (p < 0 || maxHeap[i] <= maxHeap[p])\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.swift
    /* \u5143\u7d20\u5165\u5806 */\nfunc push(val: Int) {\n// \u6dfb\u52a0\u8282\u70b9\nmaxHeap.append(val)\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\nsiftUp(i: size() - 1)\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfunc siftUp(i: Int) {\nvar i = i\nwhile true {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nlet p = parent(i: i)\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif p < 0 || maxHeap[i] <= maxHeap[p] {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i: i, j: p)\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p\n}\n}\n
    my_heap.zig
    // \u5143\u7d20\u5165\u5806\nfn push(self: *Self, val: T) !void {\n// \u6dfb\u52a0\u8282\u70b9\ntry self.max_heap.?.append(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\ntry self.siftUp(self.size() - 1);\n}  // \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316\nfn siftUp(self: *Self, i_: usize) !void {\nvar i = i_;\nwhile (true) {\n// \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\nvar p = parent(i);\n// \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u9700\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\nif (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\ntry self.swap(i, p);\n// \u5faa\u73af\u5411\u4e0a\u5806\u5316\ni = p;\n}\n}\n
    my_heap.dart
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(int val) {\n// \u6dfb\u52a0\u8282\u70b9\n_maxHeap.add(val);\n// \u4ece\u5e95\u81f3\u9876\u5806\u5316\n_siftUp(size() - 1);\n}\n[class]{MaxHeap}-[func]{siftUp}\n
    "},{"location":"chapter_heap/heap/#_4","title":"\u5806\u9876\u5143\u7d20\u51fa\u5806","text":"

    \u5806\u9876\u5143\u7d20\u662f\u4e8c\u53c9\u6811\u7684\u6839\u8282\u70b9\uff0c\u5373\u5217\u8868\u9996\u5143\u7d20\u3002\u5982\u679c\u6211\u4eec\u76f4\u63a5\u4ece\u5217\u8868\u4e2d\u5220\u9664\u9996\u5143\u7d20\uff0c\u90a3\u4e48\u4e8c\u53c9\u6811\u4e2d\u6240\u6709\u8282\u70b9\u7684\u7d22\u5f15\u90fd\u4f1a\u53d1\u751f\u53d8\u5316\uff0c\u8fd9\u5c06\u4f7f\u5f97\u540e\u7eed\u4f7f\u7528\u5806\u5316\u4fee\u590d\u53d8\u5f97\u56f0\u96be\u3002\u4e3a\u4e86\u5c3d\u91cf\u51cf\u5c11\u5143\u7d20\u7d22\u5f15\u7684\u53d8\u52a8\uff0c\u6211\u4eec\u91c7\u53d6\u4ee5\u4e0b\u64cd\u4f5c\u6b65\u9aa4\uff1a

    1. \u4ea4\u6362\u5806\u9876\u5143\u7d20\u4e0e\u5806\u5e95\u5143\u7d20\uff08\u5373\u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff09\uff1b
    2. \u4ea4\u6362\u5b8c\u6210\u540e\uff0c\u5c06\u5806\u5e95\u4ece\u5217\u8868\u4e2d\u5220\u9664\uff08\u6ce8\u610f\uff0c\u7531\u4e8e\u5df2\u7ecf\u4ea4\u6362\uff0c\u5b9e\u9645\u4e0a\u5220\u9664\u7684\u662f\u539f\u6765\u7684\u5806\u9876\u5143\u7d20\uff09\uff1b
    3. \u4ece\u6839\u8282\u70b9\u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u6267\u884c\u5806\u5316\uff1b

    \u987e\u540d\u601d\u4e49\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\u7684\u64cd\u4f5c\u65b9\u5411\u4e0e\u4ece\u5e95\u81f3\u9876\u5806\u5316\u76f8\u53cd\uff0c\u6211\u4eec\u5c06\u6839\u8282\u70b9\u7684\u503c\u4e0e\u5176\u4e24\u4e2a\u5b50\u8282\u70b9\u7684\u503c\u8fdb\u884c\u6bd4\u8f83\uff0c\u5c06\u6700\u5927\u7684\u5b50\u8282\u70b9\u4e0e\u6839\u8282\u70b9\u4ea4\u6362\uff1b\u7136\u540e\u5faa\u73af\u6267\u884c\u6b64\u64cd\u4f5c\uff0c\u76f4\u5230\u8d8a\u8fc7\u53f6\u8282\u70b9\u6216\u9047\u5230\u65e0\u9700\u4ea4\u6362\u7684\u8282\u70b9\u65f6\u7ed3\u675f\u3002

    <1><2><3><4><5><6><7><8><9><10>

    \u4e0e\u5143\u7d20\u5165\u5806\u64cd\u4f5c\u76f8\u4f3c\uff0c\u5806\u9876\u5143\u7d20\u51fa\u5806\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e5f\u4e3a \\(O(\\log n)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart my_heap.java
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n// \u5224\u7a7a\u5904\u7406\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(0, size() - 1);\n// \u5220\u9664\u8282\u70b9\nint val = maxHeap.remove(size() - 1);\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nsiftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = left(i), r = right(i), ma = i;\nif (l < size() && maxHeap.get(l) > maxHeap.get(ma))\nma = l;\nif (r < size() && maxHeap.get(r) > maxHeap.get(ma))\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i)\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i, ma);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.cpp
    /* \u5143\u7d20\u51fa\u5806 */\nvoid pop() {\n// \u5224\u7a7a\u5904\u7406\nif (empty()) {\nthrow out_of_range(\"\u5806\u4e3a\u7a7a\");\n}\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(maxHeap[0], maxHeap[size() - 1]);\n// \u5220\u9664\u8282\u70b9\nmaxHeap.pop_back();\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nsiftDown(0);\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = left(i), r = right(i), ma = i;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (l < size() && maxHeap[l] > maxHeap[ma])\nma = l;\nif (r < size() && maxHeap[r] > maxHeap[ma])\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i)\nbreak;\nswap(maxHeap[i], maxHeap[ma]);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.py
    def pop(self) -> int:\n\"\"\"\u5143\u7d20\u51fa\u5806\"\"\"\n# \u5224\u7a7a\u5904\u7406\nif self.is_empty():\nraise IndexError(\"\u5806\u4e3a\u7a7a\")\n# \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nself.swap(0, self.size() - 1)\n# \u5220\u9664\u8282\u70b9\nval = self.max_heap.pop()\n# \u4ece\u9876\u81f3\u5e95\u5806\u5316\nself.sift_down(0)\n# \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val\ndef sift_down(self, i: int):\n\"\"\"\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\"\"\"\nwhile True:\n# \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nl, r, ma = self.left(i), self.right(i), i\nif l < self.size() and self.max_heap[l] > self.max_heap[ma]:\nma = l\nif r < self.size() and self.max_heap[r] > self.max_heap[ma]:\nma = r\n# \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif ma == i:\nbreak\n# \u4ea4\u6362\u4e24\u8282\u70b9\nself.swap(i, ma)\n# \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma\n
    my_heap.go
    /* \u5143\u7d20\u51fa\u5806 */\nfunc (h *maxHeap) pop() any {\n// \u5224\u7a7a\u5904\u7406\nif h.isEmpty() {\nfmt.Println(\"error\")\nreturn nil\n}\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nh.swap(0, h.size()-1)\n// \u5220\u9664\u8282\u70b9\nval := h.data[len(h.data)-1]\nh.data = h.data[:len(h.data)-1]\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nh.siftDown(0)\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc (h *maxHeap) siftDown(i int) {\nfor true {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a max\nl, r, max := h.left(i), h.right(i), i\nif l < h.size() && h.data[l].(int) > h.data[max].(int) {\nmax = l\n}\nif r < h.size() && h.data[r].(int) > h.data[max].(int) {\nmax = r\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif max == i {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nh.swap(i, max)\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = max\n}\n}\n
    my_heap.js
    /* \u5143\u7d20\u51fa\u5806 */\npop() {\n// \u5224\u7a7a\u5904\u7406\nif (this.isEmpty()) throw new Error('\u5806\u4e3a\u7a7a');\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nthis.#swap(0, this.size() - 1);\n// \u5220\u9664\u8282\u70b9\nconst val = this.#maxHeap.pop();\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nthis.#siftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\n#siftDown(i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nconst l = this.#left(i),\nr = this.#right(i);\nlet ma = i;\nif (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;\nif (r < this.size() && this.#maxHeap[r] > this.#maxHeap[ma]) ma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nthis.#swap(i, ma);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.ts
    /* \u5143\u7d20\u51fa\u5806 */\npop(): number {\n// \u5224\u7a7a\u5904\u7406\nif (this.isEmpty()) throw new RangeError('Heap is empty.');\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nthis.swap(0, this.size() - 1);\n// \u5220\u9664\u8282\u70b9\nconst val = this.maxHeap.pop();\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nthis.siftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nsiftDown(i: number): void {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nconst l = this.left(i),\nr = this.right(i);\nlet ma = i;\nif (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l;\nif (r < this.size() && this.maxHeap[r] > this.maxHeap[ma]) ma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nthis.swap(i, ma);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.c
    /* \u5143\u7d20\u51fa\u5806 */\nint pop(maxHeap *h) {\n// \u5224\u7a7a\u5904\u7406\nif (isEmpty(h)) {\nprintf(\"heap is empty!\");\nreturn INT_MAX;\n}\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(h, 0, size(h) - 1);\n// \u5220\u9664\u8282\u70b9\nint val = h->data[h->size - 1];\nh->size--;\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nsiftDown(h, 0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(maxHeap *h, int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a max\nint l = left(h, i);\nint r = right(h, i);\nint max = i;\nif (l < size(h) && h->data[l] > h->data[max]) {\nmax = l;\n}\nif (r < size(h) && h->data[r] > h->data[max]) {\nmax = r;\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (max == i) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(h, i, max);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = max;\n}\n}\n
    my_heap.cs
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n// \u5224\u7a7a\u5904\u7406\nif (isEmpty())\nthrow new IndexOutOfRangeException();\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(0, size() - 1);\n// \u5220\u9664\u8282\u70b9\nint val = maxHeap.Last();\nmaxHeap.RemoveAt(size() - 1);\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nsiftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = left(i), r = right(i), ma = i;\nif (l < size() && maxHeap[l] > maxHeap[ma])\nma = l;\nif (r < size() && maxHeap[r] > maxHeap[ma])\nma = r;\n// \u82e5\u201c\u8282\u70b9 i \u6700\u5927\u201d\u6216\u201c\u8d8a\u8fc7\u53f6\u8282\u70b9\u201d\uff0c\u5219\u7ed3\u675f\u5806\u5316\nif (ma == i) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i, ma);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.swift
    /* \u5143\u7d20\u51fa\u5806 */\nfunc pop() -> Int {\n// \u5224\u7a7a\u5904\u7406\nif isEmpty() {\nfatalError(\"\u5806\u4e3a\u7a7a\")\n}\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(i: 0, j: size() - 1)\n// \u5220\u9664\u8282\u70b9\nlet val = maxHeap.remove(at: size() - 1)\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\nsiftDown(i: 0)\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val\n}\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc siftDown(i: Int) {\nvar i = i\nwhile true {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nlet l = left(i: i)\nlet r = right(i: i)\nvar ma = i\nif l < size(), maxHeap[l] > maxHeap[ma] {\nma = l\n}\nif r < size(), maxHeap[r] > maxHeap[ma] {\nma = r\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif ma == i {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(i: i, j: ma)\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma\n}\n}\n
    my_heap.zig
    // \u5143\u7d20\u51fa\u5806\nfn pop(self: *Self) !T {\n// \u5224\u65ad\u5904\u7406\nif (self.isEmpty()) unreachable;\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\ntry self.swap(0, self.size() - 1);\n// \u5220\u9664\u8282\u70b9\nvar val = self.max_heap.?.pop();\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\ntry self.siftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n} // \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\nfn siftDown(self: *Self, i_: usize) !void {\nvar i = i_;\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nvar l = left(i);\nvar r = right(i);\nvar ma = i;\nif (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l;\nif (r < self.size() and self.max_heap.?.items[r] > self.max_heap.?.items[ma]) ma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\ntry self.swap(i, ma);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n
    my_heap.dart
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n// \u5224\u7a7a\u5904\u7406\nif (isEmpty()) throw Exception('\u5806\u4e3a\u7a7a');\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n_swap(0, size() - 1);\n// \u5220\u9664\u8282\u70b9\nint val = _maxHeap.removeLast();\n// \u4ece\u9876\u81f3\u5e95\u5806\u5316\n_siftDown(0);\n// \u8fd4\u56de\u5806\u9876\u5143\u7d20\nreturn val;\n}\n[class]{MaxHeap}-[func]{siftDown}\n
    "},{"location":"chapter_heap/heap/#813","title":"8.1.3. \u00a0 \u5806\u5e38\u89c1\u5e94\u7528","text":"
    • \u4f18\u5148\u961f\u5217\uff1a\u5806\u901a\u5e38\u4f5c\u4e3a\u5b9e\u73b0\u4f18\u5148\u961f\u5217\u7684\u9996\u9009\u6570\u636e\u7ed3\u6784\uff0c\u5176\u5165\u961f\u548c\u51fa\u961f\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(\\log n)\\) \uff0c\u800c\u5efa\u961f\u64cd\u4f5c\u4e3a \\(O(n)\\) \uff0c\u8fd9\u4e9b\u64cd\u4f5c\u90fd\u975e\u5e38\u9ad8\u6548\u3002
    • \u5806\u6392\u5e8f\uff1a\u7ed9\u5b9a\u4e00\u7ec4\u6570\u636e\uff0c\u6211\u4eec\u53ef\u4ee5\u7528\u5b83\u4eec\u5efa\u7acb\u4e00\u4e2a\u5806\uff0c\u7136\u540e\u4e0d\u65ad\u5730\u6267\u884c\u5143\u7d20\u51fa\u5806\u64cd\u4f5c\uff0c\u4ece\u800c\u5f97\u5230\u6709\u5e8f\u6570\u636e\u3002\u7136\u800c\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u4f7f\u7528\u4e00\u79cd\u66f4\u4f18\u96c5\u7684\u65b9\u5f0f\u5b9e\u73b0\u5806\u6392\u5e8f\uff0c\u8be6\u89c1\u540e\u7eed\u7684\u5806\u6392\u5e8f\u7ae0\u8282\u3002
    • \u83b7\u53d6\u6700\u5927\u7684 \\(k\\) \u4e2a\u5143\u7d20\uff1a\u8fd9\u662f\u4e00\u4e2a\u7ecf\u5178\u7684\u7b97\u6cd5\u95ee\u9898\uff0c\u540c\u65f6\u4e5f\u662f\u4e00\u79cd\u5178\u578b\u5e94\u7528\uff0c\u4f8b\u5982\u9009\u62e9\u70ed\u5ea6\u524d 10 \u7684\u65b0\u95fb\u4f5c\u4e3a\u5fae\u535a\u70ed\u641c\uff0c\u9009\u53d6\u9500\u91cf\u524d 10 \u7684\u5546\u54c1\u7b49\u3002
    "},{"location":"chapter_heap/summary/","title":"8.4. \u00a0 \u5c0f\u7ed3","text":"
    • \u5806\u662f\u4e00\u68f5\u5b8c\u5168\u4e8c\u53c9\u6811\uff0c\u6839\u636e\u6210\u7acb\u6761\u4ef6\u53ef\u5206\u4e3a\u5927\u9876\u5806\u548c\u5c0f\u9876\u5806\u3002\u5927\uff08\u5c0f\uff09\u9876\u5806\u7684\u5806\u9876\u5143\u7d20\u662f\u6700\u5927\uff08\u5c0f\uff09\u7684\u3002
    • \u4f18\u5148\u961f\u5217\u7684\u5b9a\u4e49\u662f\u5177\u6709\u51fa\u961f\u4f18\u5148\u7ea7\u7684\u961f\u5217\uff0c\u901a\u5e38\u4f7f\u7528\u5806\u6765\u5b9e\u73b0\u3002
    • \u5806\u7684\u5e38\u7528\u64cd\u4f5c\u53ca\u5176\u5bf9\u5e94\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5305\u62ec\uff1a\u5143\u7d20\u5165\u5806 \\(O(\\log n)\\) \u3001\u5806\u9876\u5143\u7d20\u51fa\u5806 \\(O(\\log n)\\) \u548c\u8bbf\u95ee\u5806\u9876\u5143\u7d20 \\(O(1)\\) \u7b49\u3002
    • \u5b8c\u5168\u4e8c\u53c9\u6811\u975e\u5e38\u9002\u5408\u7528\u6570\u7ec4\u8868\u793a\uff0c\u56e0\u6b64\u6211\u4eec\u901a\u5e38\u4f7f\u7528\u6570\u7ec4\u6765\u5b58\u50a8\u5806\u3002
    • \u5806\u5316\u64cd\u4f5c\u7528\u4e8e\u7ef4\u62a4\u5806\u7684\u6027\u8d28\uff0c\u5728\u5165\u5806\u548c\u51fa\u5806\u64cd\u4f5c\u4e2d\u90fd\u4f1a\u7528\u5230\u3002
    • \u8f93\u5165 \\(n\\) \u4e2a\u5143\u7d20\u5e76\u5efa\u5806\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u4f18\u5316\u81f3 \\(O(n)\\) \uff0c\u975e\u5e38\u9ad8\u6548\u3002
    • Top-K \u662f\u4e00\u4e2a\u7ecf\u5178\u7b97\u6cd5\u95ee\u9898\uff0c\u53ef\u4ee5\u4f7f\u7528\u5806\u6570\u636e\u7ed3\u6784\u9ad8\u6548\u89e3\u51b3\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log k)\\) \u3002
    "},{"location":"chapter_heap/summary/#841-q-a","title":"8.4.1. \u00a0 Q & A","text":"

    \u6570\u636e\u7ed3\u6784\u7684\u201c\u5806\u201d\u4e0e\u5185\u5b58\u7ba1\u7406\u7684\u201c\u5806\u201d\u662f\u540c\u4e00\u4e2a\u6982\u5ff5\u5417\uff1f

    \u4e24\u8005\u4e0d\u662f\u540c\u4e00\u4e2a\u6982\u5ff5\uff0c\u53ea\u662f\u78b0\u5de7\u90fd\u53eb\u5806\u3002\u8ba1\u7b97\u673a\u7cfb\u7edf\u5185\u5b58\u4e2d\u7684\u5806\u662f\u52a8\u6001\u5185\u5b58\u5206\u914d\u7684\u4e00\u90e8\u5206\uff0c\u7a0b\u5e8f\u5728\u8fd0\u884c\u65f6\u53ef\u4ee5\u4f7f\u7528\u5b83\u6765\u5b58\u50a8\u6570\u636e\u3002\u7a0b\u5e8f\u53ef\u4ee5\u8bf7\u6c42\u4e00\u5b9a\u91cf\u7684\u5806\u5185\u5b58\uff0c\u7528\u4e8e\u5b58\u50a8\u5982\u5bf9\u8c61\u548c\u6570\u7ec4\u7b49\u590d\u6742\u7ed3\u6784\u3002\u5f53\u8fd9\u4e9b\u6570\u636e\u4e0d\u518d\u9700\u8981\u65f6\uff0c\u7a0b\u5e8f\u9700\u8981\u91ca\u653e\u8fd9\u4e9b\u5185\u5b58\uff0c\u4ee5\u9632\u6b62\u5185\u5b58\u6cc4\u9732\u3002\u76f8\u8f83\u4e8e\u6808\u5185\u5b58\uff0c\u5806\u5185\u5b58\u7684\u7ba1\u7406\u548c\u4f7f\u7528\u9700\u8981\u66f4\u8c28\u614e\uff0c\u4e0d\u6070\u5f53\u7684\u4f7f\u7528\u53ef\u80fd\u4f1a\u5bfc\u81f4\u5185\u5b58\u6cc4\u9732\u548c\u91ce\u6307\u9488\u7b49\u95ee\u9898\u3002

    "},{"location":"chapter_heap/top_k/","title":"8.3. \u00a0 Top-K \u95ee\u9898","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u65e0\u5e8f\u6570\u7ec4 nums \uff0c\u8bf7\u8fd4\u56de\u6570\u7ec4\u4e2d\u524d \\(k\\) \u5927\u7684\u5143\u7d20\u3002

    \u5bf9\u4e8e\u8be5\u95ee\u9898\uff0c\u6211\u4eec\u5148\u4ecb\u7ecd\u4e24\u79cd\u601d\u8def\u6bd4\u8f83\u76f4\u63a5\u7684\u89e3\u6cd5\uff0c\u518d\u4ecb\u7ecd\u6548\u7387\u66f4\u9ad8\u7684\u5806\u89e3\u6cd5\u3002

    "},{"location":"chapter_heap/top_k/#831","title":"8.3.1. \u00a0 \u65b9\u6cd5\u4e00\uff1a\u904d\u5386\u9009\u62e9","text":"

    \u6211\u4eec\u53ef\u4ee5\u8fdb\u884c \\(k\\) \u8f6e\u904d\u5386\uff0c\u5206\u522b\u5728\u6bcf\u8f6e\u4e2d\u63d0\u53d6\u7b2c \\(1\\) , \\(2\\) , \\(\\cdots\\) , \\(k\\) \u5927\u7684\u5143\u7d20\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(nk)\\) \u3002

    \u8be5\u65b9\u6cd5\u53ea\u9002\u7528\u4e8e \\(k \\ll n\\) \u7684\u60c5\u51b5\uff0c\u56e0\u4e3a\u5f53 \\(k\\) \u4e0e \\(n\\) \u6bd4\u8f83\u63a5\u8fd1\u65f6\uff0c\u5176\u65f6\u95f4\u590d\u6742\u5ea6\u8d8b\u5411\u4e8e \\(O(n^2)\\) \uff0c\u975e\u5e38\u8017\u65f6\u3002

    Fig. \u904d\u5386\u5bfb\u627e\u6700\u5927\u7684 k \u4e2a\u5143\u7d20

    Tip

    \u5f53 \\(k = n\\) \u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u5230\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\uff0c\u7b49\u4ef7\u4e8e\u300c\u9009\u62e9\u6392\u5e8f\u300d\u7b97\u6cd5\u3002

    "},{"location":"chapter_heap/top_k/#832","title":"8.3.2. \u00a0 \u65b9\u6cd5\u4e8c\uff1a\u6392\u5e8f","text":"

    \u6211\u4eec\u53ef\u4ee5\u5bf9\u6570\u7ec4 nums \u8fdb\u884c\u6392\u5e8f\uff0c\u5e76\u8fd4\u56de\u6700\u53f3\u8fb9\u7684 \\(k\\) \u4e2a\u5143\u7d20\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002

    \u663e\u7136\uff0c\u8be5\u65b9\u6cd5\u201c\u8d85\u989d\u201d\u5b8c\u6210\u4efb\u52a1\u4e86\uff0c\u56e0\u4e3a\u6211\u4eec\u53ea\u9700\u8981\u627e\u51fa\u6700\u5927\u7684 \\(k\\) \u4e2a\u5143\u7d20\u5373\u53ef\uff0c\u800c\u4e0d\u9700\u8981\u6392\u5e8f\u5176\u4ed6\u5143\u7d20\u3002

    Fig. \u6392\u5e8f\u5bfb\u627e\u6700\u5927\u7684 k \u4e2a\u5143\u7d20

    "},{"location":"chapter_heap/top_k/#833","title":"8.3.3. \u00a0 \u65b9\u6cd5\u4e09\uff1a\u5806","text":"

    \u6211\u4eec\u53ef\u4ee5\u57fa\u4e8e\u5806\u66f4\u52a0\u9ad8\u6548\u5730\u89e3\u51b3 Top-K \u95ee\u9898\uff0c\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u521d\u59cb\u5316\u4e00\u4e2a\u5c0f\u9876\u5806\uff0c\u5176\u5806\u9876\u5143\u7d20\u6700\u5c0f\uff1b
    2. \u5148\u5c06\u6570\u7ec4\u7684\u524d \\(k\\) \u4e2a\u5143\u7d20\u4f9d\u6b21\u5165\u5806\uff1b
    3. \u4ece\u7b2c \\(k + 1\\) \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u82e5\u5f53\u524d\u5143\u7d20\u5927\u4e8e\u5806\u9876\u5143\u7d20\uff0c\u5219\u5c06\u5806\u9876\u5143\u7d20\u51fa\u5806\uff0c\u5e76\u5c06\u5f53\u524d\u5143\u7d20\u5165\u5806\uff1b
    4. \u904d\u5386\u5b8c\u6210\u540e\uff0c\u5806\u4e2d\u4fdd\u5b58\u7684\u5c31\u662f\u6700\u5927\u7684 \\(k\\) \u4e2a\u5143\u7d20\uff1b
    <1><2><3><4><5><6><7><8><9>

    \u603b\u5171\u6267\u884c\u4e86 \\(n\\) \u8f6e\u5165\u5806\u548c\u51fa\u5806\uff0c\u5806\u7684\u6700\u5927\u957f\u5ea6\u4e3a \\(k\\) \uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log k)\\) \u3002\u8be5\u65b9\u6cd5\u7684\u6548\u7387\u5f88\u9ad8\uff0c\u5f53 \\(k\\) \u8f83\u5c0f\u65f6\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u8d8b\u5411 \\(O(n)\\) \uff1b\u5f53 \\(k\\) \u8f83\u5927\u65f6\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u4f1a\u8d85\u8fc7 \\(O(n \\log n)\\) \u3002

    \u53e6\u5916\uff0c\u8be5\u65b9\u6cd5\u9002\u7528\u4e8e\u52a8\u6001\u6570\u636e\u6d41\u7684\u4f7f\u7528\u573a\u666f\u3002\u5728\u4e0d\u65ad\u52a0\u5165\u6570\u636e\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u6301\u7eed\u7ef4\u62a4\u5806\u5185\u7684\u5143\u7d20\uff0c\u4ece\u800c\u5b9e\u73b0\u6700\u5927 \\(k\\) \u4e2a\u5143\u7d20\u7684\u52a8\u6001\u66f4\u65b0\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart top_k.java
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nQueue<Integer> topKHeap(int[] nums, int k) {\nQueue<Integer> heap = new PriorityQueue<Integer>();\n// \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\nfor (int i = 0; i < k; i++) {\nheap.add(nums[i]);\n}\n// \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\nfor (int i = k; i < nums.length; i++) {\n// \u82e5\u5f53\u524d\u5143\u7d20\u5927\u4e8e\u5806\u9876\u5143\u7d20\uff0c\u5219\u5c06\u5806\u9876\u5143\u7d20\u51fa\u5806\u3001\u5f53\u524d\u5143\u7d20\u5165\u5806\nif (nums[i] > heap.peek()) {\nheap.poll();\nheap.add(nums[i]);\n}\n}\nreturn heap;\n}\n
    top_k.cpp
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\npriority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k) {\npriority_queue<int, vector<int>, greater<int>> heap;\n// \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\nfor (int i = 0; i < k; i++) {\nheap.push(nums[i]);\n}\n// \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\nfor (int i = k; i < nums.size(); i++) {\n// \u82e5\u5f53\u524d\u5143\u7d20\u5927\u4e8e\u5806\u9876\u5143\u7d20\uff0c\u5219\u5c06\u5806\u9876\u5143\u7d20\u51fa\u5806\u3001\u5f53\u524d\u5143\u7d20\u5165\u5806\nif (nums[i] > heap.top()) {\nheap.pop();\nheap.push(nums[i]);\n}\n}\nreturn heap;\n}\n
    top_k.py
    def top_k_heap(nums: list[int], k: int) -> list[int]:\n\"\"\"\u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20\"\"\"\nheap = []\n# \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\nfor i in range(k):\nheapq.heappush(heap, nums[i])\n# \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\nfor i in range(k, len(nums)):\n# \u82e5\u5f53\u524d\u5143\u7d20\u5927\u4e8e\u5806\u9876\u5143\u7d20\uff0c\u5219\u5c06\u5806\u9876\u5143\u7d20\u51fa\u5806\u3001\u5f53\u524d\u5143\u7d20\u5165\u5806\nif nums[i] > heap[0]:\nheapq.heappop(heap)\nheapq.heappush(heap, nums[i])\nreturn heap\n
    top_k.go
    [class]{maxHeap}-[func]{topKHeap}\n
    top_k.js
    [class]{}-[func]{topKHeap}\n
    top_k.ts
    [class]{}-[func]{topKHeap}\n
    top_k.c
    [class]{maxHeap}-[func]{topKHeap}\n
    top_k.cs
    [class]{top_k}-[func]{topKHeap}\n
    top_k.swift
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfunc topKHeap(nums: [Int], k: Int) -> [Int] {\n// \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\nvar heap = Array(nums.prefix(k))\n// \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\nfor i in stride(from: k, to: nums.count, by: 1) {\n// \u82e5\u5f53\u524d\u5143\u7d20\u5927\u4e8e\u5806\u9876\u5143\u7d20\uff0c\u5219\u5c06\u5806\u9876\u5143\u7d20\u51fa\u5806\u3001\u5f53\u524d\u5143\u7d20\u5165\u5806\nif nums[i] > heap.first! {\nheap.removeFirst()\nheap.insert(nums[i], at: 0)\n}\n}\nreturn heap\n}\n
    top_k.zig
    [class]{}-[func]{topKHeap}\n
    top_k.dart
    [class]{}-[func]{top_k_heap}\n
    "},{"location":"chapter_introduction/","title":"1. \u00a0 \u521d\u8bc6\u7b97\u6cd5","text":""},{"location":"chapter_introduction/algorithms_are_everywhere/","title":"1.1. \u00a0 \u7b97\u6cd5\u65e0\u5904\u4e0d\u5728","text":"

    \u5f53\u6211\u4eec\u542c\u5230\u201c\u7b97\u6cd5\u201d\u8fd9\u4e2a\u8bcd\u65f6\uff0c\u5f88\u81ea\u7136\u5730\u4f1a\u60f3\u5230\u6570\u5b66\u3002\u7136\u800c\u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u7b97\u6cd5\u5e76\u4e0d\u6d89\u53ca\u590d\u6742\u6570\u5b66\uff0c\u800c\u662f\u66f4\u591a\u5730\u4f9d\u8d56\u4e8e\u57fa\u672c\u903b\u8f91\uff0c\u8fd9\u4e9b\u903b\u8f91\u5728\u6211\u4eec\u7684\u65e5\u5e38\u751f\u6d3b\u4e2d\u5904\u5904\u53ef\u89c1\u3002

    \u5728\u6b63\u5f0f\u63a2\u8ba8\u7b97\u6cd5\u4e4b\u524d\uff0c\u6709\u4e00\u4e2a\u6709\u8da3\u7684\u4e8b\u5b9e\u503c\u5f97\u5206\u4eab\uff1a\u4f60\u5df2\u7ecf\u5728\u4e0d\u77e5\u4e0d\u89c9\u4e2d\u5b66\u4f1a\u4e86\u8bb8\u591a\u7b97\u6cd5\uff0c\u5e76\u4e60\u60ef\u5c06\u5b83\u4eec\u5e94\u7528\u5230\u65e5\u5e38\u751f\u6d3b\u4e2d\u4e86\u3002\u4e0b\u9762\uff0c\u6211\u5c06\u4e3e\u51e0\u4e2a\u5177\u4f53\u4f8b\u5b50\u6765\u8bc1\u5b9e\u8fd9\u4e00\u70b9\u3002

    \u4f8b\u4e00\uff1a\u62fc\u88c5\u79ef\u6728\u3002\u4e00\u5957\u79ef\u6728\uff0c\u9664\u4e86\u5305\u542b\u8bb8\u591a\u96f6\u4ef6\u4e4b\u5916\uff0c\u8fd8\u9644\u6709\u8be6\u7ec6\u7684\u7ec4\u88c5\u8bf4\u660e\u4e66\u3002\u6211\u4eec\u6309\u7167\u8bf4\u660e\u4e66\u4e00\u6b65\u6b65\u64cd\u4f5c\uff0c\u5c31\u80fd\u7ec4\u88c5\u51fa\u7cbe\u7f8e\u7684\u79ef\u6728\u6a21\u578b\u3002

    \u4ece\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u89d2\u5ea6\u6765\u770b\uff0c\u79ef\u6728\u7684\u5404\u79cd\u5f62\u72b6\u548c\u8fde\u63a5\u65b9\u5f0f\u4ee3\u8868\u6570\u636e\u7ed3\u6784\uff0c\u800c\u7ec4\u88c5\u8bf4\u660e\u4e66\u4e0a\u7684\u4e00\u7cfb\u5217\u6b65\u9aa4\u5219\u662f\u7b97\u6cd5\u3002

    Fig. \u62fc\u88c5\u79ef\u6728

    \u4f8b\u4e8c\uff1a\u67e5\u9605\u5b57\u5178\u3002\u5728\u5b57\u5178\u91cc\uff0c\u6bcf\u4e2a\u6c49\u5b57\u90fd\u5bf9\u5e94\u4e00\u4e2a\u62fc\u97f3\uff0c\u800c\u5b57\u5178\u662f\u6309\u7167\u62fc\u97f3\u7684\u82f1\u6587\u5b57\u6bcd\u987a\u5e8f\u6392\u5217\u7684\u3002\u5047\u8bbe\u6211\u4eec\u9700\u8981\u67e5\u627e\u4e00\u4e2a\u62fc\u97f3\u9996\u5b57\u6bcd\u4e3a \\(r\\) \u7684\u5b57\uff0c\u901a\u5e38\u4f1a\u8fd9\u6837\u64cd\u4f5c\uff1a

    1. \u7ffb\u5f00\u5b57\u5178\u7ea6\u4e00\u534a\u7684\u9875\u6570\uff0c\u67e5\u770b\u8be5\u9875\u9996\u5b57\u6bcd\u662f\u4ec0\u4e48\uff08\u5047\u8bbe\u4e3a \\(m\\) \uff09\uff1b
    2. \u7531\u4e8e\u5728\u82f1\u6587\u5b57\u6bcd\u8868\u4e2d \\(r\\) \u4f4d\u4e8e \\(m\\) \u4e4b\u540e\uff0c\u6240\u4ee5\u6392\u9664\u5b57\u5178\u524d\u534a\u90e8\u5206\uff0c\u67e5\u627e\u8303\u56f4\u7f29\u5c0f\u5230\u540e\u534a\u90e8\u5206\uff1b
    3. \u4e0d\u65ad\u91cd\u590d\u6b65\u9aa4 1-2 \uff0c\u76f4\u81f3\u627e\u5230\u62fc\u97f3\u9996\u5b57\u6bcd\u4e3a \\(r\\) \u7684\u9875\u7801\u4e3a\u6b62\u3002
    <1><2><3><4><5>

    \u67e5\u9605\u5b57\u5178\u8fd9\u4e2a\u5c0f\u5b66\u751f\u5fc5\u5907\u6280\u80fd\uff0c\u5b9e\u9645\u4e0a\u5c31\u662f\u8457\u540d\u7684\u300c\u4e8c\u5206\u67e5\u627e\u300d\u3002\u4ece\u6570\u636e\u7ed3\u6784\u7684\u89d2\u5ea6\uff0c\u6211\u4eec\u53ef\u4ee5\u628a\u5b57\u5178\u89c6\u4e3a\u4e00\u4e2a\u5df2\u6392\u5e8f\u7684\u300c\u6570\u7ec4\u300d\uff1b\u4ece\u7b97\u6cd5\u7684\u89d2\u5ea6\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u4e0a\u8ff0\u67e5\u5b57\u5178\u7684\u4e00\u7cfb\u5217\u64cd\u4f5c\u770b\u4f5c\u662f\u300c\u4e8c\u5206\u67e5\u627e\u300d\u7b97\u6cd5\u3002

    \u4f8b\u4e09\uff1a\u8d27\u5e01\u627e\u96f6\u3002\u5047\u8bbe\u6211\u4eec\u5728\u8d85\u5e02\u8d2d\u4e70\u4e86 \\(69\\) \u5143\u7684\u5546\u54c1\uff0c\u7ed9\u6536\u94f6\u5458\u4ed8\u4e86 \\(100\\) \u5143\uff0c\u5219\u6536\u94f6\u5458\u9700\u8981\u7ed9\u6211\u4eec\u627e \\(31\\) \u5143\u3002\u4ed6\u4f1a\u5f88\u81ea\u7136\u5730\u5b8c\u6210\u4ee5\u4e0b\u601d\u8003\uff1a

    1. \u53ef\u9009\u9879\u662f\u6bd4 \\(31\\) \u5143\u9762\u503c\u66f4\u5c0f\u7684\u8d27\u5e01\uff0c\u5305\u62ec \\(1\\) , \\(5\\) , \\(10\\) , \\(20\\) \u5143\u3002
    2. \u4ece\u53ef\u9009\u9879\u4e2d\u62ff\u51fa\u6700\u5927\u7684 \\(20\\) \u5143\uff0c\u5269\u4f59 \\(31 - 20 = 11\\) \u5143\u3002
    3. \u4ece\u5269\u4f59\u53ef\u9009\u9879\u4e2d\u62ff\u51fa\u6700\u5927\u7684 \\(10\\) \u5143\uff0c\u5269\u4f59 \\(11 - 10 = 1\\) \u5143\u3002
    4. \u4ece\u5269\u4f59\u53ef\u9009\u9879\u4e2d\u62ff\u51fa\u6700\u5927\u7684 \\(1\\) \u5143\uff0c\u5269\u4f59 \\(1 - 1 = 0\\) \u5143\u3002
    5. \u5b8c\u6210\u627e\u96f6\uff0c\u65b9\u6848\u4e3a \\(20 + 10 + 1 = 31\\) \u5143\u3002

    \u5728\u4ee5\u4e0a\u6b65\u9aa4\u4e2d\uff0c\u6211\u4eec\u6bcf\u4e00\u6b65\u90fd\u91c7\u53d6\u5f53\u524d\u770b\u6765\u6700\u597d\u7684\u9009\u62e9\uff08\u5c3d\u53ef\u80fd\u7528\u5927\u9762\u989d\u7684\u8d27\u5e01\uff09\uff0c\u6700\u7ec8\u5f97\u5230\u4e86\u53ef\u884c\u7684\u627e\u96f6\u65b9\u6848\u3002\u4ece\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u89d2\u5ea6\u770b\uff0c\u8fd9\u79cd\u65b9\u6cd5\u672c\u8d28\u4e0a\u662f\u300c\u8d2a\u5fc3\u7b97\u6cd5\u300d\u3002

    Fig. \u8d27\u5e01\u627e\u96f6

    \u5c0f\u5230\u70f9\u996a\u4e00\u9053\u83dc\uff0c\u5927\u5230\u661f\u9645\u822a\u884c\uff0c\u51e0\u4e4e\u6240\u6709\u95ee\u9898\u7684\u89e3\u51b3\u90fd\u79bb\u4e0d\u5f00\u7b97\u6cd5\u3002\u8ba1\u7b97\u673a\u7684\u51fa\u73b0\u4f7f\u6211\u4eec\u80fd\u591f\u901a\u8fc7\u7f16\u7a0b\u5c06\u6570\u636e\u7ed3\u6784\u5b58\u50a8\u5728\u5185\u5b58\u4e2d\uff0c\u540c\u65f6\u7f16\u5199\u4ee3\u7801\u8c03\u7528 CPU \u548c GPU \u6267\u884c\u7b97\u6cd5\u3002\u8fd9\u6837\u4e00\u6765\uff0c\u6211\u4eec\u5c31\u80fd\u628a\u751f\u6d3b\u4e2d\u7684\u95ee\u9898\u8f6c\u79fb\u5230\u8ba1\u7b97\u673a\u4e0a\uff0c\u4ee5\u66f4\u9ad8\u6548\u7684\u65b9\u5f0f\u89e3\u51b3\u5404\u79cd\u590d\u6742\u95ee\u9898\u3002

    Tip

    \u9605\u8bfb\u81f3\u6b64\uff0c\u5982\u679c\u4f60\u5bf9\u6570\u636e\u7ed3\u6784\u3001\u7b97\u6cd5\u3001\u6570\u7ec4\u548c\u4e8c\u5206\u67e5\u627e\u7b49\u6982\u5ff5\u4ecd\u611f\u5230\u4e00\u77e5\u534a\u89e3\uff0c\u90a3\u4e48\u592a\u597d\u4e86\uff01\u56e0\u4e3a\u8fd9\u6b63\u662f\u672c\u4e66\u5b58\u5728\u7684\u610f\u4e49\u3002\u63a5\u4e0b\u6765\uff0c\u8fd9\u672c\u4e66\u5c06\u4e00\u6b65\u6b65\u5f15\u5bfc\u4f60\u6df1\u5165\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u77e5\u8bc6\u6bbf\u5802\u3002

    "},{"location":"chapter_introduction/summary/","title":"1.3. \u00a0 \u5c0f\u7ed3","text":"
    • \u7b97\u6cd5\u5728\u65e5\u5e38\u751f\u6d3b\u4e2d\u65e0\u5904\u4e0d\u5728\uff0c\u5e76\u4e0d\u662f\u9065\u4e0d\u53ef\u53ca\u7684\u9ad8\u6df1\u77e5\u8bc6\u3002\u5b9e\u9645\u4e0a\uff0c\u6211\u4eec\u5df2\u7ecf\u5728\u4e0d\u77e5\u4e0d\u89c9\u4e2d\u5b66\u4f1a\u4e86\u8bb8\u591a\u7b97\u6cd5\uff0c\u7528\u4ee5\u89e3\u51b3\u751f\u6d3b\u4e2d\u7684\u5927\u5c0f\u95ee\u9898\u3002
    • \u67e5\u9605\u5b57\u5178\u7684\u539f\u7406\u4e0e\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u76f8\u4e00\u81f4\u3002\u4e8c\u5206\u67e5\u627e\u4f53\u73b0\u4e86\u5206\u800c\u6cbb\u4e4b\u7684\u91cd\u8981\u7b97\u6cd5\u601d\u60f3\u3002
    • \u7b97\u6cd5\u662f\u5728\u6709\u9650\u65f6\u95f4\u5185\u89e3\u51b3\u7279\u5b9a\u95ee\u9898\u7684\u4e00\u7ec4\u6307\u4ee4\u6216\u64cd\u4f5c\u6b65\u9aa4\uff0c\u800c\u6570\u636e\u7ed3\u6784\u662f\u8ba1\u7b97\u673a\u4e2d\u7ec4\u7ec7\u548c\u5b58\u50a8\u6570\u636e\u7684\u65b9\u5f0f\u3002
    • \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7d27\u5bc6\u76f8\u8fde\u3002\u6570\u636e\u7ed3\u6784\u662f\u7b97\u6cd5\u7684\u57fa\u77f3\uff0c\u800c\u7b97\u6cd5\u5219\u662f\u53d1\u6325\u6570\u636e\u7ed3\u6784\u4f5c\u7528\u7684\u821e\u53f0\u3002
    • \u4e50\u9ad8\u79ef\u6728\u5bf9\u5e94\u4e8e\u6570\u636e\uff0c\u79ef\u6728\u5f62\u72b6\u548c\u8fde\u63a5\u65b9\u5f0f\u4ee3\u8868\u6570\u636e\u7ed3\u6784\uff0c\u62fc\u88c5\u79ef\u6728\u7684\u6b65\u9aa4\u5219\u5bf9\u5e94\u7b97\u6cd5\u3002
    "},{"location":"chapter_introduction/what_is_dsa/","title":"1.2. \u00a0 \u7b97\u6cd5\u662f\u4ec0\u4e48","text":""},{"location":"chapter_introduction/what_is_dsa/#121","title":"1.2.1. \u00a0 \u7b97\u6cd5\u5b9a\u4e49","text":"

    \u300c\u7b97\u6cd5 Algorithm\u300d\u662f\u5728\u6709\u9650\u65f6\u95f4\u5185\u89e3\u51b3\u7279\u5b9a\u95ee\u9898\u7684\u4e00\u7ec4\u6307\u4ee4\u6216\u64cd\u4f5c\u6b65\u9aa4\u3002\u7b97\u6cd5\u5177\u6709\u4ee5\u4e0b\u7279\u6027\uff1a

    • \u95ee\u9898\u662f\u660e\u786e\u7684\uff0c\u5305\u542b\u6e05\u6670\u7684\u8f93\u5165\u548c\u8f93\u51fa\u5b9a\u4e49\u3002
    • \u5177\u6709\u53ef\u884c\u6027\uff0c\u80fd\u591f\u5728\u6709\u9650\u6b65\u9aa4\u3001\u65f6\u95f4\u548c\u5185\u5b58\u7a7a\u95f4\u4e0b\u5b8c\u6210\u3002
    • \u5404\u6b65\u9aa4\u90fd\u6709\u786e\u5b9a\u7684\u542b\u4e49\uff0c\u76f8\u540c\u7684\u8f93\u5165\u548c\u8fd0\u884c\u6761\u4ef6\u4e0b\uff0c\u8f93\u51fa\u59cb\u7ec8\u76f8\u540c\u3002
    "},{"location":"chapter_introduction/what_is_dsa/#122","title":"1.2.2. \u00a0 \u6570\u636e\u7ed3\u6784\u5b9a\u4e49","text":"

    \u300c\u6570\u636e\u7ed3\u6784 Data Structure\u300d\u662f\u8ba1\u7b97\u673a\u4e2d\u7ec4\u7ec7\u548c\u5b58\u50a8\u6570\u636e\u7684\u65b9\u5f0f\u3002\u4e3a\u4e86\u63d0\u9ad8\u6570\u636e\u5b58\u50a8\u548c\u64cd\u4f5c\u6027\u80fd\uff0c\u6570\u636e\u7ed3\u6784\u7684\u8bbe\u8ba1\u76ee\u6807\u5305\u62ec\uff1a

    • \u7a7a\u95f4\u5360\u7528\u5c3d\u91cf\u51cf\u5c11\uff0c\u8282\u7701\u8ba1\u7b97\u673a\u5185\u5b58\u3002
    • \u6570\u636e\u64cd\u4f5c\u5c3d\u53ef\u80fd\u5feb\u901f\uff0c\u6db5\u76d6\u6570\u636e\u8bbf\u95ee\u3001\u6dfb\u52a0\u3001\u5220\u9664\u3001\u66f4\u65b0\u7b49\u3002
    • \u63d0\u4f9b\u7b80\u6d01\u7684\u6570\u636e\u8868\u793a\u548c\u903b\u8f91\u4fe1\u606f\uff0c\u4ee5\u4fbf\u4f7f\u5f97\u7b97\u6cd5\u9ad8\u6548\u8fd0\u884c\u3002

    \u6570\u636e\u7ed3\u6784\u8bbe\u8ba1\u662f\u4e00\u4e2a\u5145\u6ee1\u6743\u8861\u7684\u8fc7\u7a0b\uff0c\u8fd9\u610f\u5473\u7740\u8981\u5728\u67d0\u65b9\u9762\u53d6\u5f97\u4f18\u52bf\uff0c\u5f80\u5f80\u9700\u8981\u5728\u53e6\u4e00\u65b9\u9762\u4f5c\u51fa\u59a5\u534f\u3002\u4f8b\u5982\uff0c\u94fe\u8868\u76f8\u8f83\u4e8e\u6570\u7ec4\uff0c\u5728\u6570\u636e\u6dfb\u52a0\u548c\u5220\u9664\u64cd\u4f5c\u4e0a\u66f4\u52a0\u4fbf\u6377\uff0c\u4f46\u727a\u7272\u4e86\u6570\u636e\u8bbf\u95ee\u901f\u5ea6\uff1b\u56fe\u76f8\u8f83\u4e8e\u94fe\u8868\uff0c\u63d0\u4f9b\u4e86\u66f4\u4e30\u5bcc\u7684\u903b\u8f91\u4fe1\u606f\uff0c\u4f46\u9700\u8981\u5360\u7528\u66f4\u5927\u7684\u5185\u5b58\u7a7a\u95f4\u3002

    "},{"location":"chapter_introduction/what_is_dsa/#123","title":"1.2.3. \u00a0 \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u5173\u7cfb","text":"

    \u300c\u6570\u636e\u7ed3\u6784\u300d\u4e0e\u300c\u7b97\u6cd5\u300d\u9ad8\u5ea6\u76f8\u5173\u4e14\u7d27\u5bc6\u7ed3\u5408\uff0c\u5177\u4f53\u8868\u73b0\u5728\uff1a

    • \u6570\u636e\u7ed3\u6784\u662f\u7b97\u6cd5\u7684\u57fa\u77f3\u3002\u6570\u636e\u7ed3\u6784\u4e3a\u7b97\u6cd5\u63d0\u4f9b\u4e86\u7ed3\u6784\u5316\u5b58\u50a8\u7684\u6570\u636e\uff0c\u4ee5\u53ca\u7528\u4e8e\u64cd\u4f5c\u6570\u636e\u7684\u65b9\u6cd5\u3002
    • \u7b97\u6cd5\u662f\u6570\u636e\u7ed3\u6784\u53d1\u6325\u7684\u821e\u53f0\u3002\u6570\u636e\u7ed3\u6784\u672c\u8eab\u4ec5\u5b58\u50a8\u6570\u636e\u4fe1\u606f\uff0c\u901a\u8fc7\u7ed3\u5408\u7b97\u6cd5\u624d\u80fd\u89e3\u51b3\u7279\u5b9a\u95ee\u9898\u3002
    • \u7279\u5b9a\u7b97\u6cd5\u901a\u5e38\u6709\u5bf9\u5e94\u6700\u4f18\u7684\u6570\u636e\u7ed3\u6784\u3002\u7b97\u6cd5\u901a\u5e38\u53ef\u4ee5\u57fa\u4e8e\u4e0d\u540c\u7684\u6570\u636e\u7ed3\u6784\u8fdb\u884c\u5b9e\u73b0\uff0c\u4f46\u6700\u7ec8\u6267\u884c\u6548\u7387\u53ef\u80fd\u76f8\u5dee\u5f88\u5927\u3002

    Fig. \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u5173\u7cfb

    \u7c7b\u6bd4\u300cLEGO \u4e50\u9ad8\u300d\u548c\u300c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u300d\uff0c\u5219\u5bf9\u5e94\u5173\u7cfb\u5982\u4e0b\u8868\u6240\u793a\u3002

    \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5 LEGO \u4e50\u9ad8 \u8f93\u5165\u6570\u636e \u672a\u62fc\u88c5\u7684\u79ef\u6728 \u6570\u636e\u7ed3\u6784 \u79ef\u6728\u7ec4\u7ec7\u5f62\u5f0f\uff0c\u5305\u62ec\u5f62\u72b6\u3001\u5927\u5c0f\u3001\u8fde\u63a5\u65b9\u5f0f\u7b49 \u7b97\u6cd5 \u628a\u79ef\u6728\u62fc\u6210\u76ee\u6807\u5f62\u6001\u7684\u4e00\u7cfb\u5217\u64cd\u4f5c\u6b65\u9aa4 \u8f93\u51fa\u6570\u636e \u79ef\u6728\u6a21\u578b

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u72ec\u7acb\u4e8e\u7f16\u7a0b\u8bed\u8a00\u3002\u6b63\u56e0\u5982\u6b64\uff0c\u672c\u4e66\u5f97\u4ee5\u63d0\u4f9b\u591a\u79cd\u7f16\u7a0b\u8bed\u8a00\u7684\u5b9e\u73b0\u3002

    \u7ea6\u5b9a\u4fd7\u6210\u7684\u7b80\u79f0

    \u5728\u5b9e\u9645\u8ba8\u8bba\u65f6\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u5c06\u300c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u300d\u7b80\u79f0\u4e3a\u300c\u7b97\u6cd5\u300d\u3002\u4f8b\u5982\uff0c\u4f17\u6240\u5468\u77e5\u7684 LeetCode \u7b97\u6cd5\u9898\u76ee\uff0c\u5b9e\u9645\u4e0a\u540c\u65f6\u8003\u5bdf\u4e86\u6570\u636e\u7ed3\u6784\u548c\u7b97\u6cd5\u4e24\u65b9\u9762\u7684\u77e5\u8bc6\u3002

    "},{"location":"chapter_preface/","title":"0. \u00a0 \u524d\u8a00","text":""},{"location":"chapter_preface/about_the_book/","title":"0.1. \u00a0 \u5173\u4e8e\u672c\u4e66","text":"

    \u672c\u9879\u76ee\u65e8\u5728\u521b\u5efa\u4e00\u672c\u5f00\u6e90\u514d\u8d39\u3001\u65b0\u624b\u53cb\u597d\u7684\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u5165\u95e8\u6559\u7a0b\u3002

    • \u5168\u4e66\u91c7\u7528\u52a8\u753b\u56fe\u89e3\uff0c\u7ed3\u6784\u5316\u5730\u8bb2\u89e3\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u77e5\u8bc6\uff0c\u5185\u5bb9\u6e05\u6670\u6613\u61c2\u3001\u5b66\u4e60\u66f2\u7ebf\u5e73\u6ed1\uff1b
    • \u7b97\u6cd5\u6e90\u4ee3\u7801\u7686\u53ef\u4e00\u952e\u8fd0\u884c\uff0c\u652f\u6301 Java, C++, Python, Go, JS, TS, C#, Swift, Zig \u7b49\u8bed\u8a00\uff1b
    • \u9f13\u52b1\u8bfb\u8005\u5728\u7ae0\u8282\u8ba8\u8bba\u533a\u4e92\u5e2e\u4e92\u52a9\u3001\u5171\u540c\u8fdb\u6b65\uff0c\u63d0\u95ee\u4e0e\u8bc4\u8bba\u901a\u5e38\u53ef\u5728\u4e24\u65e5\u5185\u5f97\u5230\u56de\u590d\uff1b
    "},{"location":"chapter_preface/about_the_book/#011","title":"0.1.1. \u00a0 \u8bfb\u8005\u5bf9\u8c61","text":"

    \u82e5\u60a8\u662f\u300c\u7b97\u6cd5\u521d\u5b66\u8005\u300d\uff0c\u4ece\u672a\u63a5\u89e6\u8fc7\u7b97\u6cd5\uff0c\u6216\u8005\u5df2\u7ecf\u6709\u4e00\u4e9b\u5237\u9898\u7ecf\u9a8c\uff0c\u5bf9\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u6709\u6a21\u7cca\u7684\u8ba4\u8bc6\uff0c\u5728\u4f1a\u4e0e\u4e0d\u4f1a\u4e4b\u95f4\u53cd\u590d\u6a2a\u8df3\uff0c\u90a3\u4e48\u8fd9\u672c\u4e66\u6b63\u662f\u4e3a\u60a8\u91cf\u8eab\u5b9a\u5236\uff01

    \u5982\u679c\u60a8\u662f\u300c\u7b97\u6cd5\u8001\u624b\u300d\uff0c\u5df2\u7ecf\u79ef\u7d2f\u4e00\u5b9a\u5237\u9898\u91cf\uff0c\u719f\u6089\u5927\u90e8\u5206\u9898\u578b\uff0c\u90a3\u4e48\u672c\u4e66\u53ef\u52a9\u60a8\u56de\u987e\u4e0e\u68b3\u7406\u7b97\u6cd5\u77e5\u8bc6\u4f53\u7cfb\uff0c\u4ed3\u5e93\u6e90\u4ee3\u7801\u53ef\u4ee5\u88ab\u5f53\u4f5c\u201c\u5237\u9898\u5de5\u5177\u5e93\u201d\u6216\u201c\u7b97\u6cd5\u5b57\u5178\u201d\u6765\u4f7f\u7528\u3002

    \u82e5\u60a8\u662f\u300c\u7b97\u6cd5\u5927\u795e\u300d\uff0c\u6211\u4eec\u671f\u5f85\u6536\u5230\u60a8\u7684\u5b9d\u8d35\u5efa\u8bae\uff0c\u6216\u8005\u4e00\u8d77\u53c2\u4e0e\u521b\u4f5c\u3002

    \u524d\u7f6e\u6761\u4ef6

    \u60a8\u9700\u8981\u81f3\u5c11\u5177\u5907\u4efb\u4e00\u8bed\u8a00\u7684\u7f16\u7a0b\u57fa\u7840\uff0c\u80fd\u591f\u9605\u8bfb\u548c\u7f16\u5199\u7b80\u5355\u4ee3\u7801\u3002

    "},{"location":"chapter_preface/about_the_book/#012","title":"0.1.2. \u00a0 \u5185\u5bb9\u7ed3\u6784","text":"

    \u672c\u4e66\u4e3b\u8981\u5185\u5bb9\u5305\u62ec\uff1a

    • \u590d\u6742\u5ea6\u5206\u6790\uff1a\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u8bc4\u4ef7\u7ef4\u5ea6\u3001\u7b97\u6cd5\u6548\u7387\u7684\u8bc4\u4f30\u65b9\u6cd5\u3002\u65f6\u95f4\u590d\u6742\u5ea6\u3001\u7a7a\u95f4\u590d\u6742\u5ea6\uff0c\u5305\u62ec\u63a8\u7b97\u65b9\u6cd5\u3001\u5e38\u89c1\u7c7b\u578b\u3001\u793a\u4f8b\u7b49\u3002
    • \u6570\u636e\u7ed3\u6784\uff1a\u5e38\u89c1\u57fa\u672c\u6570\u636e\u7c7b\u578b\uff0c\u6570\u636e\u5728\u5185\u5b58\u4e2d\u7684\u5b58\u50a8\u5f62\u5f0f\u3001\u6570\u636e\u7ed3\u6784\u7684\u5206\u7c7b\u65b9\u6cd5\u3002\u6d89\u53ca\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\u3001\u6563\u5217\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\u7b49\u6570\u636e\u7ed3\u6784\uff0c\u5185\u5bb9\u5305\u62ec\u5b9a\u4e49\u3001\u4f18\u7f3a\u70b9\u3001\u5e38\u7528\u64cd\u4f5c\u3001\u5e38\u89c1\u7c7b\u578b\u3001\u5178\u578b\u5e94\u7528\u3001\u5b9e\u73b0\u65b9\u6cd5\u7b49\u3002
    • \u7b97\u6cd5\uff1a\u67e5\u627e\u7b97\u6cd5\u3001\u6392\u5e8f\u7b97\u6cd5\u3001\u641c\u7d22\u4e0e\u56de\u6eaf\u3001\u52a8\u6001\u89c4\u5212\u3001\u5206\u6cbb\u7b97\u6cd5\u7b49\uff0c\u5185\u5bb9\u6db5\u76d6\u5b9a\u4e49\u3001\u5e94\u7528\u573a\u666f\u3001\u4f18\u7f3a\u70b9\u3001\u65f6\u7a7a\u6548\u7387\u3001\u5b9e\u73b0\u65b9\u6cd5\u3001\u793a\u4f8b\u9898\u76ee\u7b49\u3002

    Fig. Hello \u7b97\u6cd5\u5185\u5bb9\u7ed3\u6784

    "},{"location":"chapter_preface/about_the_book/#013","title":"0.1.3. \u00a0 \u81f4\u8c22","text":"

    \u5728\u672c\u4e66\u7684\u521b\u4f5c\u8fc7\u7a0b\u4e2d\uff0c\u6211\u5f97\u5230\u4e86\u8bb8\u591a\u4eba\u7684\u5e2e\u52a9\uff0c\u5305\u62ec\u4f46\u4e0d\u9650\u4e8e\uff1a

    • \u611f\u8c22\u6211\u5728\u516c\u53f8\u7684\u5bfc\u5e08\u674e\u6c50\u535a\u58eb\uff0c\u5728\u4e00\u6b21\u7545\u8c08\u4e2d\u60a8\u9f13\u52b1\u6211\u201c\u884c\u52a8\u8d77\u6765\u201d\uff0c\u575a\u5b9a\u4e86\u6211\u5199\u8fd9\u672c\u4e66\u7684\u51b3\u5fc3\u3002
    • \u611f\u8c22\u6211\u7684\u5973\u670b\u53cb\u6ce1\u6ce1\u4f5c\u4e3a\u672c\u4e66\u7684\u9996\u4f4d\u8bfb\u8005\uff0c\u4ece\u7b97\u6cd5\u5c0f\u767d\u7684\u89d2\u5ea6\u63d0\u51fa\u8bb8\u591a\u5b9d\u8d35\u5efa\u8bae\uff0c\u4f7f\u5f97\u672c\u4e66\u66f4\u9002\u5408\u65b0\u624b\u9605\u8bfb\u3002
    • \u611f\u8c22\u817e\u5b9d\u3001\u7426\u5b9d\u3001\u98de\u5b9d\u4e3a\u672c\u4e66\u8d77\u4e86\u4e00\u4e2a\u5bcc\u6709\u521b\u610f\u7684\u540d\u5b57\uff0c\u5524\u8d77\u5927\u5bb6\u5199\u4e0b\u7b2c\u4e00\u884c\u4ee3\u7801 \"Hello World!\" \u7684\u7f8e\u597d\u56de\u5fc6\u3002
    • \u611f\u8c22\u82cf\u6f7c\u4e3a\u672c\u4e66\u8bbe\u8ba1\u4e86\u7cbe\u7f8e\u7684\u5c01\u9762\u548c LOGO\uff0c\u5e76\u5728\u6211\u7684\u5f3a\u8feb\u75c7\u4e0b\u591a\u6b21\u8010\u5fc3\u4fee\u6539\u3002
    • \u611f\u8c22 @squidfunk \u63d0\u4f9b\u7684\u5199\u4f5c\u6392\u7248\u5efa\u8bae\uff0c\u4ee5\u53ca\u6770\u51fa\u7684\u5f00\u6e90\u9879\u76ee Material-for-MkDocs \u3002

    \u5728\u5199\u4f5c\u8fc7\u7a0b\u4e2d\uff0c\u6211\u9605\u8bfb\u4e86\u8bb8\u591a\u5173\u4e8e\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u6559\u6750\u548c\u6587\u7ae0\u3002\u8fd9\u4e9b\u4f5c\u54c1\u4e3a\u672c\u4e66\u63d0\u4f9b\u4e86\u4f18\u79c0\u7684\u8303\u672c\uff0c\u786e\u4fdd\u4e86\u672c\u4e66\u5185\u5bb9\u7684\u51c6\u786e\u6027\u4e0e\u54c1\u8d28\u3002\u5728\u6b64\u611f\u8c22\u6240\u6709\u8001\u5e08\u548c\u524d\u8f88\u4eec\u7684\u6770\u51fa\u8d21\u732e\uff01

    \u672c\u4e66\u5021\u5bfc\u624b\u8111\u5e76\u7528\u7684\u5b66\u4e60\u65b9\u5f0f\uff0c\u5728\u8fd9\u4e00\u70b9\u4e0a\u6df1\u53d7\u300a\u52a8\u624b\u5b66\u6df1\u5ea6\u5b66\u4e60\u300b\u7684\u542f\u53d1\u3002\u5728\u6b64\u5411\u5404\u4f4d\u8bfb\u8005\u5f3a\u70c8\u63a8\u8350\u8fd9\u672c\u4f18\u79c0\u8457\u4f5c\u3002

    \u8877\u5fc3\u611f\u8c22\u6211\u7684\u7236\u6bcd\uff0c\u6b63\u662f\u4f60\u4eec\u4e00\u76f4\u4ee5\u6765\u7684\u652f\u6301\u4e0e\u9f13\u52b1\uff0c\u8ba9\u6211\u6709\u673a\u4f1a\u505a\u8fd9\u4e9b\u5bcc\u6709\u8da3\u5473\u7684\u4e8b\u3002

    "},{"location":"chapter_preface/suggestions/","title":"0.2. \u00a0 \u5982\u4f55\u4f7f\u7528\u672c\u4e66","text":"

    Tip

    \u4e3a\u4e86\u83b7\u5f97\u6700\u4f73\u7684\u9605\u8bfb\u4f53\u9a8c\uff0c\u5efa\u8bae\u60a8\u901a\u8bfb\u672c\u8282\u5185\u5bb9\u3002

    "},{"location":"chapter_preface/suggestions/#021","title":"0.2.1. \u00a0 \u884c\u6587\u98ce\u683c\u7ea6\u5b9a","text":"
    • \u6807\u9898\u540e\u6807\u6ce8 * \u7684\u662f\u9009\u8bfb\u7ae0\u8282\uff0c\u5185\u5bb9\u76f8\u5bf9\u56f0\u96be\u3002\u5982\u679c\u4f60\u7684\u65f6\u95f4\u6709\u9650\uff0c\u5efa\u8bae\u53ef\u4ee5\u5148\u8df3\u8fc7\u3002
    • \u6587\u7ae0\u4e2d\u7684\u91cd\u8981\u540d\u8bcd\u4f1a\u7528 \u300c \u300d \u62ec\u53f7\u6807\u6ce8\uff0c\u4f8b\u5982 \u300c\u6570\u7ec4 Array\u300d \u3002\u8bf7\u52a1\u5fc5\u8bb0\u4f4f\u8fd9\u4e9b\u540d\u8bcd\uff0c\u5305\u62ec\u82f1\u6587\u7ffb\u8bd1\uff0c\u4ee5\u4fbf\u540e\u7eed\u9605\u8bfb\u6587\u732e\u65f6\u4f7f\u7528\u3002
    • \u52a0\u7c97\u7684\u6587\u5b57 \u8868\u793a\u91cd\u70b9\u5185\u5bb9\u6216\u603b\u7ed3\u6027\u8bed\u53e5\uff0c\u8fd9\u7c7b\u6587\u5b57\u503c\u5f97\u7279\u522b\u5173\u6ce8\u3002
    • \u4e13\u6709\u540d\u8bcd\u548c\u6709\u7279\u6307\u542b\u4e49\u7684\u8bcd\u53e5\u4f1a\u4f7f\u7528 \u201c\u53cc\u5f15\u53f7\u201d \u6807\u6ce8\uff0c\u4ee5\u907f\u514d\u6b67\u4e49\u3002
    • \u6d89\u53ca\u5230\u7f16\u7a0b\u8bed\u8a00\u4e4b\u95f4\u4e0d\u4e00\u81f4\u7684\u540d\u8bcd\uff0c\u672c\u4e66\u5747\u4ee5 Python \u4e3a\u51c6\uff0c\u4f8b\u5982\u4f7f\u7528 \\(\\text{None}\\) \u6765\u8868\u793a\u201c\u7a7a\u201d\u3002
    • \u672c\u4e66\u90e8\u5206\u653e\u5f03\u4e86\u7f16\u7a0b\u8bed\u8a00\u7684\u6ce8\u91ca\u89c4\u8303\uff0c\u4ee5\u6362\u53d6\u66f4\u52a0\u7d27\u51d1\u7684\u5185\u5bb9\u6392\u7248\u3002\u6ce8\u91ca\u4e3b\u8981\u5206\u4e3a\u4e09\u79cd\u7c7b\u578b\uff1a\u6807\u9898\u6ce8\u91ca\u3001\u5185\u5bb9\u6ce8\u91ca\u3001\u591a\u884c\u6ce8\u91ca\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    \"\"\"\u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49\"\"\"\n# \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\"\"\"\n\u591a\u884c\n\u6ce8\u91ca\n\"\"\"\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    // \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n// \u591a\u884c\n// \u6ce8\u91ca\n
    /* \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49 */\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    "},{"location":"chapter_preface/suggestions/#022","title":"0.2.2. \u00a0 \u5728\u52a8\u753b\u56fe\u89e3\u4e2d\u9ad8\u6548\u5b66\u4e60","text":"

    \u76f8\u8f83\u4e8e\u6587\u5b57\uff0c\u89c6\u9891\u548c\u56fe\u7247\u5177\u6709\u66f4\u9ad8\u7684\u4fe1\u606f\u5bc6\u5ea6\u548c\u7ed3\u6784\u5316\u7a0b\u5ea6\uff0c\u56e0\u6b64\u66f4\u6613\u4e8e\u7406\u89e3\u3002\u5728\u672c\u4e66\u4e2d\uff0c\u91cd\u70b9\u548c\u96be\u70b9\u77e5\u8bc6\u5c06\u4e3b\u8981\u901a\u8fc7\u52a8\u753b\u548c\u56fe\u89e3\u5f62\u5f0f\u5c55\u793a\uff0c\u800c\u6587\u5b57\u5219\u4f5c\u4e3a\u52a8\u753b\u548c\u56fe\u7247\u7684\u89e3\u91ca\u4e0e\u8865\u5145\u3002

    \u5728\u9605\u8bfb\u672c\u4e66\u65f6\uff0c\u5982\u679c\u53d1\u73b0\u67d0\u6bb5\u5185\u5bb9\u63d0\u4f9b\u4e86\u52a8\u753b\u6216\u56fe\u89e3\uff0c\u5efa\u8bae\u4ee5\u56fe\u4e3a\u4e3b\u7ebf\uff0c\u4ee5\u6587\u5b57\uff08\u901a\u5e38\u4f4d\u4e8e\u56fe\u50cf\u4e0a\u65b9\uff09\u4e3a\u8f85\uff0c\u7efc\u5408\u4e24\u8005\u6765\u7406\u89e3\u5185\u5bb9\u3002

    Fig. \u52a8\u753b\u56fe\u89e3\u793a\u4f8b

    "},{"location":"chapter_preface/suggestions/#023","title":"0.2.3. \u00a0 \u5728\u4ee3\u7801\u5b9e\u8df5\u4e2d\u52a0\u6df1\u7406\u89e3","text":"

    \u672c\u4e66\u7684\u914d\u5957\u4ee3\u7801\u6258\u7ba1\u5728GitHub \u4ed3\u5e93\uff0c\u6e90\u4ee3\u7801\u5305\u542b\u8be6\u7ec6\u6ce8\u91ca\uff0c\u5e76\u9644\u6709\u6d4b\u8bd5\u6837\u4f8b\uff0c\u53ef\u76f4\u63a5\u8fd0\u884c\u3002

    \u5982\u679c\u5b66\u4e60\u65f6\u95f4\u6709\u9650\uff0c\u5efa\u8bae\u4f60\u81f3\u5c11\u901a\u8bfb\u5e76\u8fd0\u884c\u6240\u6709\u4ee3\u7801\u3002\u5982\u679c\u65f6\u95f4\u5145\u88d5\uff0c\u5efa\u8bae\u53c2\u7167\u4ee3\u7801\u81ea\u884c\u6572\u4e00\u904d\u3002\u4e0e\u4ec5\u9605\u8bfb\u4ee3\u7801\u76f8\u6bd4\uff0c\u7f16\u5199\u4ee3\u7801\u7684\u8fc7\u7a0b\u5f80\u5f80\u80fd\u5e26\u6765\u66f4\u591a\u6536\u83b7\u3002

    Fig. \u8fd0\u884c\u4ee3\u7801\u793a\u4f8b

    \u7b2c\u4e00\u6b65\uff1a\u5b89\u88c5\u672c\u5730\u7f16\u7a0b\u73af\u5883\u3002\u8bf7\u53c2\u7167\u9644\u5f55\u6559\u7a0b\u8fdb\u884c\u5b89\u88c5\uff0c\u5982\u679c\u5df2\u5b89\u88c5\u5219\u53ef\u8df3\u8fc7\u6b64\u6b65\u9aa4\u3002

    \u7b2c\u4e8c\u6b65\uff1a\u4e0b\u8f7d\u4ee3\u7801\u4ed3\u3002\u5982\u679c\u5df2\u7ecf\u5b89\u88c5 Git \uff0c\u53ef\u4ee5\u901a\u8fc7\u4ee5\u4e0b\u547d\u4ee4\u514b\u9686\u672c\u4ed3\u5e93\u3002

    git clone https://github.com/krahets/hello-algo.git\n

    \u5f53\u7136\uff0c\u4f60\u4e5f\u53ef\u4ee5\u70b9\u51fb\u201cDownload ZIP\u201d\u76f4\u63a5\u4e0b\u8f7d\u4ee3\u7801\u538b\u7f29\u5305\uff0c\u7136\u540e\u5728\u672c\u5730\u89e3\u538b\u5373\u53ef\u3002

    Fig. \u514b\u9686\u4ed3\u5e93\u4e0e\u4e0b\u8f7d\u4ee3\u7801

    \u7b2c\u4e09\u6b65\uff1a\u8fd0\u884c\u6e90\u4ee3\u7801\u3002\u5982\u679c\u4ee3\u7801\u5757\u9876\u90e8\u6807\u6709\u6587\u4ef6\u540d\u79f0\uff0c\u5219\u53ef\u4ee5\u5728\u4ed3\u5e93\u7684 codes \u6587\u4ef6\u5939\u4e2d\u627e\u5230\u76f8\u5e94\u7684\u6e90\u4ee3\u7801\u6587\u4ef6\u3002\u6e90\u4ee3\u7801\u6587\u4ef6\u5c06\u5e2e\u52a9\u4f60\u8282\u7701\u4e0d\u5fc5\u8981\u7684\u8c03\u8bd5\u65f6\u95f4\uff0c\u8ba9\u4f60\u80fd\u591f\u4e13\u6ce8\u4e8e\u5b66\u4e60\u5185\u5bb9\u3002

    Fig. \u4ee3\u7801\u5757\u4e0e\u5bf9\u5e94\u7684\u6e90\u4ee3\u7801\u6587\u4ef6

    "},{"location":"chapter_preface/suggestions/#024","title":"0.2.4. \u00a0 \u5728\u63d0\u95ee\u8ba8\u8bba\u4e2d\u5171\u540c\u6210\u957f","text":"

    \u9605\u8bfb\u672c\u4e66\u65f6\uff0c\u8bf7\u4e0d\u8981\u201c\u60ef\u7740\u201d\u90a3\u4e9b\u6ca1\u5b66\u660e\u767d\u7684\u77e5\u8bc6\u70b9\u3002\u6b22\u8fce\u5728\u8bc4\u8bba\u533a\u63d0\u51fa\u4f60\u7684\u95ee\u9898\uff0c\u6211\u548c\u5176\u4ed6\u5c0f\u4f19\u4f34\u4eec\u5c06\u7aed\u8bda\u4e3a\u4f60\u89e3\u7b54\uff0c\u4e00\u822c\u60c5\u51b5\u4e0b\u53ef\u5728\u4e24\u5929\u5185\u5f97\u5230\u56de\u590d\u3002

    \u540c\u65f6\uff0c\u4e5f\u5e0c\u671b\u60a8\u80fd\u5728\u8bc4\u8bba\u533a\u591a\u82b1\u4e9b\u65f6\u95f4\u3002\u4e00\u65b9\u9762\uff0c\u60a8\u53ef\u4ee5\u4e86\u89e3\u5927\u5bb6\u9047\u5230\u7684\u95ee\u9898\uff0c\u4ece\u800c\u67e5\u6f0f\u8865\u7f3a\uff0c\u8fd9\u5c06\u6709\u52a9\u4e8e\u6fc0\u53d1\u66f4\u6df1\u5165\u7684\u601d\u8003\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u5e0c\u671b\u60a8\u80fd\u6177\u6168\u5730\u56de\u7b54\u5176\u4ed6\u5c0f\u4f19\u4f34\u7684\u95ee\u9898\u3001\u5206\u4eab\u60a8\u7684\u89c1\u89e3\uff0c\u8ba9\u5927\u5bb6\u5171\u540c\u5b66\u4e60\u548c\u8fdb\u6b65\u3002

    Fig. \u8bc4\u8bba\u533a\u793a\u4f8b

    "},{"location":"chapter_preface/suggestions/#025","title":"0.2.5. \u00a0 \u7b97\u6cd5\u5b66\u4e60\u8def\u7ebf","text":"

    \u4ece\u603b\u4f53\u4e0a\u770b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5b66\u4e60\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u8fc7\u7a0b\u5212\u5206\u4e3a\u4e09\u4e2a\u9636\u6bb5\uff1a

    1. \u7b97\u6cd5\u5165\u95e8\u3002\u6211\u4eec\u9700\u8981\u719f\u6089\u5404\u79cd\u6570\u636e\u7ed3\u6784\u7684\u7279\u70b9\u548c\u7528\u6cd5\uff0c\u5b66\u4e60\u4e0d\u540c\u7b97\u6cd5\u7684\u539f\u7406\u3001\u6d41\u7a0b\u3001\u7528\u9014\u548c\u6548\u7387\u7b49\u65b9\u9762\u5185\u5bb9\u3002
    2. \u5237\u7b97\u6cd5\u9898\u3002\u5efa\u8bae\u4ece\u70ed\u95e8\u9898\u76ee\u5f00\u5237\uff0c\u5982\u5251\u6307 Offer\u548cLeetCode Hot 100\uff0c\u5148\u79ef\u7d2f\u81f3\u5c11 100 \u9053\u9898\u76ee\uff0c\u719f\u6089\u4e3b\u6d41\u7684\u7b97\u6cd5\u95ee\u9898\u3002\u521d\u6b21\u5237\u9898\u65f6\uff0c\u201c\u77e5\u8bc6\u9057\u5fd8\u201d\u53ef\u80fd\u662f\u4e00\u4e2a\u6311\u6218\uff0c\u4f46\u8bf7\u653e\u5fc3\uff0c\u8fd9\u662f\u5f88\u6b63\u5e38\u7684\u3002\u6211\u4eec\u53ef\u4ee5\u6309\u7167\u201c\u827e\u5bbe\u6d69\u65af\u9057\u5fd8\u66f2\u7ebf\u201d\u6765\u590d\u4e60\u9898\u76ee\uff0c\u901a\u5e38\u5728\u8fdb\u884c 3-5 \u8f6e\u7684\u91cd\u590d\u540e\uff0c\u5c31\u80fd\u5c06\u5176\u7262\u8bb0\u5728\u5fc3\u3002
    3. \u642d\u5efa\u77e5\u8bc6\u4f53\u7cfb\u3002\u5728\u5b66\u4e60\u65b9\u9762\uff0c\u6211\u4eec\u53ef\u4ee5\u9605\u8bfb\u7b97\u6cd5\u4e13\u680f\u6587\u7ae0\u3001\u89e3\u9898\u6846\u67b6\u548c\u7b97\u6cd5\u6559\u6750\uff0c\u4ee5\u4e0d\u65ad\u4e30\u5bcc\u77e5\u8bc6\u4f53\u7cfb\u3002\u5728\u5237\u9898\u65b9\u9762\uff0c\u53ef\u4ee5\u5c1d\u8bd5\u91c7\u7528\u8fdb\u9636\u5237\u9898\u7b56\u7565\uff0c\u5982\u6309\u4e13\u9898\u5206\u7c7b\u3001\u4e00\u9898\u591a\u89e3\u3001\u4e00\u89e3\u591a\u9898\u7b49\uff0c\u76f8\u5173\u7684\u5237\u9898\u5fc3\u5f97\u53ef\u4ee5\u5728\u5404\u4e2a\u793e\u533a\u627e\u5230\u3002

    \u4f5c\u4e3a\u4e00\u672c\u5165\u95e8\u6559\u7a0b\uff0c\u672c\u4e66\u5185\u5bb9\u4e3b\u8981\u6db5\u76d6\u201c\u7b2c\u4e00\u9636\u6bb5\u201d\uff0c\u65e8\u5728\u5e2e\u52a9\u4f60\u66f4\u9ad8\u6548\u5730\u5c55\u5f00\u7b2c\u4e8c\u548c\u7b2c\u4e09\u9636\u6bb5\u7684\u5b66\u4e60\u3002

    Fig. \u7b97\u6cd5\u5b66\u4e60\u8def\u7ebf

    "},{"location":"chapter_preface/summary/","title":"0.3. \u00a0 \u5c0f\u7ed3","text":"
    • \u672c\u4e66\u7684\u4e3b\u8981\u53d7\u4f17\u662f\u7b97\u6cd5\u521d\u5b66\u8005\u3002\u5982\u679c\u5df2\u6709\u4e00\u5b9a\u57fa\u7840\uff0c\u672c\u4e66\u80fd\u5e2e\u52a9\u60a8\u7cfb\u7edf\u56de\u987e\u7b97\u6cd5\u77e5\u8bc6\uff0c\u4e66\u5185\u6e90\u4ee3\u7801\u4e5f\u53ef\u4f5c\u4e3a\u201c\u5237\u9898\u5de5\u5177\u5e93\u201d\u4f7f\u7528\u3002
    • \u4e66\u4e2d\u5185\u5bb9\u4e3b\u8981\u5305\u62ec\u590d\u6742\u5ea6\u5206\u6790\u3001\u6570\u636e\u7ed3\u6784\u3001\u7b97\u6cd5\u4e09\u90e8\u5206\uff0c\u6db5\u76d6\u4e86\u8be5\u9886\u57df\u7684\u5927\u90e8\u5206\u4e3b\u9898\u3002
    • \u5bf9\u4e8e\u7b97\u6cd5\u65b0\u624b\uff0c\u5728\u521d\u5b66\u9636\u6bb5\u9605\u8bfb\u4e00\u672c\u5165\u95e8\u4e66\u7c4d\u81f3\u5173\u91cd\u8981\uff0c\u53ef\u4ee5\u5c11\u8d70\u8bb8\u591a\u5f2f\u8def\u3002
    • \u4e66\u5185\u7684\u52a8\u753b\u548c\u56fe\u89e3\u901a\u5e38\u7528\u4e8e\u4ecb\u7ecd\u91cd\u70b9\u548c\u96be\u70b9\u77e5\u8bc6\u3002\u9605\u8bfb\u672c\u4e66\u65f6\uff0c\u5e94\u7ed9\u4e88\u8fd9\u4e9b\u5185\u5bb9\u66f4\u591a\u5173\u6ce8\u3002
    • \u5b9e\u8df5\u4e43\u5b66\u4e60\u7f16\u7a0b\u4e4b\u6700\u4f73\u9014\u5f84\u3002\u5f3a\u70c8\u5efa\u8bae\u8fd0\u884c\u6e90\u4ee3\u7801\u5e76\u4eb2\u81ea\u6572\u6253\u4ee3\u7801\u3002
    • \u672c\u4e66\u7f51\u9875\u7248\u7684\u6bcf\u4e2a\u7ae0\u8282\u90fd\u8bbe\u6709\u8ba8\u8bba\u533a\uff0c\u6b22\u8fce\u968f\u65f6\u5206\u4eab\u4f60\u7684\u7591\u60d1\u4e0e\u89c1\u89e3\u3002
    "},{"location":"chapter_reference/","title":"\u53c2\u8003\u6587\u732e","text":"

    [1] Thomas H. Cormen, et al. Introduction to Algorithms (3rd Edition).

    [2] Aditya Bhargava. Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People (1st Edition).

    [3] \u4e25\u851a\u654f. \u6570\u636e\u7ed3\u6784\uff08C \u8bed\u8a00\u7248\uff09.

    [4] \u9093\u4fca\u8f89. \u6570\u636e\u7ed3\u6784\uff08C++ \u8bed\u8a00\u7248\uff0c\u7b2c\u4e09\u7248\uff09.

    [5] \u9a6c\u514b \u827e\u4f26 \u7ef4\u65af\u8457\uff0c\u9648\u8d8a\u8bd1. \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u5206\u6790\uff1aJava\u8bed\u8a00\u63cf\u8ff0\uff08\u7b2c\u4e09\u7248\uff09.

    [6] \u7a0b\u6770. \u5927\u8bdd\u6570\u636e\u7ed3\u6784.

    [7] \u738b\u4e89. \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u4e4b\u7f8e.

    [8] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6th Edition).

    [9] Aston Zhang, et al. Dive into Deep Learning.

    "},{"location":"chapter_searching/","title":"10. \u00a0 \u641c\u7d22","text":""},{"location":"chapter_searching/binary_search/","title":"10.1. \u00a0 \u4e8c\u5206\u67e5\u627e","text":"

    \u300c\u4e8c\u5206\u67e5\u627e Binary Search\u300d\u662f\u4e00\u79cd\u57fa\u4e8e\u5206\u6cbb\u601d\u60f3\u7684\u9ad8\u6548\u641c\u7d22\u7b97\u6cd5\u3002\u5b83\u5229\u7528\u6570\u636e\u7684\u6709\u5e8f\u6027\uff0c\u6bcf\u8f6e\u51cf\u5c11\u4e00\u534a\u641c\u7d22\u8303\u56f4\uff0c\u76f4\u81f3\u627e\u5230\u76ee\u6807\u5143\u7d20\u6216\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u4e3a\u6b62\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4 nums \uff0c\u5143\u7d20\u6309\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\u6392\u5217\uff0c\u6570\u7ec4\u4e0d\u5305\u542b\u91cd\u590d\u5143\u7d20\u3002\u8bf7\u67e5\u627e\u5e76\u8fd4\u56de\u5143\u7d20 target \u5728\u8be5\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15\u3002\u82e5\u6570\u7ec4\u4e0d\u5305\u542b\u8be5\u5143\u7d20\uff0c\u5219\u8fd4\u56de \\(-1\\) \u3002

    \u5bf9\u4e8e\u4e0a\u8ff0\u95ee\u9898\uff0c\u6211\u4eec\u5148\u521d\u59cb\u5316\u6307\u9488 \\(i = 0\\) \u548c \\(j = n - 1\\) \uff0c\u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u548c\u5c3e\u5143\u7d20\uff0c\u4ee3\u8868\u641c\u7d22\u533a\u95f4 \\([0, n - 1]\\) \u3002\u5176\u4e2d\uff0c\u4e2d\u62ec\u53f7\u8868\u793a\u201c\u95ed\u533a\u95f4\u201d\uff0c\u5373\u5305\u542b\u8fb9\u754c\u503c\u672c\u8eab\u3002

    \u63a5\u4e0b\u6765\uff0c\u5faa\u73af\u6267\u884c\u4ee5\u4e0b\u4e24\u4e2a\u6b65\u9aa4\uff1a

    1. \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 \\(m = \\lfloor {(i + j) / 2} \\rfloor\\) \uff0c\u5176\u4e2d \\(\\lfloor \\space \\rfloor\\) \u8868\u793a\u5411\u4e0b\u53d6\u6574\u64cd\u4f5c\u3002
    2. \u5224\u65ad nums[m] \u548c target \u7684\u5927\u5c0f\u5173\u7cfb\uff0c\u5206\u4e3a\u4e09\u79cd\u60c5\u51b5\uff1a
      1. \u5f53 nums[m] < target \u65f6\uff0c\u8bf4\u660e target \u5728\u533a\u95f4 \\([m + 1, j]\\) \u4e2d\uff0c\u56e0\u6b64\u6267\u884c \\(i = m + 1\\) \uff1b
      2. \u5f53 nums[m] > target \u65f6\uff0c\u8bf4\u660e target \u5728\u533a\u95f4 \\([i, m - 1]\\) \u4e2d\uff0c\u56e0\u6b64\u6267\u884c \\(j = m - 1\\) \uff1b
      3. \u5f53 nums[m] = target \u65f6\uff0c\u8bf4\u660e\u627e\u5230 target \uff0c\u56e0\u6b64\u8fd4\u56de\u7d22\u5f15 \\(m\\) \uff1b

    \u82e5\u6570\u7ec4\u4e0d\u5305\u542b\u76ee\u6807\u5143\u7d20\uff0c\u641c\u7d22\u533a\u95f4\u6700\u7ec8\u4f1a\u7f29\u5c0f\u4e3a\u7a7a\u3002\u6b64\u65f6\u8fd4\u56de \\(-1\\) \u3002

    <0><1><2><3><4><5><6><7>

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u7531\u4e8e \\(i\\) \u548c \\(j\\) \u90fd\u662f int \u7c7b\u578b\uff0c\u56e0\u6b64 \\(i + j\\) \u53ef\u80fd\u4f1a\u8d85\u51fa int \u7c7b\u578b\u7684\u53d6\u503c\u8303\u56f4\u3002\u4e3a\u4e86\u907f\u514d\u5927\u6570\u8d8a\u754c\uff0c\u6211\u4eec\u901a\u5e38\u91c7\u7528\u516c\u5f0f \\(m = \\lfloor {i + (j - i) / 2} \\rfloor\\) \u6765\u8ba1\u7b97\u4e2d\u70b9\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search.java
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nint binarySearch(int[] nums, int target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nint i = 0, j = nums.length - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.cpp
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nint binarySearch(vector<int> &nums, int target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nint i = 0, j = nums.size() - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.py
    def binary_search(nums: list[int], target: int) -> int:\n\"\"\"\u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09\"\"\"\n# \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\ni, j = 0, len(nums) - 1\n# \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile i <= j:\n# \u7406\u8bba\u4e0a Python \u7684\u6570\u5b57\u53ef\u4ee5\u65e0\u9650\u5927\uff08\u53d6\u51b3\u4e8e\u5185\u5b58\u5927\u5c0f\uff09\uff0c\u65e0\u9700\u8003\u8651\u5927\u6570\u8d8a\u754c\u95ee\u9898\nm = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target:\ni = m + 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelif nums[m] > target:\nj = m - 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse:\nreturn m  # \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n
    binary_search.go
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfunc binarySearch(nums []int, target int) int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\ni, j := 0, len(nums)-1\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nfor i <= j {\nm := i + (j-i)/2      // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1\n} else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1\n} else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\n
    binary_search.js
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfunction binarySearch(nums, target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nlet i = 0,\nj = nums.length - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m \uff0c\u4f7f\u7528 parseInt() \u5411\u4e0b\u53d6\u6574\nconst m = parseInt(i + (j - i) / 2);\nif (nums[m] < target)\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\nelse if (nums[m] > target)\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\nelse return m; // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.ts
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfunction binarySearch(nums: number[], target: number): number {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nlet i = 0,\nj = nums.length - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nconst m = Math.floor(i + (j - i) / 2);\nif (nums[m] < target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\n} else if (nums[m] > target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\n} else {\n// \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n}\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\n
    binary_search.c
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nint binarySearch(int *nums, int len, int target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nint i = 0, j = len - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.cs
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nint binarySearch(int[] nums, int target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nint i = 0, j = nums.Length - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nint m = i + (j - i) / 2;   // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\nelse                       // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.swift
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfunc binarySearch(nums: [Int], target: Int) -> Int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nvar i = 0\nvar j = nums.count - 1\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile i <= j {\nlet m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1\n} else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1\n} else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\n
    binary_search.zig
    // \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09\nfn binarySearch(comptime T: type, nums: std.ArrayList(T), target: T) T {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nvar i: usize = 0;\nvar j: usize = nums.items.len - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nvar m = i + (j - i) / 2;                // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums.items[m] < target) {           // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\n} else if (nums.items[m] > target) {    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\n} else {                                // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn @intCast(m);\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.dart
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nint binarySearch(List<int> nums, int target) {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1] \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20\nint i = 0, j = nums.length - 1;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nint m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1;\n} else if (nums[m] > target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1;\n} else {\n// \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n

    \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u3002\u6bcf\u8f6e\u7f29\u5c0f\u4e00\u534a\u533a\u95f4\uff0c\u56e0\u6b64\u4e8c\u5206\u5faa\u73af\u6b21\u6570\u4e3a \\(\\log_2 n\\) \u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002\u6307\u9488 i , j \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7a7a\u95f4\u3002

    "},{"location":"chapter_searching/binary_search/#1011","title":"10.1.1. \u00a0 \u533a\u95f4\u8868\u793a\u65b9\u6cd5","text":"

    \u9664\u4e86\u4e0a\u8ff0\u7684\u53cc\u95ed\u533a\u95f4\u5916\uff0c\u5e38\u89c1\u7684\u533a\u95f4\u8868\u793a\u8fd8\u6709\u201c\u5de6\u95ed\u53f3\u5f00\u201d\u533a\u95f4\uff0c\u5b9a\u4e49\u4e3a \\([0, n)\\) \uff0c\u5373\u5de6\u8fb9\u754c\u5305\u542b\u81ea\u8eab\uff0c\u53f3\u8fb9\u754c\u4e0d\u5305\u542b\u81ea\u8eab\u3002\u5728\u8be5\u8868\u793a\u4e0b\uff0c\u533a\u95f4 \\([i, j]\\) \u5728 \\(i = j\\) \u65f6\u4e3a\u7a7a\u3002

    \u6211\u4eec\u53ef\u4ee5\u57fa\u4e8e\u8be5\u8868\u793a\u5b9e\u73b0\u5177\u6709\u76f8\u540c\u529f\u80fd\u7684\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search.java
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nint binarySearchLCRO(int[] nums, int target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nint i = 0, j = nums.length;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.cpp
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nint binarySearchLCRO(vector<int> &nums, int target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nint i = 0, j = nums.size();\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.py
    def binary_search_lcro(nums: list[int], target: int) -> int:\n\"\"\"\u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09\"\"\"\n# \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\ni, j = 0, len(nums)\n# \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile i < j:\nm = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target:\ni = m + 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\nelif nums[m] > target:\nj = m  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nelse:\nreturn m  # \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n
    binary_search.go
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nfunc binarySearchLCRO(nums []int, target int) int {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\ni, j := 0, len(nums)\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nfor i < j {\nm := i + (j-i)/2      // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1\n} else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m\n} else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\n
    binary_search.js
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nfunction binarySearchLCRO(nums, target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nlet i = 0,\nj = nums.length;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m \uff0c\u4f7f\u7528 parseInt() \u5411\u4e0b\u53d6\u6574\nconst m = parseInt(i + (j - i) / 2);\nif (nums[m] < target)\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\nelse if (nums[m] > target)\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\n// \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nelse return m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.ts
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nlet i = 0,\nj = nums.length;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nconst m = Math.floor(i + (j - i) / 2);\nif (nums[m] < target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\n} else if (nums[m] > target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\n} else {\n// \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n}\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\n
    binary_search.c
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nint binarySearchLCRO(int *nums, int len, int target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nint i = 0, j = len;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\nelse // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.cs
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nint binarySearchLCRO(int[] nums, int target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nint i = 0, j = nums.Length;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\nint m = i + (j - i) / 2;   // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\nelse if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\nelse                       // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.swift
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09 */\nfunc binarySearchLCRO(nums: [Int], target: Int) -> Int {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nvar i = 0\nvar j = nums.count\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile i < j {\nlet m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1\n} else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m\n} else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\n
    binary_search.zig
    // \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\uff09\nfn binarySearchLCRO(comptime T: type, nums: std.ArrayList(T), target: T) T {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nvar i: usize = 0;\nvar j: usize = nums.items.len;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i <= j) {\nvar m = i + (j - i) / 2;                // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums.items[m] < target) {           // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\n} else if (nums.items[m] > target) {    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\n} else {                                // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn @intCast(m);\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n
    binary_search.dart
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nint binarySearchLCRO(List<int> nums, int target) {\n// \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\nint i = 0, j = nums.length;\n// \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\nwhile (i < j) {\nint m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\ni = m + 1;\n} else if (nums[m] > target) {\n// \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\nj = m;\n} else {\n// \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\nreturn m;\n}\n}\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1;\n}\n

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5728\u4e24\u79cd\u533a\u95f4\u8868\u793a\u4e0b\uff0c\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u7684\u521d\u59cb\u5316\u3001\u5faa\u73af\u6761\u4ef6\u548c\u7f29\u5c0f\u533a\u95f4\u64cd\u4f5c\u7686\u6709\u6240\u4e0d\u540c\u3002

    \u5728\u201c\u53cc\u95ed\u533a\u95f4\u201d\u8868\u793a\u6cd5\u4e2d\uff0c\u7531\u4e8e\u5de6\u53f3\u8fb9\u754c\u90fd\u88ab\u5b9a\u4e49\u4e3a\u95ed\u533a\u95f4\uff0c\u56e0\u6b64\u6307\u9488 \\(i\\) \u548c \\(j\\) \u7f29\u5c0f\u533a\u95f4\u64cd\u4f5c\u4e5f\u662f\u5bf9\u79f0\u7684\u3002\u8fd9\u6837\u66f4\u4e0d\u5bb9\u6613\u51fa\u9519\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u901a\u5e38\u91c7\u7528\u201c\u53cc\u95ed\u533a\u95f4\u201d\u7684\u5199\u6cd5\u3002

    Fig. \u4e24\u79cd\u533a\u95f4\u5b9a\u4e49

    "},{"location":"chapter_searching/binary_search/#1012","title":"10.1.2. \u00a0 \u4f18\u70b9\u4e0e\u5c40\u9650\u6027","text":"

    \u4e8c\u5206\u67e5\u627e\u5728\u65f6\u95f4\u548c\u7a7a\u95f4\u65b9\u9762\u90fd\u6709\u8f83\u597d\u7684\u6027\u80fd\uff1a

    • \u4e8c\u5206\u67e5\u627e\u7684\u65f6\u95f4\u6548\u7387\u9ad8\u3002\u5728\u5927\u6570\u636e\u91cf\u4e0b\uff0c\u5bf9\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5177\u6709\u663e\u8457\u4f18\u52bf\u3002\u4f8b\u5982\uff0c\u5f53\u6570\u636e\u5927\u5c0f \\(n = 2^{20}\\) \u65f6\uff0c\u7ebf\u6027\u67e5\u627e\u9700\u8981 \\(2^{20} = 1048576\\) \u8f6e\u5faa\u73af\uff0c\u800c\u4e8c\u5206\u67e5\u627e\u4ec5\u9700 \\(\\log_2 2^{20} = 20\\) \u8f6e\u5faa\u73af\u3002
    • \u4e8c\u5206\u67e5\u627e\u65e0\u9700\u989d\u5916\u7a7a\u95f4\u3002\u76f8\u8f83\u4e8e\u9700\u8981\u501f\u52a9\u989d\u5916\u7a7a\u95f4\u7684\u641c\u7d22\u7b97\u6cd5\uff08\u4f8b\u5982\u54c8\u5e0c\u67e5\u627e\uff09\uff0c\u4e8c\u5206\u67e5\u627e\u66f4\u52a0\u8282\u7701\u7a7a\u95f4\u3002

    \u7136\u800c\uff0c\u4e8c\u5206\u67e5\u627e\u5e76\u975e\u9002\u7528\u4e8e\u6240\u6709\u60c5\u51b5\uff0c\u539f\u56e0\u5982\u4e0b\uff1a

    • \u4e8c\u5206\u67e5\u627e\u4ec5\u9002\u7528\u4e8e\u6709\u5e8f\u6570\u636e\u3002\u82e5\u8f93\u5165\u6570\u636e\u65e0\u5e8f\uff0c\u4e3a\u4e86\u4f7f\u7528\u4e8c\u5206\u67e5\u627e\u800c\u4e13\u95e8\u8fdb\u884c\u6392\u5e8f\uff0c\u5f97\u4e0d\u507f\u5931\u3002\u56e0\u4e3a\u6392\u5e8f\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u901a\u5e38\u4e3a \\(O(n \\log n)\\) \uff0c\u6bd4\u7ebf\u6027\u67e5\u627e\u548c\u4e8c\u5206\u67e5\u627e\u90fd\u66f4\u9ad8\u3002\u5bf9\u4e8e\u9891\u7e41\u63d2\u5165\u5143\u7d20\u7684\u573a\u666f\uff0c\u4e3a\u4fdd\u6301\u6570\u7ec4\u6709\u5e8f\u6027\uff0c\u9700\u8981\u5c06\u5143\u7d20\u63d2\u5165\u5230\u7279\u5b9a\u4f4d\u7f6e\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u4e5f\u662f\u975e\u5e38\u6602\u8d35\u7684\u3002
    • \u4e8c\u5206\u67e5\u627e\u4ec5\u9002\u7528\u4e8e\u6570\u7ec4\u3002\u4e8c\u5206\u67e5\u627e\u9700\u8981\u8df3\u8dc3\u5f0f\uff08\u975e\u8fde\u7eed\u5730\uff09\u8bbf\u95ee\u5143\u7d20\uff0c\u800c\u5728\u94fe\u8868\u4e2d\u6267\u884c\u8df3\u8dc3\u5f0f\u8bbf\u95ee\u7684\u6548\u7387\u8f83\u4f4e\uff0c\u56e0\u6b64\u4e0d\u9002\u5408\u5e94\u7528\u5728\u94fe\u8868\u6216\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u3002
    • \u5c0f\u6570\u636e\u91cf\u4e0b\uff0c\u7ebf\u6027\u67e5\u627e\u6027\u80fd\u66f4\u4f73\u3002\u5728\u7ebf\u6027\u67e5\u627e\u4e2d\uff0c\u6bcf\u8f6e\u53ea\u9700\u8981 1 \u6b21\u5224\u65ad\u64cd\u4f5c\uff1b\u800c\u5728\u4e8c\u5206\u67e5\u627e\u4e2d\uff0c\u9700\u8981 1 \u6b21\u52a0\u6cd5\u30011 \u6b21\u9664\u6cd5\u30011 ~ 3 \u6b21\u5224\u65ad\u64cd\u4f5c\u30011 \u6b21\u52a0\u6cd5\uff08\u51cf\u6cd5\uff09\uff0c\u5171 4 ~ 6 \u4e2a\u5355\u5143\u64cd\u4f5c\uff1b\u56e0\u6b64\uff0c\u5f53\u6570\u636e\u91cf \\(n\\) \u8f83\u5c0f\u65f6\uff0c\u7ebf\u6027\u67e5\u627e\u53cd\u800c\u6bd4\u4e8c\u5206\u67e5\u627e\u66f4\u5feb\u3002
    "},{"location":"chapter_searching/binary_search_edge/","title":"10.2. \u00a0 \u4e8c\u5206\u67e5\u627e\u8fb9\u754c","text":"

    \u5728\u4e0a\u4e00\u8282\u4e2d\uff0c\u9898\u76ee\u89c4\u5b9a\u6570\u7ec4\u4e2d\u6240\u6709\u5143\u7d20\u90fd\u662f\u552f\u4e00\u7684\u3002\u5982\u679c\u76ee\u6807\u5143\u7d20\u5728\u6570\u7ec4\u4e2d\u591a\u6b21\u51fa\u73b0\uff0c\u4e0a\u8282\u4ecb\u7ecd\u7684\u65b9\u6cd5\u53ea\u80fd\u4fdd\u8bc1\u8fd4\u56de\u5176\u4e2d\u4e00\u4e2a\u76ee\u6807\u5143\u7d20\u7684\u7d22\u5f15\uff0c\u800c\u65e0\u6cd5\u786e\u5b9a\u8be5\u7d22\u5f15\u7684\u5de6\u8fb9\u548c\u53f3\u8fb9\u8fd8\u6709\u591a\u5c11\u76ee\u6807\u5143\u7d20\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6709\u5e8f\u6570\u7ec4 nums \uff0c\u6570\u7ec4\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\u3002\u8bf7\u67e5\u627e\u5e76\u8fd4\u56de\u5143\u7d20 target \u5728\u6570\u7ec4\u4e2d\u9996\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\u3002\u82e5\u6570\u7ec4\u4e2d\u4e0d\u5305\u542b\u8be5\u5143\u7d20\uff0c\u5219\u8fd4\u56de \\(-1\\) \u3002

    "},{"location":"chapter_searching/binary_search_edge/#1021","title":"10.2.1. \u00a0 \u7ebf\u6027\u65b9\u6cd5","text":"

    \u4e3a\u4e86\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5de6\u8fb9\u7684 target \uff0c\u6211\u4eec\u53ef\u4ee5\u5206\u4e3a\u4e24\u6b65\uff1a

    1. \u8fdb\u884c\u4e8c\u5206\u67e5\u627e\uff0c\u5b9a\u4f4d\u5230\u4efb\u610f\u4e00\u4e2a target \u7684\u7d22\u5f15\uff0c\u8bb0\u4e3a \\(k\\) \uff1b
    2. \u4ee5\u7d22\u5f15 \\(k\\) \u4e3a\u8d77\u59cb\u70b9\uff0c\u5411\u5de6\u8fdb\u884c\u7ebf\u6027\u904d\u5386\uff0c\u627e\u5230\u6700\u5de6\u8fb9\u7684 target \u8fd4\u56de\u5373\u53ef\u3002

    Fig. \u7ebf\u6027\u67e5\u627e\u6700\u5de6\u8fb9\u7684\u5143\u7d20

    \u8fd9\u4e2a\u65b9\u6cd5\u867d\u7136\u6709\u6548\uff0c\u4f46\u7531\u4e8e\u5305\u542b\u7ebf\u6027\u67e5\u627e\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u5f53\u5b58\u5728\u5f88\u591a\u91cd\u590d\u7684 target \u65f6\u6548\u7387\u8f83\u4f4e\u3002

    "},{"location":"chapter_searching/binary_search_edge/#1022","title":"10.2.2. \u00a0 \u4e8c\u5206\u65b9\u6cd5","text":"

    \u8003\u8651\u4ec5\u4f7f\u7528\u4e8c\u5206\u67e5\u627e\u89e3\u51b3\u8be5\u95ee\u9898\u3002\u6574\u4f53\u7b97\u6cd5\u6d41\u7a0b\u4e0d\u53d8\uff0c\u5148\u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 \\(m\\) \uff0c\u518d\u5224\u65ad target \u548c nums[m] \u5927\u5c0f\u5173\u7cfb\uff1a

    • \u5f53 nums[m] < target \u6216 nums[m] > target \u65f6\uff0c\u8bf4\u660e\u8fd8\u6ca1\u6709\u627e\u5230 target \uff0c\u56e0\u6b64\u91c7\u53d6\u4e0e\u4e0a\u8282\u4ee3\u7801\u76f8\u540c\u7684\u7f29\u5c0f\u533a\u95f4\u64cd\u4f5c\uff0c\u4ece\u800c\u4f7f\u6307\u9488 \\(i\\) \u548c \\(j\\) \u5411 target \u9760\u8fd1\u3002
    • \u5f53 nums[m] == target \u65f6\uff0c\u8bf4\u660e\u201c\u5c0f\u4e8e target \u7684\u5143\u7d20\u201d\u5728\u533a\u95f4 \\([i, m - 1]\\) \u4e2d\uff0c\u56e0\u6b64\u91c7\u7528 \\(j = m - 1\\) \u6765\u7f29\u5c0f\u533a\u95f4\uff0c\u4ece\u800c\u4f7f\u6307\u9488 \\(j\\) \u5411\u5c0f\u4e8e target \u7684\u5143\u7d20\u9760\u8fd1\u3002

    \u4e8c\u5206\u67e5\u627e\u5b8c\u6210\u540e\uff0c\\(i\\) \u6307\u5411\u6700\u5de6\u8fb9\u7684 target \uff0c\\(j\\) \u6307\u5411\u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\uff0c\u56e0\u6b64\u8fd4\u56de\u7d22\u5f15 \\(i\\) \u5373\u53ef\u3002

    <1><2><3><4><5><6><7><8>

    \u6ce8\u610f\uff0c\u6570\u7ec4\u53ef\u80fd\u4e0d\u5305\u542b\u76ee\u6807\u5143\u7d20 target \u3002\u56e0\u6b64\u5728\u51fd\u6570\u8fd4\u56de\u524d\uff0c\u6211\u4eec\u9700\u8981\u5148\u5224\u65ad nums[i] \u4e0e target \u662f\u5426\u76f8\u7b49\uff0c\u4ee5\u53ca\u7d22\u5f15 \\(i\\) \u662f\u5426\u8d8a\u754c\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search_edge.java
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchLeftEdge(int[] nums, int target) {\nint i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\nif (i == nums.length || nums[i] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i;\n}\n
    binary_search_edge.cpp
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchLeftEdge(vector<int> &nums, int target) {\nint i = 0, j = nums.size() - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\nif (i == nums.size() || nums[i] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i;\n}\n
    binary_search_edge.py
    def binary_search_left_edge(nums: list[int], target: int) -> int:\n\"\"\"\u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20\"\"\"\ni, j = 0, len(nums) - 1  # \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile i <= j:\nm = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target:\ni = m + 1  # target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelif nums[m] > target:\nj = m - 1  # target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse:\nj = m - 1  # \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\nif i == len(nums) or nums[i] != target:\nreturn -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i\n
    binary_search_edge.go
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\ni, j := 0, len(nums)-1\nfor i <= j {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nm := i + (j-i)/2\nif nums[m] < target {\n// target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1\n} else if nums[m] > target {\n// target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1\n} else {\n// \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1\n}\n}\nif i == len(nums) || nums[i] != target {\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\nreturn i\n}\n
    binary_search_edge.js
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nfunction binarySearchLeftEdge(nums, target) {\nlet i = 0,\nj = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nlet m = Math.floor((i + j) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if (nums[m] > target) {\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\n}\nif (i == nums.length || nums[i] != target) {\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn i;\n}\n
    binary_search_edge.ts
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nfunction binarySearchLeftEdge(nums: number[], target: number): number {\nlet i = 0, j = nums.length - 1;  // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nlet m = Math.floor((i + j) / 2);  // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\ni = m + 1;  // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if (nums[m] > target) {\nj = m - 1;  // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\nj = m - 1;  // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\n}\nif (i == nums.length || nums[i] != target) {\nreturn -1;  // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn i;\n}\n
    binary_search_edge.c
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchLeftEdge(int *nums, int size, int target) {\nint i = 0, j = size - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\nif (i == size || nums[i] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i;\n}\n
    binary_search_edge.cs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchLeftEdge(int[] nums, int target) {\nint i = 0, j = nums.Length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\nif (i == nums.Length || nums[i] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i;\n}\n
    binary_search_edge.swift
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -> Int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nvar i = 0\nvar j = nums.count - 1\nwhile i <= j {\nlet m = i + (j - 1) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target {\ni = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if nums[m] > target {\nj = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\nj = m - 1 // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\n}\nif i == nums.count || nums[i] != target {\nreturn -1 // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn i\n}\n
    binary_search_edge.zig
    [class]{}-[func]{binarySearchLeftEdge}\n
    binary_search_edge.dart
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchLeftEdge(List<int> nums, int target) {\nint i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u95f4\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\nj = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n}\nif (i == nums.length || nums[i] != target) return -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn i;\n}\n
    "},{"location":"chapter_searching/binary_search_edge/#1023","title":"10.2.3. \u00a0 \u67e5\u627e\u53f3\u8fb9\u754c","text":"

    \u7c7b\u4f3c\u5730\uff0c\u6211\u4eec\u4e5f\u53ef\u4ee5\u4e8c\u5206\u67e5\u627e\u6700\u53f3\u8fb9\u7684 target \u3002\u5f53 nums[m] == target \u65f6\uff0c\u8bf4\u660e\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 \\([m + 1, j]\\) \u4e2d\uff0c\u56e0\u6b64\u6267\u884c i = m + 1 \uff0c\u4f7f\u5f97\u6307\u9488 \\(i\\) \u5411\u5927\u4e8e target \u7684\u5143\u7d20\u9760\u8fd1\u3002

    \u5b8c\u6210\u4e8c\u5206\u540e\uff0c\\(i\\) \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\uff0c\\(j\\) \u6307\u5411\u6700\u53f3\u8fb9\u7684 target \uff0c\u56e0\u6b64\u8fd4\u56de\u7d22\u5f15 \\(j\\) \u5373\u53ef\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search_edge.java
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchRightEdge(int[] nums, int target) {\nint i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\nif (j < 0 || nums[j] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j;\n}\n
    binary_search_edge.cpp
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchRightEdge(vector<int> &nums, int target) {\nint i = 0, j = nums.size() - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\nif (j < 0 || nums[j] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j;\n}\n
    binary_search_edge.py
    def binary_search_right_edge(nums: list[int], target: int) -> int:\n\"\"\"\u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20\"\"\"\ni, j = 0, len(nums) - 1  # \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile i <= j:\nm = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target:\ni = m + 1  # target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelif nums[m] > target:\nj = m - 1  # target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse:\ni = m + 1  # \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\nif j < 0 or nums[j] != target:\nreturn -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j\n
    binary_search_edge.go
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nfunc binarySearchRightEdge(nums []int, target int) int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\ni, j := 0, len(nums)-1\nfor i <= j {\n// \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nm := i + (j-i)/2\nif nums[m] < target {\n// target \u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1\n} else if nums[m] > target {\n// target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nj = m - 1\n} else {\n// \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\ni = m + 1\n}\n}\nif j < 0 || nums[j] != target {\n// \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn -1\n}\nreturn j\n}\n
    binary_search_edge.js
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nfunction binarySearchRightEdge(nums, target) {\nlet i = 0,\nj = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nlet m = Math.floor((i + j) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if (nums[m] > target) {\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\n}\nif (j < 0 || nums[j] != target) {\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn j;\n}\n
    binary_search_edge.ts
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nfunction binarySearchRightEdge(nums: number[], target: number): number {\nlet i = 0, j = nums.length - 1;  // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nlet m = Math.floor((i + j) / 2);  // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target) {\ni = m + 1;  // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if (nums[m] > target) {\nj = m - 1;  // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\ni = m + 1;  // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\n}\nif (j < 0 || nums[j] != target) {\nreturn -1;  // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn j;\n}\n
    binary_search_edge.c
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchRightEdge(int *nums, int size, int target) {\nint i = 0, j = size - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\nif (j < 0 || nums[j] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j;\n}\n
    binary_search_edge.cs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchRightEdge(int[] nums, int target) {\nint i = 0, j = nums.Length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\nif (j < 0 || nums[j] != target)\nreturn -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j;\n}\n
    binary_search_edge.swift
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -> Int {\n// \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nvar i = 0\nvar j = nums.count - 1\nwhile i <= j {\nlet m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\nif nums[m] < target {\ni = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n} else if nums[m] > target {\nj = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n} else {\ni = m + 1 // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\n}\nif j < 0 || nums[j] != target {\nreturn -1 // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n}\nreturn j\n}\n
    binary_search_edge.zig
    [class]{}-[func]{binarySearchRightEdge}\n
    binary_search_edge.dart
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a\u5143\u7d20 */\nint binarySearchRightEdge(List<int> nums, int target) {\nint i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\nwhile (i <= j) {\nint m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u95f4\u7d22\u5f15 m\nif (nums[m] < target)\ni = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\nelse if (nums[m] > target)\nj = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\nelse\ni = m + 1; // \u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [m+1, j] \u4e2d\n}\nif (j < 0 || nums[j] != target) return -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\nreturn j;\n}\n

    \u89c2\u5bdf\u4e0b\u56fe\uff0c\u641c\u7d22\u6700\u53f3\u8fb9\u5143\u7d20\u65f6\u6307\u9488 \\(j\\) \u7684\u4f5c\u7528\u4e0e\u641c\u7d22\u6700\u5de6\u8fb9\u5143\u7d20\u65f6\u6307\u9488 \\(i\\) \u7684\u4f5c\u7528\u4e00\u81f4\uff0c\u53cd\u4e4b\u4ea6\u7136\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u641c\u7d22\u6700\u5de6\u8fb9\u5143\u7d20\u548c\u6700\u53f3\u8fb9\u5143\u7d20\u7684\u5b9e\u73b0\u662f\u955c\u50cf\u5bf9\u79f0\u7684\u3002

    Fig. \u67e5\u627e\u6700\u5de6\u8fb9\u548c\u6700\u53f3\u8fb9\u5143\u7d20\u7684\u5bf9\u79f0\u6027

    Tip

    \u4ee5\u4e0a\u4ee3\u7801\u91c7\u53d6\u7684\u90fd\u662f\u201c\u53cc\u95ed\u533a\u95f4\u201d\u5199\u6cd5\u3002\u6709\u5174\u8da3\u7684\u8bfb\u8005\u53ef\u4ee5\u81ea\u884c\u5b9e\u73b0\u201c\u5de6\u95ed\u53f3\u5f00\u201d\u5199\u6cd5\u3002

    "},{"location":"chapter_searching/replace_linear_by_hashing/","title":"10.3. \u00a0 \u54c8\u5e0c\u4f18\u5316\u7b56\u7565","text":"

    \u5728\u7b97\u6cd5\u9898\u4e2d\uff0c\u6211\u4eec\u5e38\u901a\u8fc7\u5c06\u7ebf\u6027\u67e5\u627e\u66ff\u6362\u4e3a\u54c8\u5e0c\u67e5\u627e\u6765\u964d\u4f4e\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u3002\u6211\u4eec\u501f\u52a9\u4e00\u4e2a\u7b97\u6cd5\u9898\u6765\u52a0\u6df1\u7406\u89e3\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u6574\u6570\u6570\u7ec4 nums \u548c\u4e00\u4e2a\u76ee\u6807\u5143\u7d20 target \uff0c\u8bf7\u5728\u6570\u7ec4\u4e2d\u641c\u7d22\u201c\u548c\u201d\u4e3a target \u7684\u4e24\u4e2a\u5143\u7d20\uff0c\u5e76\u8fd4\u56de\u5b83\u4eec\u7684\u6570\u7ec4\u7d22\u5f15\u3002\u8fd4\u56de\u4efb\u610f\u4e00\u4e2a\u89e3\u5373\u53ef\u3002

    "},{"location":"chapter_searching/replace_linear_by_hashing/#1031","title":"10.3.1. \u00a0 \u7ebf\u6027\u67e5\u627e\uff1a\u4ee5\u65f6\u95f4\u6362\u7a7a\u95f4","text":"

    \u8003\u8651\u76f4\u63a5\u904d\u5386\u6240\u6709\u53ef\u80fd\u7684\u7ec4\u5408\u3002\u5f00\u542f\u4e00\u4e2a\u4e24\u5c42\u5faa\u73af\uff0c\u5728\u6bcf\u8f6e\u4e2d\u5224\u65ad\u4e24\u4e2a\u6574\u6570\u7684\u548c\u662f\u5426\u4e3a target \uff0c\u82e5\u662f\uff0c\u5219\u8fd4\u56de\u5b83\u4eec\u7684\u7d22\u5f15\u3002

    Fig. \u7ebf\u6027\u67e5\u627e\u6c42\u89e3\u4e24\u6570\u4e4b\u548c

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart two_sum.java
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint[] twoSumBruteForce(int[] nums, int target) {\nint size = nums.length;\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor (int i = 0; i < size - 1; i++) {\nfor (int j = i + 1; j < size; j++) {\nif (nums[i] + nums[j] == target)\nreturn new int[] { i, j };\n}\n}\nreturn new int[0];\n}\n
    two_sum.cpp
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nvector<int> twoSumBruteForce(vector<int> &nums, int target) {\nint size = nums.size();\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor (int i = 0; i < size - 1; i++) {\nfor (int j = i + 1; j < size; j++) {\nif (nums[i] + nums[j] == target)\nreturn {i, j};\n}\n}\nreturn {};\n}\n
    two_sum.py
    def two_sum_brute_force(nums: list[int], target: int) -> list[int]:\n\"\"\"\u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e\"\"\"\n# \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor i in range(len(nums) - 1):\nfor j in range(i + 1, len(nums)):\nif nums[i] + nums[j] == target:\nreturn [i, j]\nreturn []\n
    two_sum.go
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunc twoSumBruteForce(nums []int, target int) []int {\nsize := len(nums)\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor i := 0; i < size-1; i++ {\nfor j := i + 1; i < size; j++ {\nif nums[i]+nums[j] == target {\nreturn []int{i, j}\n}\n}\n}\nreturn nil\n}\n
    two_sum.js
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunction twoSumBruteForce(nums, target) {\nconst n = nums.length;\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor (let i = 0; i < n; i++) {\nfor (let j = i + 1; j < n; j++) {\nif (nums[i] + nums[j] === target) {\nreturn [i, j];\n}\n}\n}\nreturn [];\n}\n
    two_sum.ts
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\nconst n = nums.length;\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor (let i = 0; i < n; i++) {\nfor (let j = i + 1; j < n; j++) {\nif (nums[i] + nums[j] === target) {\nreturn [i, j];\n}\n}\n}\nreturn [];\n}\n
    two_sum.c
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\nfor (int i = 0; i < numsSize; ++i) {\nfor (int j = i + 1; j < numsSize; ++j) {\nif (nums[i] + nums[j] == target) {\nint *res = malloc(sizeof(int) * 2);\nres[0] = i, res[1] = j;\n*returnSize = 2;\nreturn res;\n}\n}\n}\n*returnSize = 0;\nreturn NULL;\n}\n
    two_sum.cs
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint[] twoSumBruteForce(int[] nums, int target) {\nint size = nums.Length;\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor (int i = 0; i < size - 1; i++) {\nfor (int j = i + 1; j < size; j++) {\nif (nums[i] + nums[j] == target)\nreturn new int[] { i, j };\n}\n}\nreturn new int[0];\n}\n
    two_sum.swift
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunc twoSumBruteForce(nums: [Int], target: Int) -> [Int] {\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nfor i in nums.indices.dropLast() {\nfor j in nums.indices.dropFirst(i + 1) {\nif nums[i] + nums[j] == target {\nreturn [i, j]\n}\n}\n}\nreturn [0]\n}\n
    two_sum.zig
    // \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e\nfn twoSumBruteForce(nums: []i32, target: i32) ?[2]i32 {\nvar size: usize = nums.len;\nvar i: usize = 0;\n// \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n^2)\nwhile (i < size - 1) : (i += 1) {\nvar j = i + 1;\nwhile (j < size) : (j += 1) {\nif (nums[i] + nums[j] == target) {\nreturn [_]i32{@intCast(i), @intCast(j)};\n}\n}\n}\nreturn null;\n}\n
    two_sum.dart
    /* \u65b9\u6cd5\u4e00\uff1a \u66b4\u529b\u679a\u4e3e */\nList<int> twoSumBruteForce(List<int> nums, int target) {\nint size = nums.length;\nfor (var i = 0; i < size - 1; i++) {\nfor (var j = i + 1; j < size; j++) {\nif (nums[i] + nums[j] == target) return [i, j];\n}\n}\nreturn [0];\n}\n

    \u6b64\u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \uff0c\u5728\u5927\u6570\u636e\u91cf\u4e0b\u975e\u5e38\u8017\u65f6\u3002

    "},{"location":"chapter_searching/replace_linear_by_hashing/#1032","title":"10.3.2. \u00a0 \u54c8\u5e0c\u67e5\u627e\uff1a\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4","text":"

    \u8003\u8651\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868\uff0c\u952e\u503c\u5bf9\u5206\u522b\u4e3a\u6570\u7ec4\u5143\u7d20\u548c\u5143\u7d20\u7d22\u5f15\u3002\u5faa\u73af\u904d\u5386\u6570\u7ec4\uff0c\u6bcf\u8f6e\u6267\u884c\uff1a

    1. \u5224\u65ad\u6570\u5b57 target - nums[i] \u662f\u5426\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u82e5\u662f\u5219\u76f4\u63a5\u8fd4\u56de\u8fd9\u4e24\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\uff1b
    2. \u5c06\u952e\u503c\u5bf9 nums[i] \u548c\u7d22\u5f15 i \u6dfb\u52a0\u8fdb\u54c8\u5e0c\u8868\uff1b
    <1><2><3>

    \u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff0c\u4ec5\u9700\u5355\u5c42\u5faa\u73af\u5373\u53ef\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart two_sum.java
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint[] twoSumHashTable(int[] nums, int target) {\nint size = nums.length;\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nMap<Integer, Integer> dic = new HashMap<>();\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor (int i = 0; i < size; i++) {\nif (dic.containsKey(target - nums[i])) {\nreturn new int[] { dic.get(target - nums[i]), i };\n}\ndic.put(nums[i], i);\n}\nreturn new int[0];\n}\n
    two_sum.cpp
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nvector<int> twoSumHashTable(vector<int> &nums, int target) {\nint size = nums.size();\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nunordered_map<int, int> dic;\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor (int i = 0; i < size; i++) {\nif (dic.find(target - nums[i]) != dic.end()) {\nreturn {dic[target - nums[i]], i};\n}\ndic.emplace(nums[i], i);\n}\nreturn {};\n}\n
    two_sum.py
    def two_sum_hash_table(nums: list[int], target: int) -> list[int]:\n\"\"\"\u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868\"\"\"\n# \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\ndic = {}\n# \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor i in range(len(nums)):\nif target - nums[i] in dic:\nreturn [dic[target - nums[i]], i]\ndic[nums[i]] = i\nreturn []\n
    two_sum.go
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nfunc twoSumHashTable(nums []int, target int) []int {\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nhashTable := map[int]int{}\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor idx, val := range nums {\nif preIdx, ok := hashTable[target-val]; ok {\nreturn []int{preIdx, idx}\n}\nhashTable[val] = idx\n}\nreturn nil\n}\n
    two_sum.js
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nfunction twoSumHashTable(nums, target) {\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nlet m = {};\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor (let i = 0; i < nums.length; i++) {\nif (m[target - nums[i]] !== undefined) {\nreturn [m[target-nums[i]], i];\n} else {\nm[nums[i]] = i;\n}\n}\nreturn [];\n}\n
    two_sum.ts
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nfunction twoSumHashTable(nums: number[], target: number): number[] {\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nlet m: Map<number, number> = new Map();\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor (let i = 0; i < nums.length; i++) {\nlet index = m.get(target - nums[i]);\nif (index !== undefined) {\nreturn [index, i];\n} else {\nm.set(nums[i], i);\n}\n}\nreturn [];\n}\n
    two_sum.c
    /* \u54c8\u5e0c\u8868 */\nstruct hashTable {\nint key;\nint val;\nUT_hash_handle hh; // \u57fa\u4e8e uthash.h \u5b9e\u73b0\n};\ntypedef struct hashTable hashTable;\n/* \u54c8\u5e0c\u8868\u67e5\u8be2 */\nhashTable *find(hashTable *h, int key) {\nhashTable *tmp;\nHASH_FIND_INT(h, &key, tmp);\nreturn tmp;\n}\n/* \u54c8\u5e0c\u8868\u5143\u7d20\u63d2\u5165 */\nvoid insert(hashTable *h, int key, int val) {\nhashTable *t = find(h, key);\nif (t == NULL) {\nhashTable *tmp = malloc(sizeof(hashTable));\ntmp->key = key, tmp->val = val;\nHASH_ADD_INT(h, key, tmp);\n} else {\nt->val = val;\n}\n}\n/* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\nhashTable *hashtable = NULL;\nfor (int i = 0; i < numsSize; i++) {\nhashTable *t = find(hashtable, target - nums[i]);\nif (t != NULL) {\nint *res = malloc(sizeof(int) * 2);\nres[0] = t->val, res[1] = i;\n*returnSize = 2;\nreturn res;\n}\ninsert(hashtable, nums[i], i);\n}\n*returnSize = 0;\nreturn NULL;\n}\n
    two_sum.cs
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint[] twoSumHashTable(int[] nums, int target) {\nint size = nums.Length;\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nDictionary<int, int> dic = new();\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor (int i = 0; i < size; i++) {\nif (dic.ContainsKey(target - nums[i])) {\nreturn new int[] { dic[target - nums[i]], i };\n}\ndic.Add(nums[i], i);\n}\nreturn new int[0];\n}\n
    two_sum.swift
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nfunc twoSumHashTable(nums: [Int], target: Int) -> [Int] {\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nvar dic: [Int: Int] = [:]\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nfor i in nums.indices {\nif let j = dic[target - nums[i]] {\nreturn [j, i]\n}\ndic[nums[i]] = i\n}\nreturn [0]\n}\n
    two_sum.zig
    // \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868\nfn twoSumHashTable(nums: []i32, target: i32) !?[2]i32 {\nvar size: usize = nums.len;\n// \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6 O(n)\nvar dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);\ndefer dic.deinit();\nvar i: usize = 0;\n// \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6 O(n)\nwhile (i < size) : (i += 1) {\nif (dic.contains(target - nums[i])) {\nreturn [_]i32{dic.get(target - nums[i]).?, @intCast(i)};\n}\ntry dic.put(nums[i], @intCast(i));\n}\nreturn null;\n}\n
    two_sum.dart
    /* \u65b9\u6cd5\u4e8c\uff1a \u8f85\u52a9\u54c8\u5e0c\u8868 */\nList<int> twoSumHashTable(List<int> nums, int target) {\nint size = nums.length;\nMap<int, int> dic = HashMap();\nfor (var i = 0; i < size; i++) {\nif (dic.containsKey(target - nums[i])) {\nreturn [dic[target - nums[i]]!, i];\n}\ndic.putIfAbsent(nums[i], () => i);\n}\nreturn [0];\n}\n

    \u6b64\u65b9\u6cd5\u901a\u8fc7\u54c8\u5e0c\u67e5\u627e\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n^2)\\) \u964d\u4f4e\u81f3 \\(O(n)\\) \uff0c\u5927\u5e45\u63d0\u5347\u8fd0\u884c\u6548\u7387\u3002

    \u7531\u4e8e\u9700\u8981\u7ef4\u62a4\u4e00\u4e2a\u989d\u5916\u7684\u54c8\u5e0c\u8868\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002\u5c3d\u7ba1\u5982\u6b64\uff0c\u8be5\u65b9\u6cd5\u7684\u6574\u4f53\u65f6\u7a7a\u6548\u7387\u66f4\u4e3a\u5747\u8861\uff0c\u56e0\u6b64\u5b83\u662f\u672c\u9898\u7684\u6700\u4f18\u89e3\u6cd5\u3002

    "},{"location":"chapter_searching/searching_algorithm_revisited/","title":"10.4. \u00a0 \u91cd\u8bc6\u641c\u7d22\u7b97\u6cd5","text":"

    \u300c\u641c\u7d22\u7b97\u6cd5 Searching Algorithm\u300d\u7528\u4e8e\u5728\u6570\u636e\u7ed3\u6784\uff08\u4f8b\u5982\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6811\u6216\u56fe\uff09\u4e2d\u641c\u7d22\u4e00\u4e2a\u6216\u4e00\u7ec4\u6ee1\u8db3\u7279\u5b9a\u6761\u4ef6\u7684\u5143\u7d20\u3002

    \u6839\u636e\u5b9e\u73b0\u601d\u8def\uff0c\u641c\u7d22\u7b97\u6cd5\u603b\u4f53\u53ef\u5206\u4e3a\u4e24\u79cd\uff1a

    • \u901a\u8fc7\u904d\u5386\u6570\u636e\u7ed3\u6784\u6765\u5b9a\u4f4d\u76ee\u6807\u5143\u7d20\uff0c\u4f8b\u5982\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6811\u548c\u56fe\u7684\u904d\u5386\u7b49\u3002
    • \u5229\u7528\u6570\u636e\u7ec4\u7ec7\u7ed3\u6784\u6216\u6570\u636e\u5305\u542b\u7684\u5148\u9a8c\u4fe1\u606f\uff0c\u5b9e\u73b0\u9ad8\u6548\u5143\u7d20\u67e5\u627e\uff0c\u4f8b\u5982\u4e8c\u5206\u67e5\u627e\u3001\u54c8\u5e0c\u67e5\u627e\u548c\u4e8c\u53c9\u641c\u7d22\u6811\u67e5\u627e\u7b49\u3002

    \u4e0d\u96be\u53d1\u73b0\uff0c\u8fd9\u4e9b\u77e5\u8bc6\u70b9\u90fd\u5df2\u5728\u524d\u9762\u7684\u7ae0\u8282\u4e2d\u4ecb\u7ecd\u8fc7\uff0c\u56e0\u6b64\u641c\u7d22\u7b97\u6cd5\u5bf9\u4e8e\u6211\u4eec\u6765\u8bf4\u5e76\u4e0d\u964c\u751f\u3002\u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u5c06\u4ece\u66f4\u52a0\u7cfb\u7edf\u7684\u89c6\u89d2\u5207\u5165\uff0c\u91cd\u65b0\u5ba1\u89c6\u641c\u7d22\u7b97\u6cd5\u3002

    "},{"location":"chapter_searching/searching_algorithm_revisited/#1041","title":"10.4.1. \u00a0 \u66b4\u529b\u641c\u7d22","text":"

    \u66b4\u529b\u641c\u7d22\u901a\u8fc7\u904d\u5386\u6570\u636e\u7ed3\u6784\u7684\u6bcf\u4e2a\u5143\u7d20\u6765\u5b9a\u4f4d\u76ee\u6807\u5143\u7d20\u3002

    • \u300c\u7ebf\u6027\u641c\u7d22\u300d\u9002\u7528\u4e8e\u6570\u7ec4\u548c\u94fe\u8868\u7b49\u7ebf\u6027\u6570\u636e\u7ed3\u6784\u3002\u5b83\u4ece\u6570\u636e\u7ed3\u6784\u7684\u4e00\u7aef\u5f00\u59cb\uff0c\u9010\u4e2a\u8bbf\u95ee\u5143\u7d20\uff0c\u76f4\u5230\u627e\u5230\u76ee\u6807\u5143\u7d20\u6216\u5230\u8fbe\u53e6\u4e00\u7aef\u4ecd\u6ca1\u6709\u627e\u5230\u76ee\u6807\u5143\u7d20\u4e3a\u6b62\u3002
    • \u300c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22\u300d\u548c\u300c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u300d\u662f\u56fe\u548c\u6811\u7684\u4e24\u79cd\u904d\u5386\u7b56\u7565\u3002\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22\u4ece\u521d\u59cb\u8282\u70b9\u5f00\u59cb\u9010\u5c42\u641c\u7d22\uff0c\u7531\u8fd1\u53ca\u8fdc\u5730\u8bbf\u95ee\u5404\u4e2a\u8282\u70b9\u3002\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u662f\u4ece\u521d\u59cb\u8282\u70b9\u5f00\u59cb\uff0c\u6cbf\u7740\u4e00\u6761\u8def\u5f84\u8d70\u5230\u5934\u4e3a\u6b62\uff0c\u518d\u56de\u6eaf\u5e76\u5c1d\u8bd5\u5176\u4ed6\u8def\u5f84\uff0c\u76f4\u5230\u904d\u5386\u5b8c\u6574\u4e2a\u6570\u636e\u7ed3\u6784\u3002

    \u66b4\u529b\u641c\u7d22\u7684\u4f18\u70b9\u662f\u7b80\u5355\u4e14\u901a\u7528\u6027\u597d\uff0c\u65e0\u9700\u5bf9\u6570\u636e\u505a\u9884\u5904\u7406\u548c\u501f\u52a9\u989d\u5916\u7684\u6570\u636e\u7ed3\u6784\u3002

    \u7136\u800c\uff0c\u6b64\u7c7b\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u5176\u4e2d \\(n\\) \u4e3a\u5143\u7d20\u6570\u91cf\uff0c\u56e0\u6b64\u5728\u6570\u636e\u91cf\u8f83\u5927\u7684\u60c5\u51b5\u4e0b\u6027\u80fd\u8f83\u5dee\u3002

    "},{"location":"chapter_searching/searching_algorithm_revisited/#1042","title":"10.4.2. \u00a0 \u81ea\u9002\u5e94\u641c\u7d22","text":"

    \u81ea\u9002\u5e94\u641c\u7d22\u5229\u7528\u6570\u636e\u7684\u7279\u6709\u5c5e\u6027\uff08\u4f8b\u5982\u6709\u5e8f\u6027\uff09\u6765\u4f18\u5316\u641c\u7d22\u8fc7\u7a0b\uff0c\u4ece\u800c\u66f4\u9ad8\u6548\u5730\u5b9a\u4f4d\u76ee\u6807\u5143\u7d20\u3002

    • \u300c\u4e8c\u5206\u67e5\u627e\u300d\u5229\u7528\u6570\u636e\u7684\u6709\u5e8f\u6027\u5b9e\u73b0\u9ad8\u6548\u67e5\u627e\uff0c\u4ec5\u9002\u7528\u4e8e\u6570\u7ec4\u3002
    • \u300c\u54c8\u5e0c\u67e5\u627e\u300d\u5229\u7528\u54c8\u5e0c\u8868\u5c06\u641c\u7d22\u6570\u636e\u548c\u76ee\u6807\u6570\u636e\u5efa\u7acb\u4e3a\u952e\u503c\u5bf9\u6620\u5c04\uff0c\u4ece\u800c\u5b9e\u73b0\u67e5\u8be2\u64cd\u4f5c\u3002
    • \u300c\u6811\u67e5\u627e\u300d\u5728\u7279\u5b9a\u7684\u6811\u7ed3\u6784\uff08\u4f8b\u5982\u4e8c\u53c9\u641c\u7d22\u6811\uff09\u4e2d\uff0c\u57fa\u4e8e\u6bd4\u8f83\u8282\u70b9\u503c\u6765\u5feb\u901f\u6392\u9664\u8282\u70b9\uff0c\u4ece\u800c\u5b9a\u4f4d\u76ee\u6807\u5143\u7d20\u3002

    \u6b64\u7c7b\u7b97\u6cd5\u7684\u4f18\u70b9\u662f\u6548\u7387\u9ad8\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u8fbe\u5230 \\(O(\\log n)\\) \u751a\u81f3 \\(O(1)\\) \u3002

    \u7136\u800c\uff0c\u4f7f\u7528\u8fd9\u4e9b\u7b97\u6cd5\u5f80\u5f80\u9700\u8981\u5bf9\u6570\u636e\u8fdb\u884c\u9884\u5904\u7406\u3002\u4f8b\u5982\uff0c\u4e8c\u5206\u67e5\u627e\u9700\u8981\u9884\u5148\u5bf9\u6570\u7ec4\u8fdb\u884c\u6392\u5e8f\uff0c\u54c8\u5e0c\u67e5\u627e\u548c\u6811\u67e5\u627e\u90fd\u9700\u8981\u501f\u52a9\u989d\u5916\u7684\u6570\u636e\u7ed3\u6784\uff0c\u7ef4\u62a4\u8fd9\u4e9b\u6570\u636e\u7ed3\u6784\u4e5f\u9700\u8981\u989d\u5916\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u5f00\u652f\u3002

    Note

    \u81ea\u9002\u5e94\u641c\u7d22\u7b97\u6cd5\u5e38\u88ab\u79f0\u4e3a\u67e5\u627e\u7b97\u6cd5\uff0c\u4e3b\u8981\u5173\u6ce8\u5728\u7279\u5b9a\u6570\u636e\u7ed3\u6784\u4e2d\u5feb\u901f\u68c0\u7d22\u76ee\u6807\u5143\u7d20\u3002

    "},{"location":"chapter_searching/searching_algorithm_revisited/#1043","title":"10.4.3. \u00a0 \u641c\u7d22\u65b9\u6cd5\u9009\u53d6","text":"

    \u7ed9\u5b9a\u5927\u5c0f\u4e3a \\(n\\) \u7684\u4e00\u7ec4\u6570\u636e\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u7ebf\u6027\u641c\u7d22\u3001\u4e8c\u5206\u67e5\u627e\u3001\u6811\u67e5\u627e\u3001\u54c8\u5e0c\u67e5\u627e\u7b49\u591a\u79cd\u65b9\u6cd5\u5728\u8be5\u6570\u636e\u4e2d\u641c\u7d22\u76ee\u6807\u5143\u7d20\u3002\u5404\u4e2a\u65b9\u6cd5\u7684\u5de5\u4f5c\u539f\u7406\u5982\u4e0b\u56fe\u6240\u793a\u3002

    Fig. \u591a\u79cd\u641c\u7d22\u7b56\u7565

    \u4e0a\u8ff0\u51e0\u79cd\u65b9\u6cd5\u7684\u64cd\u4f5c\u6548\u7387\u4e0e\u7279\u6027\u5982\u4e0b\u8868\u6240\u793a\u3002

    \u7ebf\u6027\u641c\u7d22 \u4e8c\u5206\u67e5\u627e \u6811\u67e5\u627e \u54c8\u5e0c\u67e5\u627e \u67e5\u627e\u5143\u7d20 \\(O(n)\\) \\(O(\\log n)\\) \\(O(\\log n)\\) \\(O(1)\\) \u63d2\u5165\u5143\u7d20 \\(O(1)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) \u5220\u9664\u5143\u7d20 \\(O(n)\\) \\(O(n)\\) \\(O(\\log n)\\) \\(O(1)\\) \u989d\u5916\u7a7a\u95f4 \\(O(1)\\) \\(O(1)\\) \\(O(n)\\) \\(O(n)\\) \u6570\u636e\u9884\u5904\u7406 / \u6392\u5e8f \\(O(n \\log n)\\) \u5efa\u6811 \\(O(n \\log n)\\) \u5efa\u54c8\u5e0c\u8868 \\(O(n)\\) \u6570\u636e\u662f\u5426\u6709\u5e8f \u65e0\u5e8f \u6709\u5e8f \u6709\u5e8f \u65e0\u5e8f

    \u9664\u4e86\u4ee5\u4e0a\u8868\u683c\u5185\u5bb9\uff0c\u641c\u7d22\u7b97\u6cd5\u7684\u9009\u62e9\u8fd8\u53d6\u51b3\u4e8e\u6570\u636e\u4f53\u91cf\u3001\u641c\u7d22\u6027\u80fd\u8981\u6c42\u3001\u6570\u636e\u67e5\u8be2\u4e0e\u66f4\u65b0\u9891\u7387\u7b49\u3002

    \u7ebf\u6027\u641c\u7d22

    • \u901a\u7528\u6027\u8f83\u597d\uff0c\u65e0\u9700\u4efb\u4f55\u6570\u636e\u9884\u5904\u7406\u64cd\u4f5c\u3002\u5047\u5982\u6211\u4eec\u4ec5\u9700\u67e5\u8be2\u4e00\u6b21\u6570\u636e\uff0c\u90a3\u4e48\u5176\u4ed6\u4e09\u79cd\u65b9\u6cd5\u7684\u6570\u636e\u9884\u5904\u7406\u7684\u65f6\u95f4\u6bd4\u7ebf\u6027\u641c\u7d22\u7684\u65f6\u95f4\u8fd8\u8981\u66f4\u957f\u3002
    • \u9002\u7528\u4e8e\u4f53\u91cf\u8f83\u5c0f\u7684\u6570\u636e\uff0c\u6b64\u60c5\u51b5\u4e0b\u65f6\u95f4\u590d\u6742\u5ea6\u5bf9\u6548\u7387\u5f71\u54cd\u8f83\u5c0f\u3002
    • \u9002\u7528\u4e8e\u6570\u636e\u66f4\u65b0\u9891\u7387\u8f83\u9ad8\u7684\u573a\u666f\uff0c\u56e0\u4e3a\u8be5\u65b9\u6cd5\u4e0d\u9700\u8981\u5bf9\u6570\u636e\u8fdb\u884c\u4efb\u4f55\u989d\u5916\u7ef4\u62a4\u3002

    \u4e8c\u5206\u67e5\u627e

    • \u9002\u7528\u4e8e\u5927\u6570\u636e\u91cf\u7684\u60c5\u51b5\uff0c\u6548\u7387\u8868\u73b0\u7a33\u5b9a\uff0c\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u3002
    • \u6570\u636e\u91cf\u4e0d\u80fd\u8fc7\u5927\uff0c\u56e0\u4e3a\u5b58\u50a8\u6570\u7ec4\u9700\u8981\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u3002
    • \u4e0d\u9002\u7528\u4e8e\u9ad8\u9891\u589e\u5220\u6570\u636e\u7684\u573a\u666f\uff0c\u56e0\u4e3a\u7ef4\u62a4\u6709\u5e8f\u6570\u7ec4\u7684\u5f00\u9500\u8f83\u5927\u3002

    \u54c8\u5e0c\u67e5\u627e

    • \u9002\u5408\u5bf9\u67e5\u8be2\u6027\u80fd\u8981\u6c42\u5f88\u9ad8\u7684\u573a\u666f\uff0c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002
    • \u4e0d\u9002\u5408\u9700\u8981\u6709\u5e8f\u6570\u636e\u6216\u8303\u56f4\u67e5\u627e\u7684\u573a\u666f\uff0c\u56e0\u4e3a\u54c8\u5e0c\u8868\u65e0\u6cd5\u7ef4\u62a4\u6570\u636e\u7684\u6709\u5e8f\u6027\u3002
    • \u5bf9\u54c8\u5e0c\u51fd\u6570\u548c\u54c8\u5e0c\u51b2\u7a81\u5904\u7406\u7b56\u7565\u7684\u4f9d\u8d56\u6027\u8f83\u9ad8\uff0c\u5177\u6709\u8f83\u5927\u7684\u6027\u80fd\u52a3\u5316\u98ce\u9669\u3002
    • \u4e0d\u9002\u5408\u6570\u636e\u91cf\u8fc7\u5927\u7684\u60c5\u51b5\uff0c\u56e0\u4e3a\u54c8\u5e0c\u8868\u9700\u8981\u989d\u5916\u7a7a\u95f4\u6765\u6700\u5927\u7a0b\u5ea6\u5730\u51cf\u5c11\u51b2\u7a81\uff0c\u4ece\u800c\u63d0\u4f9b\u826f\u597d\u7684\u67e5\u8be2\u6027\u80fd\u3002

    \u6811\u67e5\u627e

    • \u9002\u7528\u4e8e\u6d77\u91cf\u6570\u636e\uff0c\u56e0\u4e3a\u6811\u8282\u70b9\u5728\u5185\u5b58\u4e2d\u662f\u79bb\u6563\u5b58\u50a8\u7684\u3002
    • \u9002\u5408\u9700\u8981\u7ef4\u62a4\u6709\u5e8f\u6570\u636e\u6216\u8303\u56f4\u67e5\u627e\u7684\u573a\u666f\u3002
    • \u5728\u6301\u7eed\u589e\u5220\u8282\u70b9\u7684\u8fc7\u7a0b\u4e2d\uff0c\u4e8c\u53c9\u641c\u7d22\u6811\u53ef\u80fd\u4ea7\u751f\u503e\u659c\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u52a3\u5316\u81f3 \\(O(n)\\) \u3002
    • \u82e5\u4f7f\u7528 AVL \u6811\u6216\u7ea2\u9ed1\u6811\uff0c\u5219\u5404\u9879\u64cd\u4f5c\u53ef\u5728 \\(O(\\log n)\\) \u6548\u7387\u4e0b\u7a33\u5b9a\u8fd0\u884c\uff0c\u4f46\u7ef4\u62a4\u6811\u5e73\u8861\u7684\u64cd\u4f5c\u4f1a\u589e\u52a0\u989d\u5916\u5f00\u9500\u3002
    "},{"location":"chapter_searching/summary/","title":"10.5. \u00a0 \u5c0f\u7ed3","text":"
    • \u4e8c\u5206\u67e5\u627e\u4f9d\u8d56\u4e8e\u6570\u636e\u7684\u6709\u5e8f\u6027\uff0c\u901a\u8fc7\u5faa\u73af\u9010\u6b65\u7f29\u51cf\u4e00\u534a\u641c\u7d22\u533a\u95f4\u6765\u5b9e\u73b0\u67e5\u627e\u3002\u5b83\u8981\u6c42\u8f93\u5165\u6570\u636e\u6709\u5e8f\uff0c\u4e14\u4ec5\u9002\u7528\u4e8e\u6570\u7ec4\u6216\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u3002
    • \u66b4\u529b\u641c\u7d22\u901a\u8fc7\u904d\u5386\u6570\u636e\u7ed3\u6784\u6765\u5b9a\u4f4d\u6570\u636e\u3002\u7ebf\u6027\u641c\u7d22\u9002\u7528\u4e8e\u6570\u7ec4\u548c\u94fe\u8868\uff0c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22\u548c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u9002\u7528\u4e8e\u56fe\u548c\u6811\u3002\u6b64\u7c7b\u7b97\u6cd5\u901a\u7528\u6027\u597d\uff0c\u65e0\u9700\u5bf9\u6570\u636e\u9884\u5904\u7406\uff0c\u4f46\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n)\\) \u8f83\u9ad8\u3002
    • \u54c8\u5e0c\u67e5\u627e\u3001\u6811\u67e5\u627e\u548c\u4e8c\u5206\u67e5\u627e\u5c5e\u4e8e\u9ad8\u6548\u641c\u7d22\u65b9\u6cd5\uff0c\u53ef\u5728\u7279\u5b9a\u6570\u636e\u7ed3\u6784\u4e2d\u5feb\u901f\u5b9a\u4f4d\u76ee\u6807\u5143\u7d20\u3002\u6b64\u7c7b\u7b97\u6cd5\u6548\u7387\u9ad8\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u8fbe \\(O(\\log n)\\) \u751a\u81f3 \\(O(1)\\) \uff0c\u4f46\u901a\u5e38\u9700\u8981\u501f\u52a9\u989d\u5916\u6570\u636e\u7ed3\u6784\u3002
    • \u5b9e\u9645\u4e2d\uff0c\u6211\u4eec\u9700\u8981\u5bf9\u6570\u636e\u4f53\u91cf\u3001\u641c\u7d22\u6027\u80fd\u8981\u6c42\u3001\u6570\u636e\u67e5\u8be2\u548c\u66f4\u65b0\u9891\u7387\u7b49\u56e0\u7d20\u8fdb\u884c\u5177\u4f53\u5206\u6790\uff0c\u4ece\u800c\u9009\u62e9\u5408\u9002\u7684\u641c\u7d22\u65b9\u6cd5\u3002
    • \u7ebf\u6027\u641c\u7d22\u9002\u7528\u4e8e\u5c0f\u578b\u6216\u9891\u7e41\u66f4\u65b0\u7684\u6570\u636e\uff1b\u4e8c\u5206\u67e5\u627e\u9002\u7528\u4e8e\u5927\u578b\u3001\u6392\u5e8f\u7684\u6570\u636e\uff1b\u54c8\u5e0c\u67e5\u627e\u9002\u5408\u5bf9\u67e5\u8be2\u6548\u7387\u8981\u6c42\u8f83\u9ad8\u4e14\u65e0\u9700\u8303\u56f4\u67e5\u8be2\u7684\u6570\u636e\uff1b\u6811\u67e5\u627e\u9002\u7528\u4e8e\u9700\u8981\u7ef4\u62a4\u987a\u5e8f\u548c\u652f\u6301\u8303\u56f4\u67e5\u8be2\u7684\u5927\u578b\u52a8\u6001\u6570\u636e\u3002
    • \u7528\u54c8\u5e0c\u67e5\u627e\u66ff\u6362\u7ebf\u6027\u67e5\u627e\u662f\u4e00\u79cd\u5e38\u7528\u7684\u4f18\u5316\u8fd0\u884c\u65f6\u95f4\u7684\u7b56\u7565\uff0c\u53ef\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n)\\) \u964d\u4f4e\u81f3 \\(O(1)\\) \u3002
    "},{"location":"chapter_sorting/","title":"11. \u00a0 \u6392\u5e8f","text":""},{"location":"chapter_sorting/bubble_sort/","title":"11.3. \u00a0 \u5192\u6ce1\u6392\u5e8f","text":"

    \u300c\u5192\u6ce1\u6392\u5e8f Bubble Sort\u300d\u901a\u8fc7\u8fde\u7eed\u5730\u6bd4\u8f83\u4e0e\u4ea4\u6362\u76f8\u90bb\u5143\u7d20\u5b9e\u73b0\u6392\u5e8f\u3002\u8fd9\u4e2a\u8fc7\u7a0b\u5c31\u50cf\u6c14\u6ce1\u4ece\u5e95\u90e8\u5347\u5230\u9876\u90e8\u4e00\u6837\uff0c\u56e0\u6b64\u5f97\u540d\u5192\u6ce1\u6392\u5e8f\u3002

    \u6211\u4eec\u53ef\u4ee5\u5229\u7528\u5143\u7d20\u4ea4\u6362\u64cd\u4f5c\u6a21\u62df\u4e0a\u8ff0\u8fc7\u7a0b\uff1a\u4ece\u6570\u7ec4\u6700\u5de6\u7aef\u5f00\u59cb\u5411\u53f3\u904d\u5386\uff0c\u4f9d\u6b21\u6bd4\u8f83\u76f8\u90bb\u5143\u7d20\u5927\u5c0f\uff0c\u5982\u679c\u201c\u5de6\u5143\u7d20 > \u53f3\u5143\u7d20\u201d\u5c31\u4ea4\u6362\u5b83\u4fe9\u3002\u904d\u5386\u5b8c\u6210\u540e\uff0c\u6700\u5927\u7684\u5143\u7d20\u4f1a\u88ab\u79fb\u52a8\u5230\u6570\u7ec4\u7684\u6700\u53f3\u7aef\u3002

    <1><2><3><4><5><6><7>

    "},{"location":"chapter_sorting/bubble_sort/#1131","title":"11.3.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u8bbe\u6570\u7ec4\u7684\u957f\u5ea6\u4e3a \\(n\\) \uff0c\u5192\u6ce1\u6392\u5e8f\u7684\u6b65\u9aa4\u4e3a\uff1a

    1. \u9996\u5148\uff0c\u5bf9 \\(n\\) \u4e2a\u5143\u7d20\u6267\u884c\u201c\u5192\u6ce1\u201d\uff0c\u5c06\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u6b63\u786e\u4f4d\u7f6e\uff0c
    2. \u63a5\u4e0b\u6765\uff0c\u5bf9\u5269\u4f59 \\(n - 1\\) \u4e2a\u5143\u7d20\u6267\u884c\u201c\u5192\u6ce1\u201d\uff0c\u5c06\u7b2c\u4e8c\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u6b63\u786e\u4f4d\u7f6e\u3002
    3. \u4ee5\u6b64\u7c7b\u63a8\uff0c\u7ecf\u8fc7 \\(n - 1\\) \u8f6e\u201c\u5192\u6ce1\u201d\u540e\uff0c\u524d \\(n - 1\\) \u5927\u7684\u5143\u7d20\u90fd\u88ab\u4ea4\u6362\u81f3\u6b63\u786e\u4f4d\u7f6e\u3002
    4. \u4ec5\u5269\u7684\u4e00\u4e2a\u5143\u7d20\u5fc5\u5b9a\u662f\u6700\u5c0f\u5143\u7d20\uff0c\u65e0\u9700\u6392\u5e8f\uff0c\u56e0\u6b64\u6570\u7ec4\u6392\u5e8f\u5b8c\u6210\u3002

    Fig. \u5192\u6ce1\u6392\u5e8f\u6d41\u7a0b

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart bubble_sort.java
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    bubble_sort.cpp
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(vector<int> &nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.size() - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n// \u8fd9\u91cc\u4f7f\u7528\u4e86 std::swap() \u51fd\u6570\nswap(nums[j], nums[j + 1]);\n}\n}\n}\n}\n
    bubble_sort.py
    def bubble_sort(nums: list[int]) -> None:\n\"\"\"\u5192\u6ce1\u6392\u5e8f\"\"\"\nn = len(nums)\n# \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in range(n - 1, 0, -1):\n# \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor j in range(i):\nif nums[j] > nums[j + 1]:\n# \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nnums[j], nums[j + 1] = nums[j + 1], nums[j]\n
    bubble_sort.go
    /* \u5192\u6ce1\u6392\u5e8f */\nfunc bubbleSort(nums []int) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i := len(nums) - 1; i > 0; i-- {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef\nfor j := 0; j < i; j++ {\nif nums[j] > nums[j+1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nnums[j], nums[j+1] = nums[j+1], nums[j]\n}\n}\n}\n}\n
    bubble_sort.js
    /* \u5192\u6ce1\u6392\u5e8f */\nfunction bubbleSort(nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    bubble_sort.ts
    /* \u5192\u6ce1\u6392\u5e8f */\nfunction bubbleSort(nums: number[]): void {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    bubble_sort.c
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(int nums[], int size) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = 0; i < size - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < size - 1 - i; j++) {\nif (nums[j] > nums[j + 1]) {\nint temp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = temp;\n}\n}\n}\n}\n
    bubble_sort.cs
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.Length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    bubble_sort.swift
    /* \u5192\u6ce1\u6392\u5e8f */\nfunc bubbleSort(nums: inout [Int]) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in stride(from: nums.count - 1, to: 0, by: -1) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor j in stride(from: 0, to: i, by: 1) {\nif nums[j] > nums[j + 1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j]\nnums[j] = nums[j + 1]\nnums[j + 1] = tmp\n}\n}\n}\n}\n
    bubble_sort.zig
    // \u5192\u6ce1\u6392\u5e8f\nfn bubbleSort(nums: []i32) void {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nvar i: usize = nums.len - 1;\nwhile (i > 0) : (i -= 1) {\nvar j: usize = 0;\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nwhile (j < i) : (j += 1) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nvar tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    bubble_sort.dart
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(List<int> nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.length - 1; i > 0; i--) {\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\n}\n}\n}\n}\n
    "},{"location":"chapter_sorting/bubble_sort/#1132","title":"11.3.2. \u00a0 \u6548\u7387\u4f18\u5316","text":"

    \u6211\u4eec\u53d1\u73b0\uff0c\u5982\u679c\u67d0\u8f6e\u201c\u5192\u6ce1\u201d\u4e2d\u6ca1\u6709\u6267\u884c\u4efb\u4f55\u4ea4\u6362\u64cd\u4f5c\uff0c\u8bf4\u660e\u6570\u7ec4\u5df2\u7ecf\u5b8c\u6210\u6392\u5e8f\uff0c\u53ef\u76f4\u63a5\u8fd4\u56de\u7ed3\u679c\u3002\u56e0\u6b64\uff0c\u53ef\u4ee5\u589e\u52a0\u4e00\u4e2a\u6807\u5fd7\u4f4d flag \u6765\u76d1\u6d4b\u8fd9\u79cd\u60c5\u51b5\uff0c\u4e00\u65e6\u51fa\u73b0\u5c31\u7acb\u5373\u8fd4\u56de\u3002

    \u7ecf\u8fc7\u4f18\u5316\uff0c\u5192\u6ce1\u6392\u5e8f\u7684\u6700\u5dee\u548c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(n^2)\\) \uff1b\u4f46\u5f53\u8f93\u5165\u6570\u7ec4\u5b8c\u5168\u6709\u5e8f\u65f6\uff0c\u53ef\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart bubble_sort.java
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09 */\nvoid bubbleSortWithFlag(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.length - 1; i > 0; i--) {\nboolean flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag)\nbreak; // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.cpp
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nvoid bubbleSortWithFlag(vector<int> &nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.size() - 1; i > 0; i--) {\nbool flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n// \u8fd9\u91cc\u4f7f\u7528\u4e86 std::swap() \u51fd\u6570\nswap(nums[j], nums[j + 1]);\nflag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag)\nbreak; // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.py
    def bubble_sort_with_flag(nums: list[int]) -> None:\n\"\"\"\u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09\"\"\"\nn = len(nums)\n# \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in range(n - 1, 0, -1):\nflag = False  # \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n# \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor j in range(i):\nif nums[j] > nums[j + 1]:\n# \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nnums[j], nums[j + 1] = nums[j + 1], nums[j]\nflag = True  # \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\nif not flag:\nbreak  # \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n
    bubble_sort.go
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nfunc bubbleSortWithFlag(nums []int) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i := len(nums) - 1; i > 0; i-- {\nflag := false // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef\nfor j := 0; j < i; j++ {\nif nums[j] > nums[j+1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nnums[j], nums[j+1] = nums[j+1], nums[j]\nflag = true // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif flag == false { // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\nbreak\n}\n}\n}\n
    bubble_sort.js
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nfunction bubbleSortWithFlag(nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\nlet flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag) break; // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.ts
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nfunction bubbleSortWithFlag(nums: number[]): void {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (let i = nums.length - 1; i > 0; i--) {\nlet flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (let j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag) break; // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.c
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nvoid bubbleSortWithFlag(int nums[], int size) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = 0; i < size - 1; i++) {\nbool flag = false;\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < size - 1 - i; j++) {\nif (nums[j] > nums[j + 1]) {\nint temp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = temp;\nflag = true;\n}\n}\nif (!flag)\nbreak;\n}\n}\n
    bubble_sort.cs
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nvoid bubbleSortWithFlag(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.Length - 1; i > 0; i--) {\nbool flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true;  // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag) break;     // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.swift
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nfunc bubbleSortWithFlag(nums: inout [Int]) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i in stride(from: nums.count - 1, to: 0, by: -1) {\nvar flag = false // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\nfor j in stride(from: 0, to: i, by: 1) {\nif nums[j] > nums[j + 1] {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nlet tmp = nums[j]\nnums[j] = nums[j + 1]\nnums[j + 1] = tmp\nflag = true // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif !flag { // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\nbreak\n}\n}\n}\n
    bubble_sort.zig
    // \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09\nfn bubbleSortWithFlag(nums: []i32) void {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nvar i: usize = nums.len - 1;\nwhile (i > 0) : (i -= 1) {\nvar flag = false;   // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\nvar j: usize = 0;\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nwhile (j < i) : (j += 1) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nvar tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true;\n}\n}\nif (!flag) break;   // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    bubble_sort.dart
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09*/\nvoid bubbleSortWithFlag(List<int> nums) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor (int i = nums.length - 1; i > 0; i--) {\nbool flag = false; // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n// \u5185\u5faa\u73af\uff1a\u5c06\u672a\u6392\u5e8f\u533a\u95f4 [0, i] \u4e2d\u7684\u6700\u5927\u5143\u7d20\u4ea4\u6362\u81f3\u8be5\u533a\u95f4\u7684\u6700\u53f3\u7aef \nfor (int j = 0; j < i; j++) {\nif (nums[j] > nums[j + 1]) {\n// \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\nint tmp = nums[j];\nnums[j] = nums[j + 1];\nnums[j + 1] = tmp;\nflag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n}\n}\nif (!flag) break; // \u6b64\u8f6e\u5192\u6ce1\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n}\n}\n
    "},{"location":"chapter_sorting/bubble_sort/#1133","title":"11.3.3. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3001\u81ea\u9002\u5e94\u6392\u5e8f \uff1a\u5404\u8f6e\u201c\u5192\u6ce1\u201d\u904d\u5386\u7684\u6570\u7ec4\u957f\u5ea6\u4f9d\u6b21\u4e3a \\(n - 1\\) , \\(n - 2\\) , \\(\\cdots\\) , \\(2\\) , \\(1\\) \uff0c\u603b\u548c\u4e3a \\(\\frac{(n - 1) n}{2}\\) \u3002\u5728\u5f15\u5165 flag \u4f18\u5316\u540e\uff0c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u8fbe\u5230 \\(O(n)\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3001\u539f\u5730\u6392\u5e8f\uff1a\u6307\u9488 \\(i\\) , \\(j\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u7a33\u5b9a\u6392\u5e8f\uff1a\u7531\u4e8e\u5728\u201c\u5192\u6ce1\u201d\u4e2d\u9047\u5230\u76f8\u7b49\u5143\u7d20\u4e0d\u4ea4\u6362\u3002
    "},{"location":"chapter_sorting/bucket_sort/","title":"11.8. \u00a0 \u6876\u6392\u5e8f","text":"

    \u524d\u8ff0\u7684\u51e0\u79cd\u6392\u5e8f\u7b97\u6cd5\u90fd\u5c5e\u4e8e\u201c\u57fa\u4e8e\u6bd4\u8f83\u7684\u6392\u5e8f\u7b97\u6cd5\u201d\uff0c\u5b83\u4eec\u901a\u8fc7\u6bd4\u8f83\u5143\u7d20\u95f4\u7684\u5927\u5c0f\u6765\u5b9e\u73b0\u6392\u5e8f\u3002\u6b64\u7c7b\u6392\u5e8f\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u65e0\u6cd5\u8d85\u8d8a \\(O(n \\log n)\\) \u3002\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c06\u63a2\u8ba8\u51e0\u79cd\u201c\u975e\u6bd4\u8f83\u6392\u5e8f\u7b97\u6cd5\u201d\uff0c\u5b83\u4eec\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u8fbe\u5230\u7ebf\u6027\u6c34\u5e73\u3002

    \u300c\u6876\u6392\u5e8f Bucket Sort\u300d\u662f\u5206\u6cbb\u601d\u60f3\u7684\u4e00\u4e2a\u5178\u578b\u5e94\u7528\u3002\u5b83\u901a\u8fc7\u8bbe\u7f6e\u4e00\u4e9b\u5177\u6709\u5927\u5c0f\u987a\u5e8f\u7684\u6876\uff0c\u6bcf\u4e2a\u6876\u5bf9\u5e94\u4e00\u4e2a\u6570\u636e\u8303\u56f4\uff0c\u5c06\u6570\u636e\u5e73\u5747\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\uff1b\u7136\u540e\uff0c\u5728\u6bcf\u4e2a\u6876\u5185\u90e8\u5206\u522b\u6267\u884c\u6392\u5e8f\uff1b\u6700\u7ec8\u6309\u7167\u6876\u7684\u987a\u5e8f\u5c06\u6240\u6709\u6570\u636e\u5408\u5e76\u3002

    "},{"location":"chapter_sorting/bucket_sort/#1181","title":"11.8.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u8003\u8651\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4\uff0c\u5143\u7d20\u662f\u8303\u56f4 \\([0, 1)\\) \u7684\u6d6e\u70b9\u6570\u3002\u6876\u6392\u5e8f\u7684\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u521d\u59cb\u5316 \\(k\\) \u4e2a\u6876\uff0c\u5c06 \\(n\\) \u4e2a\u5143\u7d20\u5206\u914d\u5230 \\(k\\) \u4e2a\u6876\u4e2d\uff1b
    2. \u5bf9\u6bcf\u4e2a\u6876\u5206\u522b\u6267\u884c\u6392\u5e8f\uff08\u672c\u6587\u91c7\u7528\u7f16\u7a0b\u8bed\u8a00\u7684\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff09\uff1b
    3. \u6309\u7167\u6876\u7684\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\uff0c\u5408\u5e76\u7ed3\u679c\uff1b

    Fig. \u6876\u6392\u5e8f\u7b97\u6cd5\u6d41\u7a0b

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart bucket_sort.java
    /* \u6876\u6392\u5e8f */\nvoid bucketSort(float[] nums) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nint k = nums.length / 2;\nList<List<Float>> buckets = new ArrayList<>();\nfor (int i = 0; i < k; i++) {\nbuckets.add(new ArrayList<>());\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (float num : nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nint i = (int) (num * k);\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets.get(i).add(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (List<Float> bucket : buckets) {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nCollections.sort(bucket);\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nint i = 0;\nfor (List<Float> bucket : buckets) {\nfor (float num : bucket) {\nnums[i++] = num;\n}\n}\n}\n
    bucket_sort.cpp
    /* \u6876\u6392\u5e8f */\nvoid bucketSort(vector<float> &nums) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nint k = nums.size() / 2;\nvector<vector<float>> buckets(k);\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (float num : nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nint i = num * k;\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 bucket_idx\nbuckets[i].push_back(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (vector<float> &bucket : buckets) {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nsort(bucket.begin(), bucket.end());\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nint i = 0;\nfor (vector<float> &bucket : buckets) {\nfor (float num : bucket) {\nnums[i++] = num;\n}\n}\n}\n
    bucket_sort.py
    def bucket_sort(nums: list[float]) -> None:\n\"\"\"\u6876\u6392\u5e8f\"\"\"\n# \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nk = len(nums) // 2\nbuckets = [[] for _ in range(k)]\n# 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor num in nums:\n# \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\ni = int(num * k)\n# \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i].append(num)\n# 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor bucket in buckets:\n# \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nbucket.sort()\n# 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\ni = 0\nfor bucket in buckets:\nfor num in bucket:\nnums[i] = num\ni += 1\n
    bucket_sort.go
    /* \u6876\u6392\u5e8f */\nfunc bucketSort(nums []float64) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nk := len(nums) / 2\nbuckets := make([][]float64, k)\nfor i := 0; i < k; i++ {\nbuckets[i] = make([]float64, 0)\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor _, num := range nums {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\ni := int(num * float64(k))\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i] = append(buckets[i], num)\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor i := 0; i < k; i++ {\n// \u4f7f\u7528\u5185\u7f6e\u5207\u7247\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nsort.Float64s(buckets[i])\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\ni := 0\nfor _, bucket := range buckets {\nfor _, num := range bucket {\nnums[i] = num\ni++\n}\n}\n}\n
    bucket_sort.js
    /* \u6876\u6392\u5e8f */\nfunction bucketSort(nums) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nconst k = nums.length / 2;\nconst buckets = [];\nfor (let i = 0; i < k; i++) {\nbuckets.push([]);\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (const num of nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nconst i = Math.floor(num * k);\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i].push(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (const bucket of buckets) {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nbucket.sort((a, b) => a - b);\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nlet i = 0;\nfor (const bucket of buckets) {\nfor (const num of bucket) {\nnums[i++] = num;\n}\n}\n}\n
    bucket_sort.ts
    /* \u6876\u6392\u5e8f */\nfunction bucketSort(nums: number[]): void {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nconst k = nums.length / 2;\nconst buckets: number[][] = [];\nfor (let i = 0; i < k; i++) {\nbuckets.push([]);\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (const num of nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nconst i = Math.floor(num * k);\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i].push(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (const bucket of buckets) {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nbucket.sort((a, b) => a - b);\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nlet i = 0;\nfor (const bucket of buckets) {\nfor (const num of bucket) {\nnums[i++] = num;\n}\n}\n}\n
    bucket_sort.c
    /* \u6876\u6392\u5e8f */\nvoid bucketSort(float nums[], int size) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nint k = size / 2;\nfloat **buckets = calloc(k, sizeof(float *));\nfor (int i = 0; i < k; i++) {\n// \u6bcf\u4e2a\u6876\u6700\u591a\u53ef\u4ee5\u5206\u914d k \u4e2a\u5143\u7d20\nbuckets[i] = calloc(ARRAY_SIZE, sizeof(float));\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (int i = 0; i < size; i++) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nint bucket_idx = nums[i] * k;\nint j = 0;\n// \u5982\u679c\u6876\u4e2d\u6709\u6570\u636e\u4e14\u6570\u636e\u5c0f\u4e8e\u5f53\u524d\u503c nums[i], \u8981\u5c06\u5176\u653e\u5230\u5f53\u524d\u6876\u7684\u540e\u9762\uff0c\u76f8\u5f53\u4e8e cpp \u4e2d\u7684 push_back\nwhile (buckets[bucket_idx][j] > 0 && buckets[bucket_idx][j] < nums[i]) {\nj++;\n}\nfloat temp = nums[i];\nwhile (j < ARRAY_SIZE && buckets[bucket_idx][j] > 0) {\nswap(&temp, &buckets[bucket_idx][j]);\nj++;\n}\nbuckets[bucket_idx][j] = temp;\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (int i = 0; i < k; i++) {\nqsort(buckets[i], ARRAY_SIZE, sizeof(float), compare_float);\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nfor (int i = 0, j = 0; j < k; j++) {\nfor (int l = 0; l < ARRAY_SIZE; l++) {\nif (buckets[j][l] > 0) {\nnums[i++] = buckets[j][l];\n}\n}\n}\n// \u91ca\u653e\u4e0a\u8ff0\u5206\u914d\u7684\u5185\u5b58\nfor (int i = 0; i < k; i++) {\nfree(buckets[i]);\n}\nfree(buckets);\n}\n
    bucket_sort.cs
    /* \u6876\u6392\u5e8f */\nvoid bucketSort(float[] nums) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nint k = nums.Length / 2;\nList<List<float>> buckets = new List<List<float>>();\nfor (int i = 0; i < k; i++) {\nbuckets.Add(new List<float>());\n}\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nforeach (float num in nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nint i = (int) (num * k);\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i].Add(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nforeach (List<float> bucket in buckets) {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nbucket.Sort();\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nint j = 0;\nforeach (List<float> bucket in buckets) {\nforeach (float num in bucket) {\nnums[j++] = num;\n}\n}\n}\n
    bucket_sort.swift
    /* \u6876\u6392\u5e8f */\nfunc bucketSort(nums: inout [Double]) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nlet k = nums.count / 2\nvar buckets = (0 ..< k).map { _ in [Double]() }\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor num in nums {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nlet i = Int(num * Double(k))\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\nbuckets[i].append(num)\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor i in buckets.indices {\n// \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\nbuckets[i].sort()\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nvar i = nums.startIndex\nfor bucket in buckets {\nfor num in bucket {\nnums[i] = num\nnums.formIndex(after: &i)\n}\n}\n}\n
    bucket_sort.zig
    [class]{}-[func]{bucketSort}\n
    bucket_sort.dart
    /* \u6876\u6392\u5e8f */\nvoid bucketSort(List<double> nums) {\n// \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\nint k = nums.length ~/ 2;\nList<List<double>> buckets = List.generate(k, (index) => []);\n// 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\nfor (double num in nums) {\n// \u8f93\u5165\u6570\u636e\u8303\u56f4 [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\nint i = (num * k).toInt();\n// \u5c06 num \u6dfb\u52a0\u8fdb\u6876 bucket_idx\nbuckets[i].add(num);\n}\n// 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\nfor (List<double> bucket in buckets) {\nbucket.sort();\n}\n// 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\nint i = 0;\nfor (List<double> bucket in buckets) {\nfor (double num in bucket) {\nnums[i++] = num;\n}\n}\n}\n

    \u6876\u6392\u5e8f\u7684\u9002\u7528\u573a\u666f\u662f\u4ec0\u4e48\uff1f

    \u6876\u6392\u5e8f\u9002\u7528\u4e8e\u5904\u7406\u4f53\u91cf\u5f88\u5927\u7684\u6570\u636e\u3002\u4f8b\u5982\uff0c\u8f93\u5165\u6570\u636e\u5305\u542b 100 \u4e07\u4e2a\u5143\u7d20\uff0c\u7531\u4e8e\u7a7a\u95f4\u9650\u5236\uff0c\u7cfb\u7edf\u5185\u5b58\u65e0\u6cd5\u4e00\u6b21\u6027\u52a0\u8f7d\u6240\u6709\u6570\u636e\u3002\u6b64\u65f6\uff0c\u53ef\u4ee5\u5c06\u6570\u636e\u5206\u6210 1000 \u4e2a\u6876\uff0c\u7136\u540e\u5206\u522b\u5bf9\u6bcf\u4e2a\u6876\u8fdb\u884c\u6392\u5e8f\uff0c\u6700\u540e\u5c06\u7ed3\u679c\u5408\u5e76\u3002

    "},{"location":"chapter_sorting/bucket_sort/#1182","title":"11.8.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n + k)\\) \uff1a\u5047\u8bbe\u5143\u7d20\u5728\u5404\u4e2a\u6876\u5185\u5e73\u5747\u5206\u5e03\uff0c\u90a3\u4e48\u6bcf\u4e2a\u6876\u5185\u7684\u5143\u7d20\u6570\u91cf\u4e3a \\(\\frac{n}{k}\\) \u3002\u5047\u8bbe\u6392\u5e8f\u5355\u4e2a\u6876\u4f7f\u7528 \\(O(\\frac{n}{k} \\log\\frac{n}{k})\\) \u65f6\u95f4\uff0c\u5219\u6392\u5e8f\u6240\u6709\u6876\u4f7f\u7528 \\(O(n \\log\\frac{n}{k})\\) \u65f6\u95f4\u3002\u5f53\u6876\u6570\u91cf \\(k\\) \u6bd4\u8f83\u5927\u65f6\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u5219\u8d8b\u5411\u4e8e \\(O(n)\\) \u3002\u5408\u5e76\u7ed3\u679c\u65f6\u9700\u8981\u904d\u5386 \\(n\\) \u4e2a\u6876\uff0c\u82b1\u8d39 \\(O(k)\\) \u65f6\u95f4\u3002
    • \u81ea\u9002\u5e94\u6392\u5e8f\uff1a\u5728\u6700\u574f\u60c5\u51b5\u4e0b\uff0c\u6240\u6709\u6570\u636e\u88ab\u5206\u914d\u5230\u4e00\u4e2a\u6876\u4e2d\uff0c\u4e14\u6392\u5e8f\u8be5\u6876\u4f7f\u7528 \\(O(n^2)\\) \u65f6\u95f4\u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(n + k)\\) \u3001\u975e\u539f\u5730\u6392\u5e8f \uff1a\u9700\u8981\u501f\u52a9 \\(k\\) \u4e2a\u6876\u548c\u603b\u5171 \\(n\\) \u4e2a\u5143\u7d20\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u6876\u6392\u5e8f\u662f\u5426\u7a33\u5b9a\u53d6\u51b3\u4e8e\u6392\u5e8f\u6876\u5185\u5143\u7d20\u7684\u7b97\u6cd5\u662f\u5426\u7a33\u5b9a\u3002
    "},{"location":"chapter_sorting/bucket_sort/#1183","title":"11.8.3. \u00a0 \u5982\u4f55\u5b9e\u73b0\u5e73\u5747\u5206\u914d","text":"

    \u6876\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u7406\u8bba\u4e0a\u53ef\u4ee5\u8fbe\u5230 \\(O(n)\\) \uff0c\u5173\u952e\u5728\u4e8e\u5c06\u5143\u7d20\u5747\u5300\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\uff0c\u56e0\u4e3a\u5b9e\u9645\u6570\u636e\u5f80\u5f80\u4e0d\u662f\u5747\u5300\u5206\u5e03\u7684\u3002\u4f8b\u5982\uff0c\u6211\u4eec\u60f3\u8981\u5c06\u6dd8\u5b9d\u4e0a\u7684\u6240\u6709\u5546\u54c1\u6309\u4ef7\u683c\u8303\u56f4\u5e73\u5747\u5206\u914d\u5230 10 \u4e2a\u6876\u4e2d\uff0c\u4f46\u5546\u54c1\u4ef7\u683c\u5206\u5e03\u4e0d\u5747\uff0c\u4f4e\u4e8e 100 \u5143\u7684\u975e\u5e38\u591a\uff0c\u9ad8\u4e8e 1000 \u5143\u7684\u975e\u5e38\u5c11\u3002\u82e5\u5c06\u4ef7\u683c\u533a\u95f4\u5e73\u5747\u5212\u5206\u4e3a 10 \u4efd\uff0c\u5404\u4e2a\u6876\u4e2d\u7684\u5546\u54c1\u6570\u91cf\u5dee\u8ddd\u4f1a\u975e\u5e38\u5927\u3002

    \u4e3a\u5b9e\u73b0\u5e73\u5747\u5206\u914d\uff0c\u6211\u4eec\u53ef\u4ee5\u5148\u8bbe\u5b9a\u4e00\u4e2a\u5927\u81f4\u7684\u5206\u754c\u7ebf\uff0c\u5c06\u6570\u636e\u7c97\u7565\u5730\u5206\u5230 3 \u4e2a\u6876\u4e2d\u3002\u5206\u914d\u5b8c\u6bd5\u540e\uff0c\u518d\u5c06\u5546\u54c1\u8f83\u591a\u7684\u6876\u7ee7\u7eed\u5212\u5206\u4e3a 3 \u4e2a\u6876\uff0c\u76f4\u81f3\u6240\u6709\u6876\u4e2d\u7684\u5143\u7d20\u6570\u91cf\u5927\u81f4\u76f8\u7b49\u3002\u8fd9\u79cd\u65b9\u6cd5\u672c\u8d28\u4e0a\u662f\u521b\u5efa\u4e00\u4e2a\u9012\u5f52\u6811\uff0c\u4f7f\u53f6\u8282\u70b9\u7684\u503c\u5c3d\u53ef\u80fd\u5e73\u5747\u3002\u5f53\u7136\uff0c\u4e0d\u4e00\u5b9a\u8981\u6bcf\u8f6e\u5c06\u6570\u636e\u5212\u5206\u4e3a 3 \u4e2a\u6876\uff0c\u5177\u4f53\u5212\u5206\u65b9\u5f0f\u53ef\u6839\u636e\u6570\u636e\u7279\u70b9\u7075\u6d3b\u9009\u62e9\u3002

    Fig. \u9012\u5f52\u5212\u5206\u6876

    \u5982\u679c\u6211\u4eec\u63d0\u524d\u77e5\u9053\u5546\u54c1\u4ef7\u683c\u7684\u6982\u7387\u5206\u5e03\uff0c\u5219\u53ef\u4ee5\u6839\u636e\u6570\u636e\u6982\u7387\u5206\u5e03\u8bbe\u7f6e\u6bcf\u4e2a\u6876\u7684\u4ef7\u683c\u5206\u754c\u7ebf\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u6570\u636e\u5206\u5e03\u5e76\u4e0d\u4e00\u5b9a\u9700\u8981\u7279\u610f\u7edf\u8ba1\uff0c\u4e5f\u53ef\u4ee5\u6839\u636e\u6570\u636e\u7279\u70b9\u91c7\u7528\u67d0\u79cd\u6982\u7387\u6a21\u578b\u8fdb\u884c\u8fd1\u4f3c\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u6211\u4eec\u5047\u8bbe\u5546\u54c1\u4ef7\u683c\u670d\u4ece\u6b63\u6001\u5206\u5e03\uff0c\u8fd9\u6837\u5c31\u53ef\u4ee5\u5408\u7406\u5730\u8bbe\u5b9a\u4ef7\u683c\u533a\u95f4\uff0c\u4ece\u800c\u5c06\u5546\u54c1\u5e73\u5747\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\u3002

    Fig. \u6839\u636e\u6982\u7387\u5206\u5e03\u5212\u5206\u6876

    "},{"location":"chapter_sorting/counting_sort/","title":"11.9. \u00a0 \u8ba1\u6570\u6392\u5e8f","text":"

    \u300c\u8ba1\u6570\u6392\u5e8f Counting Sort\u300d\u901a\u8fc7\u7edf\u8ba1\u5143\u7d20\u6570\u91cf\u6765\u5b9e\u73b0\u6392\u5e8f\uff0c\u901a\u5e38\u5e94\u7528\u4e8e\u6574\u6570\u6570\u7ec4\u3002

    "},{"location":"chapter_sorting/counting_sort/#1191","title":"11.9.1. \u00a0 \u7b80\u5355\u5b9e\u73b0","text":"

    \u5148\u6765\u770b\u4e00\u4e2a\u7b80\u5355\u7684\u4f8b\u5b50\u3002\u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4 nums \uff0c\u5176\u4e2d\u7684\u5143\u7d20\u90fd\u662f\u201c\u975e\u8d1f\u6574\u6570\u201d\u3002\u8ba1\u6570\u6392\u5e8f\u7684\u6574\u4f53\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u904d\u5386\u6570\u7ec4\uff0c\u627e\u51fa\u6570\u7ec4\u4e2d\u7684\u6700\u5927\u6570\u5b57\uff0c\u8bb0\u4e3a \\(m\\) \uff0c\u7136\u540e\u521b\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(m + 1\\) \u7684\u8f85\u52a9\u6570\u7ec4 counter \uff1b
    2. \u501f\u52a9 counter \u7edf\u8ba1 nums \u4e2d\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\uff0c\u5176\u4e2d counter[num] \u5bf9\u5e94\u6570\u5b57 num \u7684\u51fa\u73b0\u6b21\u6570\u3002\u7edf\u8ba1\u65b9\u6cd5\u5f88\u7b80\u5355\uff0c\u53ea\u9700\u904d\u5386 nums\uff08\u8bbe\u5f53\u524d\u6570\u5b57\u4e3a num\uff09\uff0c\u6bcf\u8f6e\u5c06 counter[num] \u589e\u52a0 \\(1\\) \u5373\u53ef\u3002
    3. \u7531\u4e8e counter \u7684\u5404\u4e2a\u7d22\u5f15\u5929\u7136\u6709\u5e8f\uff0c\u56e0\u6b64\u76f8\u5f53\u4e8e\u6240\u6709\u6570\u5b57\u5df2\u7ecf\u88ab\u6392\u5e8f\u597d\u4e86\u3002\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u904d\u5386 counter \uff0c\u6839\u636e\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\uff0c\u5c06\u5b83\u4eec\u6309\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\u586b\u5165 nums \u5373\u53ef\u3002

    Fig. \u8ba1\u6570\u6392\u5e8f\u6d41\u7a0b

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart counting_sort.java
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nvoid countingSortNaive(int[] nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num : nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint[] counter = new int[m + 1];\nfor (int num : nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nint i = 0;\nfor (int num = 0; num < m + 1; num++) {\nfor (int j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.cpp
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nvoid countingSortNaive(vector<int> &nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num : nums) {\nm = max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nvector<int> counter(m + 1, 0);\nfor (int num : nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nint i = 0;\nfor (int num = 0; num < m + 1; num++) {\nfor (int j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.py
    def counting_sort_naive(nums: list[int]) -> None:\n\"\"\"\u8ba1\u6570\u6392\u5e8f\"\"\"\n# \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\n# 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nm = 0\nfor num in nums:\nm = max(m, num)\n# 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n# counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\ncounter = [0] * (m + 1)\nfor num in nums:\ncounter[num] += 1\n# 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\ni = 0\nfor num in range(m + 1):\nfor _ in range(counter[num]):\nnums[i] = num\ni += 1\n
    counting_sort.go
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfunc countingSortNaive(nums []int) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nm := 0\nfor _, num := range nums {\nif num > m {\nm = num\n}\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\ncounter := make([]int, m+1)\nfor _, num := range nums {\ncounter[num]++\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nfor i, num := 0, 0; num < m+1; num++ {\nfor j := 0; j < counter[num]; j++ {\nnums[i] = num\ni++\n}\n}\n}\n
    counting_sort.js
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfunction countingSortNaive(nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = 0;\nfor (const num of nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nconst counter = new Array(m + 1).fill(0);\nfor (const num of nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nlet i = 0;\nfor (let num = 0; num < m + 1; num++) {\nfor (let j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.ts
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfunction countingSortNaive(nums: number[]): void {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = 0;\nfor (const num of nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nconst counter: number[] = new Array<number>(m + 1).fill(0);\nfor (const num of nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nlet i = 0;\nfor (let num = 0; num < m + 1; num++) {\nfor (let j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.c
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nvoid countingSortNaive(int nums[], int size) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int i = 0; i < size; i++) {\nif (nums[i] > m) {\nm = nums[i];\n}\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint *counter = malloc(sizeof(int) * m);\nfor (int i = 0; i < size; i++) {\ncounter[nums[i]]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nint i = 0;\nfor (int num = 0; num < m + 1; num++) {\nfor (int j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.cs
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nvoid countingSortNaive(int[] nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nforeach (int num in nums) {\nm = Math.Max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint[] counter = new int[m + 1];\nforeach (int num in nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nint i = 0;\nfor (int num = 0; num < m + 1; num++) {\nfor (int j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n
    counting_sort.swift
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfunc countingSortNaive(nums: inout [Int]) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = nums.max()!\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nvar counter = Array(repeating: 0, count: m + 1)\nfor num in nums {\ncounter[num] += 1\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nvar i = 0\nfor num in stride(from: 0, to: m + 1, by: 1) {\nfor _ in stride(from: 0, to: counter[num], by: 1) {\nnums[i] = num\ni += 1\n}\n}\n}\n
    counting_sort.zig
    [class]{}-[func]{countingSortNaive}\n
    counting_sort.dart
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nvoid countingSortNaive(List<int> nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num in nums) {\nm = max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nList<int> counter = List.filled(m + 1, 0);\nfor (int num in nums) {\ncounter[num]++;\n}\n// 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\nint i = 0;\nfor (int num = 0; num < m + 1; num++) {\nfor (int j = 0; j < counter[num]; j++, i++) {\nnums[i] = num;\n}\n}\n}\n

    \u8ba1\u6570\u6392\u5e8f\u4e0e\u6876\u6392\u5e8f\u7684\u8054\u7cfb

    \u4ece\u6876\u6392\u5e8f\u7684\u89d2\u5ea6\u770b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u8ba1\u6570\u6392\u5e8f\u4e2d\u7684\u8ba1\u6570\u6570\u7ec4 counter \u7684\u6bcf\u4e2a\u7d22\u5f15\u89c6\u4e3a\u4e00\u4e2a\u6876\uff0c\u5c06\u7edf\u8ba1\u6570\u91cf\u7684\u8fc7\u7a0b\u770b\u4f5c\u662f\u5c06\u5404\u4e2a\u5143\u7d20\u5206\u914d\u5230\u5bf9\u5e94\u7684\u6876\u4e2d\u3002\u672c\u8d28\u4e0a\uff0c\u8ba1\u6570\u6392\u5e8f\u662f\u6876\u6392\u5e8f\u5728\u6574\u578b\u6570\u636e\u4e0b\u7684\u4e00\u4e2a\u7279\u4f8b\u3002

    "},{"location":"chapter_sorting/counting_sort/#1192","title":"11.9.2. \u00a0 \u5b8c\u6574\u5b9e\u73b0","text":"

    \u7ec6\u5fc3\u7684\u540c\u5b66\u53ef\u80fd\u53d1\u73b0\uff0c\u5982\u679c\u8f93\u5165\u6570\u636e\u662f\u5bf9\u8c61\uff0c\u4e0a\u8ff0\u6b65\u9aa4 3. \u5c31\u5931\u6548\u4e86\u3002\u4f8b\u5982\uff0c\u8f93\u5165\u6570\u636e\u662f\u5546\u54c1\u5bf9\u8c61\uff0c\u6211\u4eec\u60f3\u8981\u6309\u7167\u5546\u54c1\u4ef7\u683c\uff08\u7c7b\u7684\u6210\u5458\u53d8\u91cf\uff09\u5bf9\u5546\u54c1\u8fdb\u884c\u6392\u5e8f\uff0c\u800c\u4e0a\u8ff0\u7b97\u6cd5\u53ea\u80fd\u7ed9\u51fa\u4ef7\u683c\u7684\u6392\u5e8f\u7ed3\u679c\u3002

    \u90a3\u4e48\u5982\u4f55\u624d\u80fd\u5f97\u5230\u539f\u6570\u636e\u7684\u6392\u5e8f\u7ed3\u679c\u5462\uff1f\u6211\u4eec\u9996\u5148\u8ba1\u7b97 counter \u7684\u300c\u524d\u7f00\u548c\u300d\u3002\u987e\u540d\u601d\u4e49\uff0c\u7d22\u5f15 i \u5904\u7684\u524d\u7f00\u548c prefix[i] \u7b49\u4e8e\u6570\u7ec4\u524d i \u4e2a\u5143\u7d20\u4e4b\u548c\uff0c\u5373

    \\[ \\text{prefix}[i] = \\sum_{j=0}^i \\text{counter[j]} \\]

    \u524d\u7f00\u548c\u5177\u6709\u660e\u786e\u7684\u610f\u4e49\uff0cprefix[num] - 1 \u4ee3\u8868\u5143\u7d20 num \u5728\u7ed3\u679c\u6570\u7ec4 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\u3002\u8fd9\u4e2a\u4fe1\u606f\u975e\u5e38\u5173\u952e\uff0c\u56e0\u4e3a\u5b83\u544a\u8bc9\u6211\u4eec\u5404\u4e2a\u5143\u7d20\u5e94\u8be5\u51fa\u73b0\u5728\u7ed3\u679c\u6570\u7ec4\u7684\u54ea\u4e2a\u4f4d\u7f6e\u3002\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5012\u5e8f\u904d\u5386\u539f\u6570\u7ec4 nums \u7684\u6bcf\u4e2a\u5143\u7d20 num \uff0c\u5728\u6bcf\u8f6e\u8fed\u4ee3\u4e2d\u6267\u884c\uff1a

    1. \u5c06 num \u586b\u5165\u6570\u7ec4 res \u7684\u7d22\u5f15 prefix[num] - 1 \u5904\uff1b
    2. \u4ee4\u524d\u7f00\u548c prefix[num] \u51cf\u5c0f \\(1\\) \uff0c\u4ece\u800c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\uff1b

    \u904d\u5386\u5b8c\u6210\u540e\uff0c\u6570\u7ec4 res \u4e2d\u5c31\u662f\u6392\u5e8f\u597d\u7684\u7ed3\u679c\uff0c\u6700\u540e\u4f7f\u7528 res \u8986\u76d6\u539f\u6570\u7ec4 nums \u5373\u53ef\u3002

    <1><2><3><4><5><6><7><8>

    \u8ba1\u6570\u6392\u5e8f\u7684\u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart counting_sort.java
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nvoid countingSort(int[] nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num : nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint[] counter = new int[m + 1];\nfor (int num : nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (int i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nint n = nums.length;\nint[] res = new int[n];\nfor (int i = n - 1; i >= 0; i--) {\nint num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--; // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n
    counting_sort.cpp
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nvoid countingSort(vector<int> &nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num : nums) {\nm = max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nvector<int> counter(m + 1, 0);\nfor (int num : nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (int i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nint n = nums.size();\nvector<int> res(n);\nfor (int i = n - 1; i >= 0; i--) {\nint num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--;              // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nnums = res;\n}\n
    counting_sort.py
    def counting_sort(nums: list[int]) -> None:\n\"\"\"\u8ba1\u6570\u6392\u5e8f\"\"\"\n# \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\n# 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nm = max(nums)\n# 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n# counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\ncounter = [0] * (m + 1)\nfor num in nums:\ncounter[num] += 1\n# 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n# \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor i in range(m):\ncounter[i + 1] += counter[i]\n# 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n# \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nn = len(nums)\nres = [0] * n\nfor i in range(n - 1, -1, -1):\nnum = nums[i]\nres[counter[num] - 1] = num  # \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num] -= 1  # \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n# \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor i in range(n):\nnums[i] = res[i]\n
    counting_sort.go
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfunc countingSort(nums []int) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nm := 0\nfor _, num := range nums {\nif num > m {\nm = num\n}\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\ncounter := make([]int, m+1)\nfor _, num := range nums {\ncounter[num]++\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor i := 0; i < m; i++ {\ncounter[i+1] += counter[i]\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nn := len(nums)\nres := make([]int, n)\nfor i := n - 1; i >= 0; i-- {\nnum := nums[i]\n// \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\nres[counter[num]-1] = num\n// \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\ncounter[num]--\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\ncopy(nums, res)\n}\n
    counting_sort.js
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfunction countingSort(nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = 0;\nfor (const num of nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nconst counter = new Array(m + 1).fill(0);\nfor (const num of nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (let i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nconst n = nums.length;\nconst res = new Array(n);\nfor (let i = n - 1; i >= 0; i--) {\nconst num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--; // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (let i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n
    counting_sort.ts
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfunction countingSort(nums: number[]): void {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = 0;\nfor (const num of nums) {\nm = Math.max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nconst counter: number[] = new Array<number>(m + 1).fill(0);\nfor (const num of nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (let i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nconst n = nums.length;\nconst res: number[] = new Array<number>(n);\nfor (let i = n - 1; i >= 0; i--) {\nconst num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--; // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (let i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n
    counting_sort.c
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nvoid countingSort(int nums[], int size) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int i = 0; i < size; i++) {\nif (nums[i] > m) {\nm = nums[i];\n}\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint *counter = malloc(sizeof(int) * m);\nfor (int i = 0; i < size; i++) {\ncounter[nums[i]]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (int i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nint *res = malloc(sizeof(int) * size);\nfor (int i = size - 1; i >= 0; i--) {\nint num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--;              // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nmemcpy(nums, res, size * sizeof(int));\n}\n
    counting_sort.cs
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nvoid countingSort(int[] nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nforeach (int num in nums) {\nm = Math.Max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nint[] counter = new int[m + 1];\nforeach (int num in nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (int i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nint n = nums.Length;\nint[] res = new int[n];\nfor (int i = n - 1; i >= 0; i--) {\nint num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--; // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n
    counting_sort.swift
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfunc countingSort(nums: inout [Int]) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nlet m = nums.max()!\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nvar counter = Array(repeating: 0, count: m + 1)\nfor num in nums {\ncounter[num] += 1\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor i in stride(from: 0, to: m, by: 1) {\ncounter[i + 1] += counter[i]\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nvar res = Array(repeating: 0, count: nums.count)\nfor i in stride(from: nums.count - 1, through: 0, by: -1) {\nlet num = nums[i]\nres[counter[num] - 1] = num // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num] -= 1 // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nfor i in stride(from: 0, to: nums.count, by: 1) {\nnums[i] = res[i]\n}\n}\n
    counting_sort.zig
    [class]{}-[func]{countingSort}\n
    counting_sort.dart
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nvoid countingSort(List<int> nums) {\n// 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\nint m = 0;\nfor (int num in nums) {\nm = max(m, num);\n}\n// 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n// counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\nList<int> counter = List.filled(m + 1, 0);\nfor (int num in nums) {\ncounter[num]++;\n}\n// 3. \u6c42 counter \u7684\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u6b21\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u5c3e\u7d22\u5f15\u201d\n// \u5373 counter[num]-1 \u662f num \u5728 res \u4e2d\u6700\u540e\u4e00\u6b21\u51fa\u73b0\u7684\u7d22\u5f15\nfor (int i = 0; i < m; i++) {\ncounter[i + 1] += counter[i];\n}\n// 4. \u5012\u5e8f\u904d\u5386 nums \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u7ed3\u679c\u6570\u7ec4 res\n// \u521d\u59cb\u5316\u6570\u7ec4 res \u7528\u4e8e\u8bb0\u5f55\u7ed3\u679c\nint n = nums.length;\nList<int> res = List.filled(n, 0);\nfor (int i = n - 1; i >= 0; i--) {\nint num = nums[i];\nres[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\ncounter[num]--;              // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n}\n// \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\nnums.setAll(0, res);\n}\n
    "},{"location":"chapter_sorting/counting_sort/#1193","title":"11.9.3. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n + m)\\) \uff1a\u6d89\u53ca\u904d\u5386 nums \u548c\u904d\u5386 counter \uff0c\u90fd\u4f7f\u7528\u7ebf\u6027\u65f6\u95f4\u3002\u4e00\u822c\u60c5\u51b5\u4e0b \\(n \\gg m\\) \uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u8d8b\u4e8e \\(O(n)\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(n + m)\\) \u3001\u975e\u539f\u5730\u6392\u5e8f \uff1a\u501f\u52a9\u4e86\u957f\u5ea6\u5206\u522b\u4e3a \\(n\\) \u548c \\(m\\) \u7684\u6570\u7ec4 res \u548c counter \u3002
    • \u7a33\u5b9a\u6392\u5e8f\uff1a\u7531\u4e8e\u5411 res \u4e2d\u586b\u5145\u5143\u7d20\u7684\u987a\u5e8f\u662f\u201c\u4ece\u53f3\u5411\u5de6\u201d\u7684\uff0c\u56e0\u6b64\u5012\u5e8f\u904d\u5386 nums \u53ef\u4ee5\u907f\u514d\u6539\u53d8\u76f8\u7b49\u5143\u7d20\u4e4b\u95f4\u7684\u76f8\u5bf9\u4f4d\u7f6e\uff0c\u4ece\u800c\u5b9e\u73b0\u7a33\u5b9a\u6392\u5e8f\u3002\u5b9e\u9645\u4e0a\uff0c\u6b63\u5e8f\u904d\u5386 nums \u4e5f\u53ef\u4ee5\u5f97\u5230\u6b63\u786e\u7684\u6392\u5e8f\u7ed3\u679c\uff0c\u4f46\u7ed3\u679c\u662f\u975e\u7a33\u5b9a\u7684\u3002
    "},{"location":"chapter_sorting/counting_sort/#1194","title":"11.9.4. \u00a0 \u5c40\u9650\u6027","text":"

    \u770b\u5230\u8fd9\u91cc\uff0c\u4f60\u4e5f\u8bb8\u4f1a\u89c9\u5f97\u8ba1\u6570\u6392\u5e8f\u975e\u5e38\u5de7\u5999\uff0c\u4ec5\u901a\u8fc7\u7edf\u8ba1\u6570\u91cf\u5c31\u53ef\u4ee5\u5b9e\u73b0\u9ad8\u6548\u7684\u6392\u5e8f\u5de5\u4f5c\u3002\u7136\u800c\uff0c\u4f7f\u7528\u8ba1\u6570\u6392\u5e8f\u7684\u524d\u7f6e\u6761\u4ef6\u76f8\u5bf9\u8f83\u4e3a\u4e25\u683c\u3002

    \u8ba1\u6570\u6392\u5e8f\u53ea\u9002\u7528\u4e8e\u975e\u8d1f\u6574\u6570\u3002\u82e5\u60f3\u8981\u5c06\u5176\u7528\u4e8e\u5176\u4ed6\u7c7b\u578b\u7684\u6570\u636e\uff0c\u9700\u8981\u786e\u4fdd\u8fd9\u4e9b\u6570\u636e\u53ef\u4ee5\u88ab\u8f6c\u6362\u4e3a\u975e\u8d1f\u6574\u6570\uff0c\u5e76\u4e14\u5728\u8f6c\u6362\u8fc7\u7a0b\u4e2d\u4e0d\u80fd\u6539\u53d8\u5404\u4e2a\u5143\u7d20\u4e4b\u95f4\u7684\u76f8\u5bf9\u5927\u5c0f\u5173\u7cfb\u3002\u4f8b\u5982\uff0c\u5bf9\u4e8e\u5305\u542b\u8d1f\u6570\u7684\u6574\u6570\u6570\u7ec4\uff0c\u53ef\u4ee5\u5148\u7ed9\u6240\u6709\u6570\u5b57\u52a0\u4e0a\u4e00\u4e2a\u5e38\u6570\uff0c\u5c06\u5168\u90e8\u6570\u5b57\u8f6c\u5316\u4e3a\u6b63\u6570\uff0c\u6392\u5e8f\u5b8c\u6210\u540e\u518d\u8f6c\u6362\u56de\u53bb\u5373\u53ef\u3002

    \u8ba1\u6570\u6392\u5e8f\u9002\u7528\u4e8e\u6570\u636e\u91cf\u5927\u4f46\u6570\u636e\u8303\u56f4\u8f83\u5c0f\u7684\u60c5\u51b5\u3002\u6bd4\u5982\uff0c\u5728\u4e0a\u8ff0\u793a\u4f8b\u4e2d \\(m\\) \u4e0d\u80fd\u592a\u5927\uff0c\u5426\u5219\u4f1a\u5360\u7528\u8fc7\u591a\u7a7a\u95f4\u3002\u800c\u5f53 \\(n \\ll m\\) \u65f6\uff0c\u8ba1\u6570\u6392\u5e8f\u4f7f\u7528 \\(O(m)\\) \u65f6\u95f4\uff0c\u53ef\u80fd\u6bd4 \\(O(n \\log n)\\) \u7684\u6392\u5e8f\u7b97\u6cd5\u8fd8\u8981\u6162\u3002

    "},{"location":"chapter_sorting/heap_sort/","title":"11.7. \u00a0 \u5806\u6392\u5e8f","text":"

    Tip

    \u9605\u8bfb\u672c\u8282\u524d\uff0c\u8bf7\u786e\u4fdd\u5df2\u5b66\u5b8c\u300c\u5806\u300d\u7ae0\u8282\u3002

    \u300c\u5806\u6392\u5e8f Heap Sort\u300d\u662f\u4e00\u79cd\u57fa\u4e8e\u5806\u6570\u636e\u7ed3\u6784\u5b9e\u73b0\u7684\u9ad8\u6548\u6392\u5e8f\u7b97\u6cd5\u3002\u6211\u4eec\u53ef\u4ee5\u5229\u7528\u5df2\u7ecf\u5b66\u8fc7\u7684\u201c\u5efa\u5806\u64cd\u4f5c\u201d\u548c\u201c\u5143\u7d20\u51fa\u5806\u64cd\u4f5c\u201d\u5b9e\u73b0\u5806\u6392\u5e8f\uff1a

    1. \u8f93\u5165\u6570\u7ec4\u5e76\u5efa\u7acb\u5c0f\u9876\u5806\uff0c\u6b64\u65f6\u6700\u5c0f\u5143\u7d20\u4f4d\u4e8e\u5806\u9876\u3002
    2. \u4e0d\u65ad\u6267\u884c\u51fa\u5806\u64cd\u4f5c\uff0c\u4f9d\u6b21\u8bb0\u5f55\u51fa\u5806\u5143\u7d20\uff0c\u5373\u53ef\u5f97\u5230\u4ece\u5c0f\u5230\u5927\u6392\u5e8f\u7684\u5e8f\u5217\u3002

    \u4ee5\u4e0a\u65b9\u6cd5\u867d\u7136\u53ef\u884c\uff0c\u4f46\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u989d\u5916\u6570\u7ec4\u6765\u4fdd\u5b58\u5f39\u51fa\u7684\u5143\u7d20\uff0c\u6bd4\u8f83\u6d6a\u8d39\u7a7a\u95f4\u3002\u5728\u5b9e\u9645\u4e2d\uff0c\u6211\u4eec\u901a\u5e38\u4f7f\u7528\u4e00\u79cd\u66f4\u52a0\u4f18\u96c5\u7684\u5b9e\u73b0\u65b9\u5f0f\u3002

    "},{"location":"chapter_sorting/heap_sort/#1171","title":"11.7.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u8bbe\u6570\u7ec4\u7684\u957f\u5ea6\u4e3a \\(n\\) \uff0c\u5806\u6392\u5e8f\u7684\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u8f93\u5165\u6570\u7ec4\u5e76\u5efa\u7acb\u5927\u9876\u5806\u3002\u5b8c\u6210\u540e\uff0c\u6700\u5927\u5143\u7d20\u4f4d\u4e8e\u5806\u9876\u3002
    2. \u5c06\u5806\u9876\u5143\u7d20\uff08\u7b2c\u4e00\u4e2a\u5143\u7d20\uff09\u4e0e\u5806\u5e95\u5143\u7d20\uff08\u6700\u540e\u4e00\u4e2a\u5143\u7d20\uff09\u4ea4\u6362\u3002\u5b8c\u6210\u4ea4\u6362\u540e\uff0c\u5806\u7684\u957f\u5ea6\u51cf \\(1\\) \uff0c\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u52a0 \\(1\\) \u3002
    3. \u4ece\u5806\u9876\u5143\u7d20\u5f00\u59cb\uff0c\u4ece\u9876\u5230\u5e95\u6267\u884c\u5806\u5316\u64cd\u4f5c\uff08Sift Down\uff09\u3002\u5b8c\u6210\u5806\u5316\u540e\uff0c\u5806\u7684\u6027\u8d28\u5f97\u5230\u4fee\u590d\u3002
    4. \u5faa\u73af\u6267\u884c\u7b2c 2. \u548c 3. \u6b65\u3002\u5faa\u73af \\(n - 1\\) \u8f6e\u540e\uff0c\u5373\u53ef\u5b8c\u6210\u6570\u7ec4\u6392\u5e8f\u3002

    \u5b9e\u9645\u4e0a\uff0c\u5143\u7d20\u51fa\u5806\u64cd\u4f5c\u4e2d\u4e5f\u5305\u542b\u7b2c 2. \u548c 3. \u6b65\uff0c\u53ea\u662f\u591a\u4e86\u4e00\u4e2a\u5f39\u51fa\u5143\u7d20\u7684\u6b65\u9aa4\u3002

    <1><2><3><4><5><6><7><8><9><10><11><12>

    \u5728\u4ee3\u7801\u5b9e\u73b0\u4e2d\uff0c\u6211\u4eec\u4f7f\u7528\u4e86\u4e0e\u5806\u7ae0\u8282\u76f8\u540c\u7684\u4ece\u9876\u81f3\u5e95\u5806\u5316\uff08Sift Down\uff09\u7684\u51fd\u6570\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u7531\u4e8e\u5806\u7684\u957f\u5ea6\u4f1a\u968f\u7740\u63d0\u53d6\u6700\u5927\u5143\u7d20\u800c\u51cf\u5c0f\uff0c\u56e0\u6b64\u6211\u4eec\u9700\u8981\u7ed9 Sift Down \u51fd\u6570\u6dfb\u52a0\u4e00\u4e2a\u957f\u5ea6\u53c2\u6570 \\(n\\) \uff0c\u7528\u4e8e\u6307\u5b9a\u5806\u7684\u5f53\u524d\u6709\u6548\u957f\u5ea6\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart heap_sort.java
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int[] nums, int n, int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = 2 * i + 1;\nint r = 2 * i + 2;\nint ma = i;\nif (l < n && nums[l] > nums[ma])\nma = l;\nif (r < n && nums[r] > nums[ma])\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i)\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nint temp = nums[i];\nnums[i] = nums[ma];\nnums[ma] = temp;\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nvoid heapSort(int[] nums) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = nums.length / 2 - 1; i >= 0; i--) {\nsiftDown(nums, nums.length, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (int i = nums.length - 1; i > 0; i--) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nint tmp = nums[0];\nnums[0] = nums[i];\nnums[i] = tmp;\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.cpp
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(vector<int> &nums, int n, int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = 2 * i + 1;\nint r = 2 * i + 2;\nint ma = i;\nif (l < n && nums[l] > nums[ma])\nma = l;\nif (r < n && nums[r] > nums[ma])\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nswap(nums[i], nums[ma]);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nvoid heapSort(vector<int> &nums) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = nums.size() / 2 - 1; i >= 0; --i) {\nsiftDown(nums, nums.size(), i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (int i = nums.size() - 1; i > 0; --i) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nswap(nums[0], nums[i]);\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.py
    def sift_down(nums: list[int], n: int, i: int):\n\"\"\"\u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\"\"\"\nwhile True:\n# \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nl = 2 * i + 1\nr = 2 * i + 2\nma = i\nif l < n and nums[l] > nums[ma]:\nma = l\nif r < n and nums[r] > nums[ma]:\nma = r\n# \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif ma == i:\nbreak\n# \u4ea4\u6362\u4e24\u8282\u70b9\nnums[i], nums[ma] = nums[ma], nums[i]\n# \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma\ndef heap_sort(nums: list[int]):\n\"\"\"\u5806\u6392\u5e8f\"\"\"\n# \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor i in range(len(nums) // 2 - 1, -1, -1):\nsift_down(nums, len(nums), i)\n# \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor i in range(len(nums) - 1, 0, -1):\n# \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nnums[0], nums[i] = nums[i], nums[0]\n# \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsift_down(nums, i, 0)\n
    heap_sort.go
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc siftDown(nums *[]int, n, i int) {\nfor true {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nl := 2*i + 1\nr := 2*i + 2\nma := i\nif l < n && (*nums)[l] > (*nums)[ma] {\nma = l\n}\nif r < n && (*nums)[r] > (*nums)[ma] {\nma = r\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif ma == i {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\n(*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma\n}\n}\n/* \u5806\u6392\u5e8f */\nfunc heapSort(nums *[]int) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor i := len(*nums)/2 - 1; i >= 0; i-- {\nsiftDown(nums, len(*nums), i)\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor i := len(*nums) - 1; i > 0; i-- {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n(*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0)\n}\n}\n
    heap_sort.js
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunction siftDown(nums, n, i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nlet l = 2 * i + 1;\nlet r = 2 * i + 2;\nlet ma = i;\nif (l < n && nums[l] > nums[ma]) {\nma = l;\n}\nif (r < n && nums[r] > nums[ma]) {\nma = r;\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma === i) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\n[nums[i], nums[ma]] = [nums[ma], nums[i]];\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nfunction heapSort(nums) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {\nsiftDown(nums, nums.length, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n[nums[0], nums[i]] = [nums[i], nums[0]];\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.ts
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunction siftDown(nums: number[], n: number, i: number): void {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nlet l = 2 * i + 1;\nlet r = 2 * i + 2;\nlet ma = i;\nif (l < n && nums[l] > nums[ma]) {\nma = l;\n}\nif (r < n && nums[r] > nums[ma]) {\nma = r;\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma === i) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\n[nums[i], nums[ma]] = [nums[ma], nums[i]];\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nfunction heapSort(nums: number[]): void {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {\nsiftDown(nums, nums.length, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (let i = nums.length - 1; i > 0; i--) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n[nums[0], nums[i]] = [nums[i], nums[0]];\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.c
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int nums[], int n, int i) {\nwhile (1) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = 2 * i + 1;\nint r = 2 * i + 2;\nint ma = i;\nif (l < n && nums[l] > nums[ma])\nma = l;\nif (r < n && nums[r] > nums[ma])\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) {\nbreak;\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nint temp = nums[i];\nnums[i] = nums[ma];\nnums[ma] = temp;\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nvoid heapSort(int nums[], int n) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = n / 2 - 1; i >= 0; --i) {\nsiftDown(nums, n, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (int i = n - 1; i > 0; --i) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nint tmp = nums[0];\nnums[0] = nums[i];\nnums[i] = tmp;\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.cs
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int[] nums, int n, int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = 2 * i + 1;\nint r = 2 * i + 2;\nint ma = i;\nif (l < n && nums[l] > nums[ma])\nma = l;\nif (r < n && nums[r] > nums[ma])\nma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i)\nbreak;\n// \u4ea4\u6362\u4e24\u8282\u70b9\n(nums[ma], nums[i]) = (nums[i], nums[ma]);\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nvoid heapSort(int[] nums) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = nums.Length / 2 - 1; i >= 0; i--) {\nsiftDown(nums, nums.Length, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (int i = nums.Length - 1; i > 0; i--) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n(nums[i], nums[0]) = (nums[0], nums[i]);\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    heap_sort.swift
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc siftDown(nums: inout [Int], n: Int, i: Int) {\nvar i = i\nwhile true {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nlet l = 2 * i + 1\nlet r = 2 * i + 2\nvar ma = i\nif l < n, nums[l] > nums[ma] {\nma = l\n}\nif r < n, nums[r] > nums[ma] {\nma = r\n}\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif ma == i {\nbreak\n}\n// \u4ea4\u6362\u4e24\u8282\u70b9\nnums.swapAt(i, ma)\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma\n}\n}\n/* \u5806\u6392\u5e8f */\nfunc heapSort(nums: inout [Int]) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\nsiftDown(nums: &nums, n: nums.count, i: i)\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor i in stride(from: nums.count - 1, to: 0, by: -1) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nnums.swapAt(0, i)\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums: &nums, n: i, i: 0)\n}\n}\n
    heap_sort.zig
    [class]{}-[func]{siftDown}\n[class]{}-[func]{heapSort}\n
    heap_sort.dart
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(List<int> nums, int n, int i) {\nwhile (true) {\n// \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\nint l = 2 * i + 1;\nint r = 2 * i + 2;\nint ma = i;\nif (l < n && nums[l] > nums[ma]) ma = l;\nif (r < n && nums[r] > nums[ma]) ma = r;\n// \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u9700\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\nif (ma == i) break;\n// \u4ea4\u6362\u4e24\u8282\u70b9\nint temp = nums[i];\nnums[i] = nums[ma];\nnums[ma] = temp;\n// \u5faa\u73af\u5411\u4e0b\u5806\u5316\ni = ma;\n}\n}\n/* \u5806\u6392\u5e8f */\nvoid heapSort(List<int> nums) {\n// \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\nfor (int i = nums.length ~/ 2 - 1; i >= 0; i--) {\nsiftDown(nums, nums.length, i);\n}\n// \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\nfor (int i = nums.length - 1; i > 0; i--) {\n// \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u5373\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\nint tmp = nums[0];\nnums[0] = nums[i];\nnums[i] = tmp;\n// \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\nsiftDown(nums, i, 0);\n}\n}\n
    "},{"location":"chapter_sorting/heap_sort/#1172","title":"11.7.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n \\log n)\\) \u3001\u975e\u81ea\u9002\u5e94\u6392\u5e8f \uff1a\u5efa\u5806\u64cd\u4f5c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002\u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \uff0c\u5171\u5faa\u73af \\(n - 1\\) \u8f6e\u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(1)\\) \u3001\u539f\u5730\u6392\u5e8f \uff1a\u51e0\u4e2a\u6307\u9488\u53d8\u91cf\u4f7f\u7528 \\(O(1)\\) \u7a7a\u95f4\u3002\u5143\u7d20\u4ea4\u6362\u548c\u5806\u5316\u64cd\u4f5c\u90fd\u662f\u5728\u539f\u6570\u7ec4\u4e0a\u8fdb\u884c\u7684\u3002
    • \u975e\u7a33\u5b9a\u6392\u5e8f\uff1a\u5728\u4ea4\u6362\u5806\u9876\u5143\u7d20\u548c\u5806\u5e95\u5143\u7d20\u65f6\uff0c\u76f8\u7b49\u5143\u7d20\u7684\u76f8\u5bf9\u4f4d\u7f6e\u53ef\u80fd\u53d1\u751f\u53d8\u5316\u3002
    "},{"location":"chapter_sorting/insertion_sort/","title":"11.4. \u00a0 \u63d2\u5165\u6392\u5e8f","text":"

    \u300c\u63d2\u5165\u6392\u5e8f Insertion Sort\u300d\u662f\u4e00\u79cd\u7b80\u5355\u7684\u6392\u5e8f\u7b97\u6cd5\uff0c\u5b83\u7684\u5de5\u4f5c\u539f\u7406\u4e0e\u624b\u52a8\u6574\u7406\u4e00\u526f\u724c\u7684\u8fc7\u7a0b\u975e\u5e38\u76f8\u4f3c\u3002

    \u5177\u4f53\u6765\u8bf4\uff0c\u6211\u4eec\u5728\u672a\u6392\u5e8f\u533a\u95f4\u9009\u62e9\u4e00\u4e2a\u57fa\u51c6\u5143\u7d20\uff0c\u5c06\u8be5\u5143\u7d20\u4e0e\u5176\u5de6\u4fa7\u5df2\u6392\u5e8f\u533a\u95f4\u7684\u5143\u7d20\u9010\u4e00\u6bd4\u8f83\u5927\u5c0f\uff0c\u5e76\u5c06\u8be5\u5143\u7d20\u63d2\u5165\u5230\u6b63\u786e\u7684\u4f4d\u7f6e\u3002

    \u56de\u5fc6\u6570\u7ec4\u7684\u5143\u7d20\u63d2\u5165\u64cd\u4f5c\uff0c\u8bbe\u57fa\u51c6\u5143\u7d20\u4e3a base \uff0c\u6211\u4eec\u9700\u8981\u5c06\u4ece\u76ee\u6807\u7d22\u5f15\u5230 base \u4e4b\u95f4\u7684\u6240\u6709\u5143\u7d20\u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\uff0c\u7136\u540e\u518d\u5c06 base \u8d4b\u503c\u7ed9\u76ee\u6807\u7d22\u5f15\u3002

    Fig. \u5355\u6b21\u63d2\u5165\u64cd\u4f5c

    "},{"location":"chapter_sorting/insertion_sort/#1141","title":"11.4.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u63d2\u5165\u6392\u5e8f\u7684\u6574\u4f53\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u521d\u59cb\u72b6\u6001\u4e0b\uff0c\u6570\u7ec4\u7684\u7b2c 1 \u4e2a\u5143\u7d20\u5df2\u5b8c\u6210\u6392\u5e8f\u3002
    2. \u9009\u53d6\u6570\u7ec4\u7684\u7b2c 2 \u4e2a\u5143\u7d20\u4f5c\u4e3a base \uff0c\u5c06\u5176\u63d2\u5165\u5230\u6b63\u786e\u4f4d\u7f6e\u540e\uff0c\u6570\u7ec4\u7684\u524d 2 \u4e2a\u5143\u7d20\u5df2\u6392\u5e8f\u3002
    3. \u9009\u53d6\u7b2c 3 \u4e2a\u5143\u7d20\u4f5c\u4e3a base \uff0c\u5c06\u5176\u63d2\u5165\u5230\u6b63\u786e\u4f4d\u7f6e\u540e\uff0c\u6570\u7ec4\u7684\u524d 3 \u4e2a\u5143\u7d20\u5df2\u6392\u5e8f\u3002
    4. \u4ee5\u6b64\u7c7b\u63a8\uff0c\u5728\u6700\u540e\u4e00\u8f6e\u4e2d\uff0c\u9009\u53d6\u6700\u540e\u4e00\u4e2a\u5143\u7d20\u4f5c\u4e3a base \uff0c\u5c06\u5176\u63d2\u5165\u5230\u6b63\u786e\u4f4d\u7f6e\u540e\uff0c\u6240\u6709\u5143\u7d20\u5747\u5df2\u6392\u5e8f\u3002

    Fig. \u63d2\u5165\u6392\u5e8f\u6d41\u7a0b

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart insertion_sort.java
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (int i = 1; i < nums.length; i++) {\nint base = nums[i], j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = base;        // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.cpp
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(vector<int> &nums) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (int i = 1; i < nums.size(); i++) {\nint base = nums[i], j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.py
    def insertion_sort(nums: list[int]) -> None:\n\"\"\"\u63d2\u5165\u6392\u5e8f\"\"\"\n# \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\nfor i in range(1, len(nums)):\nbase = nums[i]\nj = i - 1\n# \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u533a\u95f4 [0, i-1] \u4e2d\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile j >= 0 and nums[j] > base:\nnums[j + 1] = nums[j]  # \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj -= 1\nnums[j + 1] = base  # \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n
    insertion_sort.go
    /* \u63d2\u5165\u6392\u5e8f */\nfunc insertionSort(nums []int) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\nfor i := 1; i < len(nums); i++ {\nbase := nums[i]\nj := i - 1\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nfor j >= 0 && nums[j] > base {\nnums[j+1] = nums[j] // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--\n}\nnums[j+1] = base // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.js
    /* \u63d2\u5165\u6392\u5e8f */\nfunction insertionSort(nums) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (let i = 1; i < nums.length; i++) {\nlet base = nums[i],\nj = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.ts
    /* \u63d2\u5165\u6392\u5e8f */\nfunction insertionSort(nums: number[]): void {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (let i = 1; i < nums.length; i++) {\nconst base = nums[i];\nlet j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.c
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(int nums[], int size) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (int i = 1; i < size; i++) {\nint base = nums[i], j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\n// \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nnums[j + 1] = nums[j];\nj--;\n}\n// \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\nnums[j + 1] = base;\n}\n}\n
    insertion_sort.cs
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(int[] nums) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (int i = 1; i < nums.Length; i++) {\nint bas = nums[i], j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > bas) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = bas;         // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.swift
    /* \u63d2\u5165\u6392\u5e8f */\nfunc insertionSort(nums: inout [Int]) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor i in stride(from: 1, to: nums.count, by: 1) {\nlet base = nums[i]\nvar j = i - 1\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile j >= 0, nums[j] > base {\nnums[j + 1] = nums[j] // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj -= 1\n}\nnums[j + 1] = base // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.zig
    // \u63d2\u5165\u6392\u5e8f\nfn insertionSort(nums: []i32) void {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nvar i: usize = 1;\nwhile (i < nums.len) : (i += 1) {\nvar base = nums[i];\nvar j: usize = i;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 1 and nums[j - 1] > base) : (j -= 1) {\nnums[j] = nums[j - 1];  // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n}\nnums[j] = base;             // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    insertion_sort.dart
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(List<int> nums) {\n// \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u5143\u7d20\u6570\u91cf\u4e3a 1, 2, ..., n\nfor (int i = 1; i < nums.length; i++) {\nint base = nums[i], j = i - 1;\n// \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\nwhile (j >= 0 && nums[j] > base) {\nnums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\nj--;\n}\nnums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n}\n}\n
    "},{"location":"chapter_sorting/insertion_sort/#1142","title":"11.4.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n^2)\\) \u3001\u81ea\u9002\u5e94\u6392\u5e8f \uff1a\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u6bcf\u6b21\u63d2\u5165\u64cd\u4f5c\u5206\u522b\u9700\u8981\u5faa\u73af \\(n - 1\\) , \\(n-2\\) , \\(\\cdots\\) , \\(2\\) , \\(1\\) \u6b21\uff0c\u6c42\u548c\u5f97\u5230 \\(\\frac{(n - 1) n}{2}\\) \uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002\u5728\u9047\u5230\u6709\u5e8f\u6570\u636e\u65f6\uff0c\u63d2\u5165\u64cd\u4f5c\u4f1a\u63d0\u524d\u7ec8\u6b62\u3002\u5f53\u8f93\u5165\u6570\u7ec4\u5b8c\u5168\u6709\u5e8f\u65f6\uff0c\u63d2\u5165\u6392\u5e8f\u8fbe\u5230\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n)\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(1)\\) \u3001\u539f\u5730\u6392\u5e8f \uff1a\u6307\u9488 \\(i\\) , \\(j\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u7a33\u5b9a\u6392\u5e8f\uff1a\u5728\u63d2\u5165\u64cd\u4f5c\u8fc7\u7a0b\u4e2d\uff0c\u6211\u4eec\u4f1a\u5c06\u5143\u7d20\u63d2\u5165\u5230\u76f8\u7b49\u5143\u7d20\u7684\u53f3\u4fa7\uff0c\u4e0d\u4f1a\u6539\u53d8\u5b83\u4eec\u7684\u987a\u5e8f\u3002
    "},{"location":"chapter_sorting/insertion_sort/#1143","title":"11.4.3. \u00a0 \u63d2\u5165\u6392\u5e8f\u4f18\u52bf","text":"

    \u63d2\u5165\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff0c\u800c\u6211\u4eec\u5373\u5c06\u5b66\u4e60\u7684\u5feb\u901f\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002\u5c3d\u7ba1\u63d2\u5165\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u76f8\u6bd4\u5feb\u901f\u6392\u5e8f\u66f4\u9ad8\uff0c\u4f46\u5728\u6570\u636e\u91cf\u8f83\u5c0f\u7684\u60c5\u51b5\u4e0b\uff0c\u63d2\u5165\u6392\u5e8f\u901a\u5e38\u66f4\u5feb\u3002

    \u8fd9\u4e2a\u7ed3\u8bba\u4e0e\u7ebf\u6027\u67e5\u627e\u548c\u4e8c\u5206\u67e5\u627e\u7684\u9002\u7528\u60c5\u51b5\u7684\u7ed3\u8bba\u7c7b\u4f3c\u3002\u5feb\u901f\u6392\u5e8f\u8fd9\u7c7b \\(O(n \\log n)\\) \u7684\u7b97\u6cd5\u5c5e\u4e8e\u57fa\u4e8e\u5206\u6cbb\u7684\u6392\u5e8f\u7b97\u6cd5\uff0c\u5f80\u5f80\u5305\u542b\u66f4\u591a\u5355\u5143\u8ba1\u7b97\u64cd\u4f5c\u3002\u800c\u5728\u6570\u636e\u91cf\u8f83\u5c0f\u65f6\uff0c\\(n^2\\) \u548c \\(n \\log n\\) \u7684\u6570\u503c\u6bd4\u8f83\u63a5\u8fd1\uff0c\u590d\u6742\u5ea6\u4e0d\u5360\u4e3b\u5bfc\u4f5c\u7528\uff1b\u6bcf\u8f6e\u4e2d\u7684\u5355\u5143\u8ba1\u7b97\u64cd\u4f5c\u6570\u91cf\u8d77\u5230\u51b3\u5b9a\u6027\u56e0\u7d20\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\uff08\u4f8b\u5982 Java\uff09\u7684\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\u90fd\u91c7\u7528\u4e86\u63d2\u5165\u6392\u5e8f\uff0c\u5927\u81f4\u601d\u8def\u4e3a\uff1a\u5bf9\u4e8e\u957f\u6570\u7ec4\uff0c\u91c7\u7528\u57fa\u4e8e\u5206\u6cbb\u7684\u6392\u5e8f\u7b97\u6cd5\uff0c\u4f8b\u5982\u5feb\u901f\u6392\u5e8f\uff1b\u5bf9\u4e8e\u77ed\u6570\u7ec4\uff0c\u76f4\u63a5\u4f7f\u7528\u63d2\u5165\u6392\u5e8f\u3002

    \u867d\u7136\u5192\u6ce1\u6392\u5e8f\u3001\u9009\u62e9\u6392\u5e8f\u548c\u63d2\u5165\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(n^2)\\) \uff0c\u4f46\u5728\u5b9e\u9645\u60c5\u51b5\u4e2d\uff0c\u63d2\u5165\u6392\u5e8f\u7684\u4f7f\u7528\u9891\u7387\u663e\u8457\u9ad8\u4e8e\u5192\u6ce1\u6392\u5e8f\u548c\u9009\u62e9\u6392\u5e8f\u3002\u8fd9\u662f\u56e0\u4e3a\uff1a

    • \u5192\u6ce1\u6392\u5e8f\u57fa\u4e8e\u5143\u7d20\u4ea4\u6362\u5b9e\u73b0\uff0c\u9700\u8981\u501f\u52a9\u4e00\u4e2a\u4e34\u65f6\u53d8\u91cf\uff0c\u5171\u6d89\u53ca 3 \u4e2a\u5355\u5143\u64cd\u4f5c\uff1b\u63d2\u5165\u6392\u5e8f\u57fa\u4e8e\u5143\u7d20\u8d4b\u503c\u5b9e\u73b0\uff0c\u4ec5\u9700 1 \u4e2a\u5355\u5143\u64cd\u4f5c\u3002\u56e0\u6b64\uff0c\u5192\u6ce1\u6392\u5e8f\u7684\u8ba1\u7b97\u5f00\u9500\u901a\u5e38\u6bd4\u63d2\u5165\u6392\u5e8f\u66f4\u9ad8\u3002
    • \u9009\u62e9\u6392\u5e8f\u5728\u4efb\u4f55\u60c5\u51b5\u4e0b\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(n^2)\\) \u3002\u5982\u679c\u7ed9\u5b9a\u4e00\u7ec4\u90e8\u5206\u6709\u5e8f\u7684\u6570\u636e\uff0c\u63d2\u5165\u6392\u5e8f\u901a\u5e38\u6bd4\u9009\u62e9\u6392\u5e8f\u6548\u7387\u66f4\u9ad8\u3002
    • \u9009\u62e9\u6392\u5e8f\u4e0d\u7a33\u5b9a\uff0c\u65e0\u6cd5\u5e94\u7528\u4e8e\u591a\u7ea7\u6392\u5e8f\u3002
    "},{"location":"chapter_sorting/merge_sort/","title":"11.6. \u00a0 \u5f52\u5e76\u6392\u5e8f","text":"

    \u300c\u5f52\u5e76\u6392\u5e8f Merge Sort\u300d\u57fa\u4e8e\u5206\u6cbb\u601d\u60f3\u5b9e\u73b0\u6392\u5e8f\uff0c\u5305\u542b\u201c\u5212\u5206\u201d\u548c\u201c\u5408\u5e76\u201d\u4e24\u4e2a\u9636\u6bb5\uff1a

    1. \u5212\u5206\u9636\u6bb5\uff1a\u901a\u8fc7\u9012\u5f52\u4e0d\u65ad\u5730\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5904\u5206\u5f00\uff0c\u5c06\u957f\u6570\u7ec4\u7684\u6392\u5e8f\u95ee\u9898\u8f6c\u6362\u4e3a\u77ed\u6570\u7ec4\u7684\u6392\u5e8f\u95ee\u9898\uff1b
    2. \u5408\u5e76\u9636\u6bb5\uff1a\u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u5212\u5206\uff0c\u5f00\u59cb\u5408\u5e76\uff0c\u6301\u7eed\u5730\u5c06\u5de6\u53f3\u4e24\u4e2a\u8f83\u77ed\u7684\u6709\u5e8f\u6570\u7ec4\u5408\u5e76\u4e3a\u4e00\u4e2a\u8f83\u957f\u7684\u6709\u5e8f\u6570\u7ec4\uff0c\u76f4\u81f3\u7ed3\u675f\uff1b

    Fig. \u5f52\u5e76\u6392\u5e8f\u7684\u5212\u5206\u4e0e\u5408\u5e76\u9636\u6bb5

    "},{"location":"chapter_sorting/merge_sort/#1161","title":"11.6.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u201c\u5212\u5206\u9636\u6bb5\u201d\u4ece\u9876\u81f3\u5e95\u9012\u5f52\u5730\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5207\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u76f4\u81f3\u957f\u5ea6\u4e3a 1 \uff1b

    1. \u8ba1\u7b97\u6570\u7ec4\u4e2d\u70b9 mid \uff0c\u9012\u5f52\u5212\u5206\u5de6\u5b50\u6570\u7ec4\uff08\u533a\u95f4 [left, mid] \uff09\u548c\u53f3\u5b50\u6570\u7ec4\uff08\u533a\u95f4 [mid + 1, right] \uff09\uff1b
    2. \u9012\u5f52\u6267\u884c\u6b65\u9aa4 1. \uff0c\u76f4\u81f3\u5b50\u6570\u7ec4\u533a\u95f4\u957f\u5ea6\u4e3a 1 \u65f6\uff0c\u7ec8\u6b62\u9012\u5f52\u5212\u5206\uff1b

    \u201c\u5408\u5e76\u9636\u6bb5\u201d\u4ece\u5e95\u81f3\u9876\u5730\u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u5408\u5e76\u4e3a\u4e00\u4e2a\u6709\u5e8f\u6570\u7ec4\u3002\u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u4ece\u957f\u5ea6\u4e3a 1 \u7684\u5b50\u6570\u7ec4\u5f00\u59cb\u5408\u5e76\uff0c\u5408\u5e76\u9636\u6bb5\u4e2d\u7684\u6bcf\u4e2a\u5b50\u6570\u7ec4\u90fd\u662f\u6709\u5e8f\u7684\u3002

    <1><2><3><4><5><6><7><8><9><10>

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u5f52\u5e76\u6392\u5e8f\u7684\u9012\u5f52\u987a\u5e8f\u4e0e\u4e8c\u53c9\u6811\u7684\u540e\u5e8f\u904d\u5386\u76f8\u540c\uff0c\u5177\u4f53\u6765\u770b\uff1a

    • \u540e\u5e8f\u904d\u5386\uff1a\u5148\u9012\u5f52\u5de6\u5b50\u6811\uff0c\u518d\u9012\u5f52\u53f3\u5b50\u6811\uff0c\u6700\u540e\u5904\u7406\u6839\u8282\u70b9\u3002
    • \u5f52\u5e76\u6392\u5e8f\uff1a\u5148\u9012\u5f52\u5de6\u5b50\u6570\u7ec4\uff0c\u518d\u9012\u5f52\u53f3\u5b50\u6570\u7ec4\uff0c\u6700\u540e\u5904\u7406\u5408\u5e76\u3002
    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart merge_sort.java
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nvoid merge(int[] nums, int left, int mid, int right) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nint[] tmp = Arrays.copyOfRange(nums, left, right + 1);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint leftStart = left - left, leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint rightStart = mid + 1 - left, rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nint i = leftStart, j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (int k = left; k <= right; k++) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd)\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if (j > rightEnd || tmp[i] <= tmp[j])\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse\nnums[k] = tmp[j++];\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(int[] nums, int left, int right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right)\nreturn;                      // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nint mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.cpp
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nvoid merge(vector<int> &nums, int left, int mid, int right) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nvector<int> tmp(nums.begin() + left, nums.begin() + right + 1);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint leftStart = left - left, leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint rightStart = mid + 1 - left, rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nint i = leftStart, j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (int k = left; k <= right; k++) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd)\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if (j > rightEnd || tmp[i] <= tmp[j])\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse\nnums[k] = tmp[j++];\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(vector<int> &nums, int left, int right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right)\nreturn; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nint mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.py
    def merge(nums: list[int], left: int, mid: int, right: int) -> None:\n\"\"\"\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\"\"\"\n# \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n# \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\n# \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\ntmp = list(nums[left : right + 1])\n# \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nleft_start = 0\nleft_end = mid - left\n# \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nright_start = mid + 1 - left\nright_end = right - left\n# i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\ni = left_start\nj = right_start\n# \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor k in range(left, right + 1):\n# \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif i > left_end:\nnums[k] = tmp[j]\nj += 1\n# \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelif j > right_end or tmp[i] <= tmp[j]:\nnums[k] = tmp[i]\ni += 1\n# \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse:\nnums[k] = tmp[j]\nj += 1\ndef merge_sort(nums: list[int], left: int, right: int) -> None:\n\"\"\"\u5f52\u5e76\u6392\u5e8f\"\"\"\n# \u7ec8\u6b62\u6761\u4ef6\nif left >= right:\nreturn  # \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n# \u5212\u5206\u9636\u6bb5\nmid = (left + right) // 2  # \u8ba1\u7b97\u4e2d\u70b9\nmerge_sort(nums, left, mid)  # \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmerge_sort(nums, mid + 1, right)  # \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n# \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right)\n
    merge_sort.go
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nfunc merge(nums []int, left, mid, right int) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4 \u501f\u52a9 copy \u6a21\u5757\ntmp := make([]int, right-left+1)\nfor i := left; i <= right; i++ {\ntmp[i-left] = nums[i]\n}\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nleftStart, leftEnd := left-left, mid-left\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nrightStart, rightEnd := mid+1-left, right-left\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\ni, j := leftStart, rightStart\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor k := left; k <= right; k++ {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif i > leftEnd {\nnums[k] = tmp[j]\nj++\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\n} else if j > rightEnd || tmp[i] <= tmp[j] {\nnums[k] = tmp[i]\ni++\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\n} else {\nnums[k] = tmp[j]\nj++\n}\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nfunc mergeSort(nums []int, left, right int) {\n// \u7ec8\u6b62\u6761\u4ef6\nif left >= right {\nreturn\n}\n// \u5212\u5206\u9636\u6bb5\nmid := (left + right) / 2\nmergeSort(nums, left, mid)\nmergeSort(nums, mid+1, right)\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right)\n}\n
    merge_sort.js
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nfunction merge(nums, left, mid, right) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nlet tmp = nums.slice(left, right + 1);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet leftStart = left - left,\nleftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet rightStart = mid + 1 - left,\nrightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nlet i = leftStart,\nj = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (let k = left; k <= right; k++) {\nif (i > leftEnd) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nnums[k] = tmp[j++];\n} else if (j > rightEnd || tmp[i] <= tmp[j]) {\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nnums[k] = tmp[i++];\n} else {\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nnums[k] = tmp[j++];\n}\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nfunction mergeSort(nums, left, right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nlet mid = Math.floor((left + right) / 2); // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.ts
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nlet tmp = nums.slice(left, right + 1);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet leftStart = left - left,\nleftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet rightStart = mid + 1 - left,\nrightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nlet i = leftStart,\nj = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (let k = left; k <= right; k++) {\nif (i > leftEnd) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\n} else if (j > rightEnd || tmp[i] <= tmp[j]) {\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\n} else {\nnums[k] = tmp[j++];\n}\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nlet mid = Math.floor((left + right) / 2); // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.c
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nvoid merge(int *nums, int left, int mid, int right) {\nint index;\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nint tmp[right + 1 - left];\nfor (index = left; index < right + 1; index++) {\ntmp[index - left] = nums[index];\n}\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint leftStart = left - left, leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint rightStart = mid + 1 - left, rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nint i = leftStart, j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (int k = left; k <= right; k++) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd)\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if (j > rightEnd || tmp[i] <= tmp[j])\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse\nnums[k] = tmp[j++];\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(int *nums, int left, int right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right)\nreturn; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nint mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.cs
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nvoid merge(int[] nums, int left, int mid, int right) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nint[] tmp = nums[left..(right + 1)];\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15  \nint leftStart = left - left, leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15       \nint rightStart = mid + 1 - left, rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nint i = leftStart, j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (int k = left; k <= right; k++) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd)\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if (j > rightEnd || tmp[i] <= tmp[j])\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse\nnums[k] = tmp[j++];\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(int[] nums, int left, int right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right) return;       // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nint mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n
    merge_sort.swift
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nlet tmp = Array(nums[left ..< (right + 1)])\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet leftStart = left - left\nlet leftEnd = mid - left\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nlet rightStart = mid + 1 - left\nlet rightEnd = right - left\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nvar i = leftStart\nvar j = rightStart\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor k in left ... right {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif i > leftEnd {\nnums[k] = tmp[j]\nj += 1\n}\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if j > rightEnd || tmp[i] <= tmp[j] {\nnums[k] = tmp[i]\ni += 1\n}\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse {\nnums[k] = tmp[j]\nj += 1\n}\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n// \u7ec8\u6b62\u6761\u4ef6\nif left >= right { // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nreturn\n}\n// \u5212\u5206\u9636\u6bb5\nlet mid = (left + right) / 2 // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums: &nums, left: left, right: mid) // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums: &nums, left: mid + 1, right: right) // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums: &nums, left: left, mid: mid, right: right)\n}\n
    merge_sort.zig
    // \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nfn merge(nums: []i32, left: usize, mid: usize, right: usize) !void {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nvar mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);\ndefer mem_arena.deinit();\nconst mem_allocator = mem_arena.allocator();\nvar tmp = try mem_allocator.alloc(i32, right + 1 - left);\nstd.mem.copy(i32, tmp, nums[left..right+1]);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15  \nvar leftStart = left - left;\nvar leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15       \nvar rightStart = mid + 1 - left;\nvar rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nvar i = leftStart;\nvar j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nvar k = left;\nwhile (k <= right) : (k += 1) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd) {\nnums[k] = tmp[j];\nj += 1;\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\n} else if  (j > rightEnd or tmp[i] <= tmp[j]) {\nnums[k] = tmp[i];\ni += 1;\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\n} else {\nnums[k] = tmp[j];\nj += 1;\n}\n}\n}\n// \u5f52\u5e76\u6392\u5e8f\nfn mergeSort(nums: []i32, left: usize, right: usize) !void {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right) return;              // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nvar mid = (left + right) / 2;           // \u8ba1\u7b97\u4e2d\u70b9\ntry mergeSort(nums, left, mid);         // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\ntry mergeSort(nums, mid + 1, right);    // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\ntry merge(nums, left, mid, right);\n}\n
    merge_sort.dart
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\n// \u5de6\u5b50\u6570\u7ec4\u533a\u95f4 [left, mid]\n// \u53f3\u5b50\u6570\u7ec4\u533a\u95f4 [mid + 1, right]\nvoid merge(List<int> nums, int left, int mid, int right) {\n// \u521d\u59cb\u5316\u8f85\u52a9\u6570\u7ec4\nList<int> tmp = nums.sublist(left, right + 1);\n// \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint leftStart = left - left, leftEnd = mid - left;\n// \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15\nint rightStart = mid + 1 - left, rightEnd = right - left;\n// i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\nint i = leftStart, j = rightStart;\n// \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\nfor (int k = left; k <= right; k++) {\n// \u82e5\u201c\u5de6\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nif (i > leftEnd)\nnums[k] = tmp[j++];\n// \u5426\u5219\uff0c\u82e5\u201c\u53f3\u5b50\u6570\u7ec4\u5df2\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u6216\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 <= \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u5de6\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 i++\nelse if (j > rightEnd || tmp[i] <= tmp[j])\nnums[k] = tmp[i++];\n// \u5426\u5219\uff0c\u82e5\u201c\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u672a\u5168\u90e8\u5408\u5e76\u5b8c\u201d\u4e14\u201c\u5de6\u5b50\u6570\u7ec4\u5143\u7d20 > \u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u201d\uff0c\u5219\u9009\u53d6\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\uff0c\u5e76\u4e14 j++\nelse\nnums[k] = tmp[j++];\n}\n}\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(List<int> nums, int left, int right) {\n// \u7ec8\u6b62\u6761\u4ef6\nif (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n// \u5212\u5206\u9636\u6bb5\nint mid = (left + right) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\nmergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\nmergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n// \u5408\u5e76\u9636\u6bb5\nmerge(nums, left, mid, right);\n}\n

    \u5408\u5e76\u65b9\u6cd5 merge() \u4ee3\u7801\u4e2d\u7684\u96be\u70b9\u5305\u62ec\uff1a

    • \u5728\u9605\u8bfb\u4ee3\u7801\u65f6\uff0c\u9700\u8981\u7279\u522b\u6ce8\u610f\u5404\u4e2a\u53d8\u91cf\u7684\u542b\u4e49\u3002nums \u7684\u5f85\u5408\u5e76\u533a\u95f4\u4e3a [left, right] \uff0c\u4f46\u7531\u4e8e tmp \u4ec5\u590d\u5236\u4e86 nums \u8be5\u533a\u95f4\u7684\u5143\u7d20\uff0c\u56e0\u6b64 tmp \u5bf9\u5e94\u533a\u95f4\u4e3a [0, right - left] \u3002
    • \u5728\u6bd4\u8f83 tmp[i] \u548c tmp[j] \u7684\u5927\u5c0f\u65f6\uff0c\u8fd8\u9700\u8003\u8651\u5b50\u6570\u7ec4\u904d\u5386\u5b8c\u6210\u540e\u7684\u7d22\u5f15\u8d8a\u754c\u95ee\u9898\uff0c\u5373 i > leftEnd \u548c j > rightEnd \u7684\u60c5\u51b5\u3002\u7d22\u5f15\u8d8a\u754c\u7684\u4f18\u5148\u7ea7\u662f\u6700\u9ad8\u7684\uff0c\u5982\u679c\u5de6\u5b50\u6570\u7ec4\u5df2\u7ecf\u88ab\u5408\u5e76\u5b8c\u4e86\uff0c\u90a3\u4e48\u4e0d\u9700\u8981\u7ee7\u7eed\u6bd4\u8f83\uff0c\u76f4\u63a5\u5408\u5e76\u53f3\u5b50\u6570\u7ec4\u5143\u7d20\u5373\u53ef\u3002
    "},{"location":"chapter_sorting/merge_sort/#1162","title":"11.6.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n \\log n)\\) \u3001\u975e\u81ea\u9002\u5e94\u6392\u5e8f \uff1a\u5212\u5206\u4ea7\u751f\u9ad8\u5ea6\u4e3a \\(\\log n\\) \u7684\u9012\u5f52\u6811\uff0c\u6bcf\u5c42\u5408\u5e76\u7684\u603b\u64cd\u4f5c\u6570\u91cf\u4e3a \\(n\\) \uff0c\u56e0\u6b64\u603b\u4f53\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(n)\\) \u3001\u975e\u539f\u5730\u6392\u5e8f \uff1a\u9012\u5f52\u6df1\u5ea6\u4e3a \\(\\log n\\) \uff0c\u4f7f\u7528 \\(O(\\log n)\\) \u5927\u5c0f\u7684\u6808\u5e27\u7a7a\u95f4\u3002\u5408\u5e76\u64cd\u4f5c\u9700\u8981\u501f\u52a9\u8f85\u52a9\u6570\u7ec4\u5b9e\u73b0\uff0c\u4f7f\u7528 \\(O(n)\\) \u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u7a33\u5b9a\u6392\u5e8f\uff1a\u5728\u5408\u5e76\u8fc7\u7a0b\u4e2d\uff0c\u76f8\u7b49\u5143\u7d20\u7684\u6b21\u5e8f\u4fdd\u6301\u4e0d\u53d8\u3002
    "},{"location":"chapter_sorting/merge_sort/#1163","title":"11.6.3. \u00a0 \u94fe\u8868\u6392\u5e8f *","text":"

    \u5f52\u5e76\u6392\u5e8f\u5728\u6392\u5e8f\u94fe\u8868\u65f6\u5177\u6709\u663e\u8457\u4f18\u52bf\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u4f18\u5316\u81f3 \\(O(1)\\) \uff0c\u539f\u56e0\u5982\u4e0b\uff1a

    • \u7531\u4e8e\u94fe\u8868\u4ec5\u9700\u6539\u53d8\u6307\u9488\u5c31\u53ef\u5b9e\u73b0\u8282\u70b9\u7684\u589e\u5220\u64cd\u4f5c\uff0c\u56e0\u6b64\u5408\u5e76\u9636\u6bb5\uff08\u5c06\u4e24\u4e2a\u77ed\u6709\u5e8f\u94fe\u8868\u5408\u5e76\u4e3a\u4e00\u4e2a\u957f\u6709\u5e8f\u94fe\u8868\uff09\u65e0\u9700\u521b\u5efa\u8f85\u52a9\u94fe\u8868\u3002
    • \u901a\u8fc7\u4f7f\u7528\u201c\u8fed\u4ee3\u5212\u5206\u201d\u66ff\u4ee3\u201c\u9012\u5f52\u5212\u5206\u201d\uff0c\u53ef\u7701\u53bb\u9012\u5f52\u4f7f\u7528\u7684\u6808\u5e27\u7a7a\u95f4\uff1b

    \u5177\u4f53\u5b9e\u73b0\u7ec6\u8282\u6bd4\u8f83\u590d\u6742\uff0c\u6709\u5174\u8da3\u7684\u540c\u5b66\u53ef\u4ee5\u67e5\u9605\u76f8\u5173\u8d44\u6599\u8fdb\u884c\u5b66\u4e60\u3002

    "},{"location":"chapter_sorting/quick_sort/","title":"11.5. \u00a0 \u5feb\u901f\u6392\u5e8f","text":"

    \u300c\u5feb\u901f\u6392\u5e8f Quick Sort\u300d\u662f\u4e00\u79cd\u57fa\u4e8e\u5206\u6cbb\u601d\u60f3\u7684\u6392\u5e8f\u7b97\u6cd5\uff0c\u8fd0\u884c\u9ad8\u6548\uff0c\u5e94\u7528\u5e7f\u6cdb\u3002

    \u5feb\u901f\u6392\u5e8f\u7684\u6838\u5fc3\u64cd\u4f5c\u662f\u300c\u54e8\u5175\u5212\u5206\u300d\uff0c\u5176\u76ee\u6807\u662f\uff1a\u9009\u62e9\u6570\u7ec4\u4e2d\u7684\u67d0\u4e2a\u5143\u7d20\u4f5c\u4e3a\u201c\u57fa\u51c6\u6570\u201d\uff0c\u5c06\u6240\u6709\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\u79fb\u5230\u5176\u5de6\u4fa7\uff0c\u800c\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\u79fb\u5230\u5176\u53f3\u4fa7\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u54e8\u5175\u5212\u5206\u7684\u6d41\u7a0b\u4e3a\uff1a

    1. \u9009\u53d6\u6570\u7ec4\u6700\u5de6\u7aef\u5143\u7d20\u4f5c\u4e3a\u57fa\u51c6\u6570\uff0c\u521d\u59cb\u5316\u4e24\u4e2a\u6307\u9488 i \u548c j \u5206\u522b\u6307\u5411\u6570\u7ec4\u7684\u4e24\u7aef\uff1b
    2. \u8bbe\u7f6e\u4e00\u4e2a\u5faa\u73af\uff0c\u5728\u6bcf\u8f6e\u4e2d\u4f7f\u7528 i\uff08j\uff09\u5206\u522b\u5bfb\u627e\u7b2c\u4e00\u4e2a\u6bd4\u57fa\u51c6\u6570\u5927\uff08\u5c0f\uff09\u7684\u5143\u7d20\uff0c\u7136\u540e\u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\uff1b
    3. \u5faa\u73af\u6267\u884c\u6b65\u9aa4 2. \uff0c\u76f4\u5230 i \u548c j \u76f8\u9047\u65f6\u505c\u6b62\uff0c\u6700\u540e\u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u4e2a\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\uff1b

    \u54e8\u5175\u5212\u5206\u5b8c\u6210\u540e\uff0c\u539f\u6570\u7ec4\u88ab\u5212\u5206\u6210\u4e09\u90e8\u5206\uff1a\u5de6\u5b50\u6570\u7ec4\u3001\u57fa\u51c6\u6570\u3001\u53f3\u5b50\u6570\u7ec4\uff0c\u4e14\u6ee1\u8db3\u201c\u5de6\u5b50\u6570\u7ec4\u4efb\u610f\u5143\u7d20 \\(\\leq\\) \u57fa\u51c6\u6570 \\(\\leq\\) \u53f3\u5b50\u6570\u7ec4\u4efb\u610f\u5143\u7d20\u201d\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u63a5\u4e0b\u6765\u53ea\u9700\u5bf9\u8fd9\u4e24\u4e2a\u5b50\u6570\u7ec4\u8fdb\u884c\u6392\u5e8f\u3002

    <1><2><3><4><5><6><7><8><9>

    \u5feb\u901f\u6392\u5e8f\u7684\u5206\u6cbb\u601d\u60f3

    \u54e8\u5175\u5212\u5206\u7684\u5b9e\u8d28\u662f\u5c06\u4e00\u4e2a\u8f83\u957f\u6570\u7ec4\u7684\u6392\u5e8f\u95ee\u9898\u7b80\u5316\u4e3a\u4e24\u4e2a\u8f83\u77ed\u6570\u7ec4\u7684\u6392\u5e8f\u95ee\u9898\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart quick_sort.java
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(int[] nums, int i, int j) {\nint tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\nint partition(int[] nums, int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);  // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.cpp
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(vector<int> &nums, int i, int j) {\nint tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\nint partition(vector<int> &nums, int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.py
    def partition(self, nums: list[int], left: int, right: int) -> int:\n\"\"\"\u54e8\u5175\u5212\u5206\"\"\"\n# \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\ni, j = left, right\nwhile i < j:\nwhile i < j and nums[j] >= nums[left]:\nj -= 1  # \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile i < j and nums[i] <= nums[left]:\ni += 1  # \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n# \u5143\u7d20\u4ea4\u6362\nnums[i], nums[j] = nums[j], nums[i]\n# \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nnums[i], nums[left] = nums[left], nums[i]\nreturn i  # \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n
    quick_sort.go
    /* \u54e8\u5175\u5212\u5206 */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\ni, j := left, right\nfor i < j {\nfor i < j && nums[j] >= nums[left] {\nj-- // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nfor i < j && nums[i] <= nums[left] {\ni++ // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\n// \u5143\u7d20\u4ea4\u6362\nnums[i], nums[j] = nums[j], nums[i]\n}\n// \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nnums[i], nums[left] = nums[left], nums[i]\nreturn i // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.js
    /* \u5143\u7d20\u4ea4\u6362 */\nswap(nums, i, j) {\nlet tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\npartition(nums, left, right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nlet i = left,\nj = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) {\nj -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nwhile (i < j && nums[i] <= nums[left]) {\ni += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\n// \u5143\u7d20\u4ea4\u6362\nthis.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nthis.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.ts
    /* \u5143\u7d20\u4ea4\u6362 */\nswap(nums: number[], i: number, j: number): void {\nlet tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\npartition(nums: number[], left: number, right: number): number {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nlet i = left,\nj = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) {\nj -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nwhile (i < j && nums[i] <= nums[left]) {\ni += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\n// \u5143\u7d20\u4ea4\u6362\nthis.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nthis.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.c
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(int nums[], int i, int j) {\nint tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u5feb\u901f\u6392\u5e8f\u7c7b */\n// \u5feb\u901f\u6392\u5e8f\u7c7b-\u54e8\u5175\u5212\u5206\nint partition(int nums[], int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) {\n// \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nj--;\n}\nwhile (i < j && nums[i] <= nums[left]) {\n// \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\ni++;\n}\n// \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\nswap(nums, i, j);\n}\n// \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nswap(nums, i, left);\n// \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\nreturn i;\n}\n
    quick_sort.cs
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(int[] nums, int i, int j) {\nint tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\nint partition(int[] nums, int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);  // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.swift
    /* \u5143\u7d20\u4ea4\u6362 */\nfunc swap(nums: inout [Int], i: Int, j: Int) {\nlet tmp = nums[i]\nnums[i] = nums[j]\nnums[j] = tmp\n}\n/* \u54e8\u5175\u5212\u5206 */\nfunc partition(nums: inout [Int], left: Int, right: Int) -> Int {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nvar i = left\nvar j = right\nwhile i < j {\nwhile i < j, nums[j] >= nums[left] {\nj -= 1 // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nwhile i < j, nums[i] <= nums[left] {\ni += 1 // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nswap(nums: &nums, i: i, j: j) // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums: &nums, i: i, j: left) // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.zig
    // \u5143\u7d20\u4ea4\u6362\nfn swap(nums: []i32, i: usize, j: usize) void {\nvar tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n// \u54e8\u5175\u5212\u5206\nfn partition(nums: []i32, left: usize, right: usize) usize {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nvar i = left;\nvar j = right;\nwhile (i < j) {\nwhile (i < j and nums[j] >= nums[left]) j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j and nums[i] <= nums[left]) i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j);   // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);    // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;               // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.dart
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid _swap(List<int> nums, int i, int j) {\nint tmp = nums[i];\nnums[i] = nums[j];\nnums[j] = tmp;\n}\n/* \u54e8\u5175\u5212\u5206 */\nint _partition(List<int> nums, int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left]) i++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n_swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\n_swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    "},{"location":"chapter_sorting/quick_sort/#1151","title":"11.5.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"
    1. \u9996\u5148\uff0c\u5bf9\u539f\u6570\u7ec4\u6267\u884c\u4e00\u6b21\u300c\u54e8\u5175\u5212\u5206\u300d\uff0c\u5f97\u5230\u672a\u6392\u5e8f\u7684\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\uff1b
    2. \u7136\u540e\uff0c\u5bf9\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u5206\u522b\u9012\u5f52\u6267\u884c\u300c\u54e8\u5175\u5212\u5206\u300d\uff1b
    3. \u6301\u7eed\u9012\u5f52\uff0c\u76f4\u81f3\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\uff0c\u4ece\u800c\u5b8c\u6210\u6574\u4e2a\u6570\u7ec4\u7684\u6392\u5e8f\uff1b

    Fig. \u5feb\u901f\u6392\u5e8f\u6d41\u7a0b

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart quick_sort.java
    /* \u5feb\u901f\u6392\u5e8f */\nvoid quickSort(int[] nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right)\nreturn;\n// \u54e8\u5175\u5212\u5206\nint pivot = partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    quick_sort.cpp
    /* \u5feb\u901f\u6392\u5e8f */\nvoid quickSort(vector<int> &nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right)\nreturn;\n// \u54e8\u5175\u5212\u5206\nint pivot = partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    quick_sort.py
    def quick_sort(self, nums: list[int], left: int, right: int) -> None:\n\"\"\"\u5feb\u901f\u6392\u5e8f\"\"\"\n# \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif left >= right:\nreturn\n# \u54e8\u5175\u5212\u5206\npivot = self.partition(nums, left, right)\n# \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nself.quick_sort(nums, left, pivot - 1)\nself.quick_sort(nums, pivot + 1, right)\n
    quick_sort.go
    /* \u5feb\u901f\u6392\u5e8f */\nfunc (q *quickSort) quickSort(nums []int, left, right int) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif left >= right {\nreturn\n}\n// \u54e8\u5175\u5212\u5206\npivot := q.partition(nums, left, right)\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nq.quickSort(nums, left, pivot-1)\nq.quickSort(nums, pivot+1, right)\n}\n
    quick_sort.js
    /* \u5feb\u901f\u6392\u5e8f */\nquickSort(nums, left, right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right) return;\n// \u54e8\u5175\u5212\u5206\nconst pivot = this.partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nthis.quickSort(nums, left, pivot - 1);\nthis.quickSort(nums, pivot + 1, right);\n}\n
    quick_sort.ts
    /* \u5feb\u901f\u6392\u5e8f */\nquickSort(nums: number[], left: number, right: number): void {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right) {\nreturn;\n}\n// \u54e8\u5175\u5212\u5206\nconst pivot = this.partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nthis.quickSort(nums, left, pivot - 1);\nthis.quickSort(nums, pivot + 1, right);\n}\n
    quick_sort.c
    /* \u5feb\u901f\u6392\u5e8f\u7c7b */\n// \u5feb\u901f\u6392\u5e8f\u7c7b-\u54e8\u5175\u5212\u5206\nint partition(int nums[], int left, int right) {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) {\n// \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nj--;\n}\nwhile (i < j && nums[i] <= nums[left]) {\n// \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\ni++;\n}\n// \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\nswap(nums, i, j);\n}\n// \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nswap(nums, i, left);\n// \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\nreturn i;\n}\n// \u5feb\u901f\u6392\u5e8f\u7c7b-\u5feb\u901f\u6392\u5e8f\nvoid quickSort(int nums[], int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right) {\nreturn;\n}\n// \u54e8\u5175\u5212\u5206\nint pivot = partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    quick_sort.cs
    /* \u5feb\u901f\u6392\u5e8f */\nvoid quickSort(int[] nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right)\nreturn;\n// \u54e8\u5175\u5212\u5206\nint pivot = partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    quick_sort.swift
    /* \u5feb\u901f\u6392\u5e8f */\nfunc quickSort(nums: inout [Int], left: Int, right: Int) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif left >= right {\nreturn\n}\n// \u54e8\u5175\u5212\u5206\nlet pivot = partition(nums: &nums, left: left, right: right)\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums: &nums, left: left, right: pivot - 1)\nquickSort(nums: &nums, left: pivot + 1, right: right)\n}\n
    quick_sort.zig
    // \u5feb\u901f\u6392\u5e8f\nfn quickSort(nums: []i32, left: usize, right: usize) void {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right) return;\n// \u54e8\u5175\u5212\u5206\nvar pivot = partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    quick_sort.dart
    /* \u5feb\u901f\u6392\u5e8f */\nvoid quickSort(List<int> nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nif (left >= right) return;\n// \u54e8\u5175\u5212\u5206\nint pivot = _partition(nums, left, right);\n// \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\nquickSort(nums, left, pivot - 1);\nquickSort(nums, pivot + 1, right);\n}\n
    "},{"location":"chapter_sorting/quick_sort/#1152","title":"11.5.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n \\log n)\\) \u3001\u81ea\u9002\u5e94\u6392\u5e8f \uff1a\u5728\u5e73\u5747\u60c5\u51b5\u4e0b\uff0c\u54e8\u5175\u5212\u5206\u7684\u9012\u5f52\u5c42\u6570\u4e3a \\(\\log n\\) \uff0c\u6bcf\u5c42\u4e2d\u7684\u603b\u5faa\u73af\u6570\u4e3a \\(n\\) \uff0c\u603b\u4f53\u4f7f\u7528 \\(O(n \\log n)\\) \u65f6\u95f4\u3002\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u6bcf\u8f6e\u54e8\u5175\u5212\u5206\u64cd\u4f5c\u90fd\u5c06\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4\u5212\u5206\u4e3a\u957f\u5ea6\u4e3a \\(0\\) \u548c \\(n - 1\\) \u7684\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u6b64\u65f6\u9012\u5f52\u5c42\u6570\u8fbe\u5230 \\(n\\) \u5c42\uff0c\u6bcf\u5c42\u4e2d\u7684\u5faa\u73af\u6570\u4e3a \\(n\\) \uff0c\u603b\u4f53\u4f7f\u7528 \\(O(n^2)\\) \u65f6\u95f4\u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(n)\\) \u3001\u539f\u5730\u6392\u5e8f \uff1a\u5728\u8f93\u5165\u6570\u7ec4\u5b8c\u5168\u5012\u5e8f\u7684\u60c5\u51b5\u4e0b\uff0c\u8fbe\u5230\u6700\u5dee\u9012\u5f52\u6df1\u5ea6 \\(n\\) \uff0c\u4f7f\u7528 \\(O(n)\\) \u6808\u5e27\u7a7a\u95f4\u3002\u6392\u5e8f\u64cd\u4f5c\u662f\u5728\u539f\u6570\u7ec4\u4e0a\u8fdb\u884c\u7684\uff0c\u672a\u501f\u52a9\u989d\u5916\u6570\u7ec4\u3002
    • \u975e\u7a33\u5b9a\u6392\u5e8f\uff1a\u5728\u54e8\u5175\u5212\u5206\u7684\u6700\u540e\u4e00\u6b65\uff0c\u57fa\u51c6\u6570\u53ef\u80fd\u4f1a\u88ab\u4ea4\u6362\u81f3\u76f8\u7b49\u5143\u7d20\u7684\u53f3\u4fa7\u3002
    "},{"location":"chapter_sorting/quick_sort/#1153","title":"11.5.3. \u00a0 \u5feb\u6392\u4e3a\u4ec0\u4e48\u5feb\uff1f","text":"

    \u4ece\u540d\u79f0\u4e0a\u5c31\u80fd\u770b\u51fa\uff0c\u5feb\u901f\u6392\u5e8f\u5728\u6548\u7387\u65b9\u9762\u5e94\u8be5\u5177\u6709\u4e00\u5b9a\u7684\u4f18\u52bf\u3002\u5c3d\u7ba1\u5feb\u901f\u6392\u5e8f\u7684\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4e0e\u300c\u5f52\u5e76\u6392\u5e8f\u300d\u548c\u300c\u5806\u6392\u5e8f\u300d\u76f8\u540c\uff0c\u4f46\u901a\u5e38\u5feb\u901f\u6392\u5e8f\u7684\u6548\u7387\u66f4\u9ad8\uff0c\u539f\u56e0\u5982\u4e0b\uff1a

    • \u51fa\u73b0\u6700\u5dee\u60c5\u51b5\u7684\u6982\u7387\u5f88\u4f4e\uff1a\u867d\u7136\u5feb\u901f\u6392\u5e8f\u7684\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff0c\u6ca1\u6709\u5f52\u5e76\u6392\u5e8f\u7a33\u5b9a\uff0c\u4f46\u5728\u7edd\u5927\u591a\u6570\u60c5\u51b5\u4e0b\uff0c\u5feb\u901f\u6392\u5e8f\u80fd\u5728 \\(O(n \\log n)\\) \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e0b\u8fd0\u884c\u3002
    • \u7f13\u5b58\u4f7f\u7528\u6548\u7387\u9ad8\uff1a\u5728\u6267\u884c\u54e8\u5175\u5212\u5206\u64cd\u4f5c\u65f6\uff0c\u7cfb\u7edf\u53ef\u5c06\u6574\u4e2a\u5b50\u6570\u7ec4\u52a0\u8f7d\u5230\u7f13\u5b58\uff0c\u56e0\u6b64\u8bbf\u95ee\u5143\u7d20\u7684\u6548\u7387\u8f83\u9ad8\u3002\u800c\u50cf\u300c\u5806\u6392\u5e8f\u300d\u8fd9\u7c7b\u7b97\u6cd5\u9700\u8981\u8df3\u8dc3\u5f0f\u8bbf\u95ee\u5143\u7d20\uff0c\u4ece\u800c\u7f3a\u4e4f\u8fd9\u4e00\u7279\u6027\u3002
    • \u590d\u6742\u5ea6\u7684\u5e38\u6570\u7cfb\u6570\u4f4e\uff1a\u5728\u4e0a\u8ff0\u4e09\u79cd\u7b97\u6cd5\u4e2d\uff0c\u5feb\u901f\u6392\u5e8f\u7684\u6bd4\u8f83\u3001\u8d4b\u503c\u3001\u4ea4\u6362\u7b49\u64cd\u4f5c\u7684\u603b\u6570\u91cf\u6700\u5c11\u3002\u8fd9\u4e0e\u300c\u63d2\u5165\u6392\u5e8f\u300d\u6bd4\u300c\u5192\u6ce1\u6392\u5e8f\u300d\u66f4\u5feb\u7684\u539f\u56e0\u7c7b\u4f3c\u3002
    "},{"location":"chapter_sorting/quick_sort/#1154","title":"11.5.4. \u00a0 \u57fa\u51c6\u6570\u4f18\u5316","text":"

    \u5feb\u901f\u6392\u5e8f\u5728\u67d0\u4e9b\u8f93\u5165\u4e0b\u7684\u65f6\u95f4\u6548\u7387\u53ef\u80fd\u964d\u4f4e\u3002\u4e3e\u4e00\u4e2a\u6781\u7aef\u4f8b\u5b50\uff0c\u5047\u8bbe\u8f93\u5165\u6570\u7ec4\u662f\u5b8c\u5168\u5012\u5e8f\u7684\uff0c\u7531\u4e8e\u6211\u4eec\u9009\u62e9\u6700\u5de6\u7aef\u5143\u7d20\u4f5c\u4e3a\u57fa\u51c6\u6570\uff0c\u90a3\u4e48\u5728\u54e8\u5175\u5212\u5206\u5b8c\u6210\u540e\uff0c\u57fa\u51c6\u6570\u88ab\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u53f3\u7aef\uff0c\u5bfc\u81f4\u5de6\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a \\(n - 1\\) \u3001\u53f3\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a \\(0\\) \u3002\u5982\u6b64\u9012\u5f52\u4e0b\u53bb\uff0c\u6bcf\u8f6e\u54e8\u5175\u5212\u5206\u540e\u7684\u53f3\u5b50\u6570\u7ec4\u957f\u5ea6\u90fd\u4e3a \\(0\\) \uff0c\u5206\u6cbb\u7b56\u7565\u5931\u6548\uff0c\u5feb\u901f\u6392\u5e8f\u9000\u5316\u4e3a\u300c\u5192\u6ce1\u6392\u5e8f\u300d\u3002

    \u4e3a\u4e86\u5c3d\u91cf\u907f\u514d\u8fd9\u79cd\u60c5\u51b5\u53d1\u751f\uff0c\u6211\u4eec\u53ef\u4ee5\u4f18\u5316\u54e8\u5175\u5212\u5206\u4e2d\u7684\u57fa\u51c6\u6570\u7684\u9009\u53d6\u7b56\u7565\u3002\u4f8b\u5982\uff0c\u6211\u4eec\u53ef\u4ee5\u968f\u673a\u9009\u53d6\u4e00\u4e2a\u5143\u7d20\u4f5c\u4e3a\u57fa\u51c6\u6570\u3002\u7136\u800c\uff0c\u5982\u679c\u8fd0\u6c14\u4e0d\u4f73\uff0c\u6bcf\u6b21\u90fd\u9009\u5230\u4e0d\u7406\u60f3\u7684\u57fa\u51c6\u6570\uff0c\u6548\u7387\u4ecd\u7136\u4e0d\u5c3d\u5982\u4eba\u610f\u3002

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u7f16\u7a0b\u8bed\u8a00\u901a\u5e38\u751f\u6210\u7684\u662f\u201c\u4f2a\u968f\u673a\u6570\u201d\u3002\u5982\u679c\u6211\u4eec\u9488\u5bf9\u4f2a\u968f\u673a\u6570\u5e8f\u5217\u6784\u5efa\u4e00\u4e2a\u7279\u5b9a\u7684\u6d4b\u8bd5\u6837\u4f8b\uff0c\u90a3\u4e48\u5feb\u901f\u6392\u5e8f\u7684\u6548\u7387\u4ecd\u7136\u53ef\u80fd\u52a3\u5316\u3002

    \u4e3a\u4e86\u8fdb\u4e00\u6b65\u6539\u8fdb\uff0c\u6211\u4eec\u53ef\u4ee5\u5728\u6570\u7ec4\u4e2d\u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\uff08\u901a\u5e38\u4e3a\u6570\u7ec4\u7684\u9996\u3001\u5c3e\u3001\u4e2d\u70b9\u5143\u7d20\uff09\uff0c\u5e76\u5c06\u8fd9\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\u4f5c\u4e3a\u57fa\u51c6\u6570\u3002\u8fd9\u6837\u4e00\u6765\uff0c\u57fa\u51c6\u6570\u201c\u65e2\u4e0d\u592a\u5c0f\u4e5f\u4e0d\u592a\u5927\u201d\u7684\u6982\u7387\u5c06\u5927\u5e45\u63d0\u5347\u3002\u5f53\u7136\uff0c\u6211\u4eec\u8fd8\u53ef\u4ee5\u9009\u53d6\u66f4\u591a\u5019\u9009\u5143\u7d20\uff0c\u4ee5\u8fdb\u4e00\u6b65\u63d0\u9ad8\u7b97\u6cd5\u7684\u7a33\u5065\u6027\u3002\u91c7\u7528\u8fd9\u79cd\u65b9\u6cd5\u540e\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u52a3\u5316\u81f3 \\(O(n^2)\\) \u7684\u6982\u7387\u5927\u5927\u964d\u4f4e\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart quick_sort.java
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint medianThree(int[] nums, int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nint partition(int[] nums, int left, int right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint med = medianThree(nums, left, (left + right) / 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);  // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.cpp
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint medianThree(vector<int> &nums, int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nint partition(vector<int> &nums, int left, int right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint med = medianThree(nums, left, (left + right) / 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.py
    def median_three(self, nums: list[int], left: int, mid: int, right: int) -> int:\n\"\"\"\u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\"\"\"\n# \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n# \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif (nums[left] < nums[mid]) ^ (nums[left] < nums[right]):\nreturn left\nelif (nums[mid] < nums[left]) ^ (nums[mid] < nums[right]):\nreturn mid\nreturn right\ndef partition(self, nums: list[int], left: int, right: int) -> int:\n\"\"\"\u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09\"\"\"\n# \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nmed = self.median_three(nums, left, (left + right) // 2, right)\n# \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nnums[left], nums[med] = nums[med], nums[left]\n# \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\ni, j = left, right\nwhile i < j:\nwhile i < j and nums[j] >= nums[left]:\nj -= 1  # \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile i < j and nums[i] <= nums[left]:\ni += 1  # \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n# \u5143\u7d20\u4ea4\u6362\nnums[i], nums[j] = nums[j], nums[i]\n# \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nnums[i], nums[left] = nums[left], nums[i]\nreturn i  # \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n
    quick_sort.go
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\uff08!= \u5728\u8fd9\u91cc\u8d77\u5230\u5f02\u6216\u7684\u4f5c\u7528\uff09\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif (nums[left] < nums[mid]) != (nums[left] < nums[right]) {\nreturn left\n} else if (nums[mid] < nums[left]) != (nums[mid] < nums[right]) {\nreturn mid\n}\nreturn right\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09*/\nfunc (q *quickSortMedian) partition(nums []int, left, right int) int {\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nmed := q.medianThree(nums, left, (left+right)/2, right)\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nnums[left], nums[med] = nums[med], nums[left]\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\ni, j := left, right\nfor i < j {\nfor i < j && nums[j] >= nums[left] {\nj-- //\u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nfor i < j && nums[i] <= nums[left] {\ni++ //\u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\n//\u5143\u7d20\u4ea4\u6362\nnums[i], nums[j] = nums[j], nums[i]\n}\n//\u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nnums[i], nums[left] = nums[left], nums[i]\nreturn i //\u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.js
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nmedianThree(nums, left, mid, right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right])) return left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse return right;\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\npartition(nums, left, right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nlet med = this.medianThree(\nnums,\nleft,\nMath.floor((left + right) / 2),\nright\n);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nthis.swap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nlet i = left,\nj = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left]) i++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nthis.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nthis.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.ts
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nmedianThree(\nnums: number[],\nleft: number,\nmid: number,\nright: number\n): number {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif (Number(nums[left] < nums[mid]) ^ Number(nums[left] < nums[right])) {\nreturn left;\n} else if (\nNumber(nums[mid] < nums[left]) ^ Number(nums[mid] < nums[right])\n) {\nreturn mid;\n} else {\nreturn right;\n}\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\npartition(nums: number[], left: number, right: number): number {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nlet med = this.medianThree(\nnums,\nleft,\nMath.floor((left + right) / 2),\nright\n);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nthis.swap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nlet i = left,\nj = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) {\nj--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nwhile (i < j && nums[i] <= nums[left]) {\ni++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n}\nthis.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nthis.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.c
    /* \u5feb\u901f\u6392\u5e8f\u7c7b\uff08\u4e2d\u4f4d\u57fa\u51c6\u6570\u4f18\u5316\uff09 */\n// \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint medianThree(int nums[], int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n/* \u5feb\u901f\u6392\u5e8f\u7c7b\uff08\u4e2d\u4f4d\u57fa\u51c6\u6570\u4f18\u5316\uff09 */\n// \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint medianThree(int nums[], int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n// \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09\nint partitionMedian(int nums[], int left, int right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint med = medianThree(nums, left, (left + right) / 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.cs
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint medianThree(int[] nums, int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nint partition(int[] nums, int left, int right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint med = medianThree(nums, left, (left + right) / 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left])\nj--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left])\ni++;          // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);  // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.swift
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -> Int {\nif (nums[left] < nums[mid]) != (nums[left] < nums[right]) {\nreturn left\n} else if (nums[mid] < nums[left]) != (nums[mid] < nums[right]) {\nreturn mid\n} else {\nreturn right\n}\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nfunc partitionMedian(nums: inout [Int], left: Int, right: Int) -> Int {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nlet med = medianThree(nums: nums, left: left, mid: (left + right) / 2, right: right)\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums: &nums, i: left, j: med)\nreturn partition(nums: &nums, left: left, right: right)\n}\n
    quick_sort.zig
    // \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nfn medianThree(nums: []i32, left: usize, mid: usize, right: usize) usize {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) != (nums[left] < nums[right])) {\nreturn left;\n} else if ((nums[mid] < nums[left]) != (nums[mid] < nums[right])) {\nreturn mid;\n} else {\nreturn right;\n}\n}\n// \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09\nfn partition(nums: []i32, left: usize, right: usize) usize {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nvar med = medianThree(nums, left, (left + right) / 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\nswap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nvar i = left;\nvar j = right;\nwhile (i < j) {\nwhile (i < j and nums[j] >= nums[left]) j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j and nums[i] <= nums[left]) i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nswap(nums, i, j);   // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\nswap(nums, i, left);    // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i;               // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.dart
    /* \u9009\u53d6\u4e09\u4e2a\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint _medianThree(List<int> nums, int left, int mid, int right) {\n// \u6b64\u5904\u4f7f\u7528\u5f02\u6216\u8fd0\u7b97\u6765\u7b80\u5316\u4ee3\u7801\n// \u5f02\u6216\u89c4\u5219\u4e3a 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1\nif ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))\nreturn left;\nelse if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))\nreturn mid;\nelse\nreturn right;\n}\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nint _partition(List<int> nums, int left, int right) {\n// \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint med = _medianThree(nums, left, (left + right) ~/ 2, right);\n// \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n_swap(nums, left, med);\n// \u4ee5 nums[left] \u4f5c\u4e3a\u57fa\u51c6\u6570\nint i = left, j = right;\nwhile (i < j) {\nwhile (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\nwhile (i < j && nums[i] <= nums[left]) i++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n_swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n}\n_swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\nreturn i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    "},{"location":"chapter_sorting/quick_sort/#1155","title":"11.5.5. \u00a0 \u5c3e\u9012\u5f52\u4f18\u5316","text":"

    \u5728\u67d0\u4e9b\u8f93\u5165\u4e0b\uff0c\u5feb\u901f\u6392\u5e8f\u53ef\u80fd\u5360\u7528\u7a7a\u95f4\u8f83\u591a\u3002\u4ee5\u5b8c\u5168\u5012\u5e8f\u7684\u8f93\u5165\u6570\u7ec4\u4e3a\u4f8b\uff0c\u7531\u4e8e\u6bcf\u8f6e\u54e8\u5175\u5212\u5206\u540e\u53f3\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a \\(0\\) \uff0c\u9012\u5f52\u6811\u7684\u9ad8\u5ea6\u4f1a\u8fbe\u5230 \\(n - 1\\) \uff0c\u6b64\u65f6\u9700\u8981\u5360\u7528 \\(O(n)\\) \u5927\u5c0f\u7684\u6808\u5e27\u7a7a\u95f4\u3002

    \u4e3a\u4e86\u9632\u6b62\u6808\u5e27\u7a7a\u95f4\u7684\u7d2f\u79ef\uff0c\u6211\u4eec\u53ef\u4ee5\u5728\u6bcf\u8f6e\u54e8\u5175\u6392\u5e8f\u5b8c\u6210\u540e\uff0c\u6bd4\u8f83\u4e24\u4e2a\u5b50\u6570\u7ec4\u7684\u957f\u5ea6\uff0c\u4ec5\u5bf9\u8f83\u77ed\u7684\u5b50\u6570\u7ec4\u8fdb\u884c\u9012\u5f52\u3002\u7531\u4e8e\u8f83\u77ed\u5b50\u6570\u7ec4\u7684\u957f\u5ea6\u4e0d\u4f1a\u8d85\u8fc7 \\(\\frac{n}{2}\\) \uff0c\u56e0\u6b64\u8fd9\u79cd\u65b9\u6cd5\u80fd\u786e\u4fdd\u9012\u5f52\u6df1\u5ea6\u4e0d\u8d85\u8fc7 \\(\\log n\\) \uff0c\u4ece\u800c\u5c06\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u81f3 \\(O(\\log n)\\) \u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart quick_sort.java
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nvoid quickSort(int[] nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nint pivot = partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.cpp
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nvoid quickSort(vector<int> &nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nint pivot = partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1;                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1;                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.py
    def quick_sort(self, nums: list[int], left: int, right: int) -> None:\n\"\"\"\u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09\"\"\"\n# \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile left < right:\n# \u54e8\u5175\u5212\u5206\u64cd\u4f5c\npivot = self.partition(nums, left, right)\n# \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif pivot - left < right - pivot:\nself.quick_sort(nums, left, pivot - 1)  # \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1  # \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\nelse:\nself.quick_sort(nums, pivot + 1, right)  # \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1  # \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n
    quick_sort.go
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09*/\nfunc (q *quickSortTailCall) quickSort(nums []int, left, right int) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nfor left < right {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\npivot := q.partition(nums, left, right)\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif pivot-left < right-pivot {\nq.quickSort(nums, left, pivot-1) // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nq.quickSort(nums, pivot+1, right) // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.js
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nquickSort(nums, left, right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nlet pivot = this.partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nthis.quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nthis.quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.ts
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nquickSort(nums: number[], left: number, right: number): void {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nlet pivot = this.partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nthis.quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nthis.quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.c
    /* \u5feb\u901f\u6392\u5e8f\u7c7b\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\n// \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09\nvoid quickSortTailCall(int nums[], int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nint pivot = partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSortTailCall(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1;                         // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSortTailCall(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1;                         // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.cs
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nvoid quickSort(int[] nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nint pivot = partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSort(nums, left, pivot - 1);  // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1;  // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.swift
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nfunc quickSortTailCall(nums: inout [Int], left: Int, right: Int) {\nvar left = left\nvar right = right\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile left < right {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nlet pivot = partition(nums: &nums, left: left, right: right)\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left) < (right - pivot) {\nquickSortTailCall(nums: &nums, left: left, right: pivot - 1) // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSortTailCall(nums: &nums, left: pivot + 1, right: right) // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.zig
    // \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09\nfn quickSort(nums: []i32, left_: usize, right_: usize) void {\nvar left = left_;\nvar right = right_;\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nvar pivot = partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSort(nums, left, pivot - 1);   // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1;                   // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSort(nums, pivot + 1, right);  // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1;                  // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    quick_sort.dart
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\nvoid quickSort(List<int> nums, int left, int right) {\n// \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\nwhile (left < right) {\n// \u54e8\u5175\u5212\u5206\u64cd\u4f5c\nint pivot = _partition(nums, left, right);\n// \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u6392\nif (pivot - left < right - pivot) {\nquickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\nleft = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n} else {\nquickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\nright = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n}\n}\n}\n
    "},{"location":"chapter_sorting/radix_sort/","title":"11.10. \u00a0 \u57fa\u6570\u6392\u5e8f","text":"

    \u4e0a\u4e00\u8282\u6211\u4eec\u4ecb\u7ecd\u4e86\u8ba1\u6570\u6392\u5e8f\uff0c\u5b83\u9002\u7528\u4e8e\u6570\u636e\u91cf \\(n\\) \u8f83\u5927\u4f46\u6570\u636e\u8303\u56f4 \\(m\\) \u8f83\u5c0f\u7684\u60c5\u51b5\u3002\u5047\u8bbe\u6211\u4eec\u9700\u8981\u5bf9 \\(n = 10^6\\) \u4e2a\u5b66\u53f7\u8fdb\u884c\u6392\u5e8f\uff0c\u800c\u5b66\u53f7\u662f\u4e00\u4e2a \\(8\\) \u4f4d\u6570\u5b57\uff0c\u8fd9\u610f\u5473\u7740\u6570\u636e\u8303\u56f4 \\(m = 10^8\\) \u975e\u5e38\u5927\uff0c\u4f7f\u7528\u8ba1\u6570\u6392\u5e8f\u9700\u8981\u5206\u914d\u5927\u91cf\u5185\u5b58\u7a7a\u95f4\uff0c\u800c\u57fa\u6570\u6392\u5e8f\u53ef\u4ee5\u907f\u514d\u8fd9\u79cd\u60c5\u51b5\u3002

    \u300c\u57fa\u6570\u6392\u5e8f Radix Sort\u300d\u7684\u6838\u5fc3\u601d\u60f3\u4e0e\u8ba1\u6570\u6392\u5e8f\u4e00\u81f4\uff0c\u4e5f\u901a\u8fc7\u7edf\u8ba1\u4e2a\u6570\u6765\u5b9e\u73b0\u6392\u5e8f\u3002\u5728\u6b64\u57fa\u7840\u4e0a\uff0c\u57fa\u6570\u6392\u5e8f\u5229\u7528\u6570\u5b57\u5404\u4f4d\u4e4b\u95f4\u7684\u9012\u8fdb\u5173\u7cfb\uff0c\u4f9d\u6b21\u5bf9\u6bcf\u4e00\u4f4d\u8fdb\u884c\u6392\u5e8f\uff0c\u4ece\u800c\u5f97\u5230\u6700\u7ec8\u7684\u6392\u5e8f\u7ed3\u679c\u3002

    "},{"location":"chapter_sorting/radix_sort/#11101","title":"11.10.1. \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u4ee5\u5b66\u53f7\u6570\u636e\u4e3a\u4f8b\uff0c\u5047\u8bbe\u6570\u5b57\u7684\u6700\u4f4e\u4f4d\u662f\u7b2c \\(1\\) \u4f4d\uff0c\u6700\u9ad8\u4f4d\u662f\u7b2c \\(8\\) \u4f4d\uff0c\u57fa\u6570\u6392\u5e8f\u7684\u6b65\u9aa4\u5982\u4e0b\uff1a

    1. \u521d\u59cb\u5316\u4f4d\u6570 \\(k = 1\\) \uff1b
    2. \u5bf9\u5b66\u53f7\u7684\u7b2c \\(k\\) \u4f4d\u6267\u884c\u300c\u8ba1\u6570\u6392\u5e8f\u300d\u3002\u5b8c\u6210\u540e\uff0c\u6570\u636e\u4f1a\u6839\u636e\u7b2c \\(k\\) \u4f4d\u4ece\u5c0f\u5230\u5927\u6392\u5e8f\uff1b
    3. \u5c06 \\(k\\) \u589e\u52a0 \\(1\\) \uff0c\u7136\u540e\u8fd4\u56de\u6b65\u9aa4 2. \u7ee7\u7eed\u8fed\u4ee3\uff0c\u76f4\u5230\u6240\u6709\u4f4d\u90fd\u6392\u5e8f\u5b8c\u6210\u540e\u7ed3\u675f\uff1b

    Fig. \u57fa\u6570\u6392\u5e8f\u7b97\u6cd5\u6d41\u7a0b

    \u4e0b\u9762\u6765\u5256\u6790\u4ee3\u7801\u5b9e\u73b0\u3002\u5bf9\u4e8e\u4e00\u4e2a \\(d\\) \u8fdb\u5236\u7684\u6570\u5b57 \\(x\\) \uff0c\u8981\u83b7\u53d6\u5176\u7b2c \\(k\\) \u4f4d \\(x_k\\) \uff0c\u53ef\u4ee5\u4f7f\u7528\u4ee5\u4e0b\u8ba1\u7b97\u516c\u5f0f\uff1a

    \\[ x_k = \\lfloor\\frac{x}{d^{k-1}}\\rfloor \\bmod d \\]

    \u5176\u4e2d \\(\\lfloor a \\rfloor\\) \u8868\u793a\u5bf9\u6d6e\u70b9\u6570 \\(a\\) \u5411\u4e0b\u53d6\u6574\uff0c\u800c \\(\\bmod \\space d\\) \u8868\u793a\u5bf9 \\(d\\) \u53d6\u4f59\u3002\u5bf9\u4e8e\u5b66\u53f7\u6570\u636e\uff0c\\(d = 10\\) \u4e14 \\(k \\in [1, 8]\\) \u3002

    \u6b64\u5916\uff0c\u6211\u4eec\u9700\u8981\u5c0f\u5e45\u6539\u52a8\u8ba1\u6570\u6392\u5e8f\u4ee3\u7801\uff0c\u4f7f\u4e4b\u53ef\u4ee5\u6839\u636e\u6570\u5b57\u7684\u7b2c \\(k\\) \u4f4d\u8fdb\u884c\u6392\u5e8f\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart radix_sort.java
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nint digit(int num, int exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nvoid countingSortDigit(int[] nums, int exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nint[] counter = new int[10];\nint n = nums.length;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (int i = 0; i < n; i++) {\nint d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++;                // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (int i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nint[] res = new int[n];\nfor (int i = n - 1; i >= 0; i--) {\nint d = digit(nums[i], exp);\nint j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++)\nnums[i] = res[i];\n}\n/* \u57fa\u6570\u6392\u5e8f */\nvoid radixSort(int[] nums) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nint m = Integer.MIN_VALUE;\nfor (int num : nums)\nif (num > m)\nm = num;\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (int exp = 1; exp <= m; exp *= 10)\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n
    radix_sort.cpp
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nint digit(int num, int exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nvoid countingSortDigit(vector<int> &nums, int exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nvector<int> counter(10, 0);\nint n = nums.size();\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (int i = 0; i < n; i++) {\nint d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++;                // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (int i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nvector<int> res(n, 0);\nfor (int i = n - 1; i >= 0; i--) {\nint d = digit(nums[i], exp);\nint j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++)\nnums[i] = res[i];\n}\n/* \u57fa\u6570\u6392\u5e8f */\nvoid radixSort(vector<int> &nums) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nint m = *max_element(nums.begin(), nums.end());\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (int exp = 1; exp <= m; exp *= 10)\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n
    radix_sort.py
    def digit(num: int, exp: int) -> int:\n\"\"\"\u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1)\"\"\"\n# \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num // exp) % 10\ndef counting_sort_digit(nums: list[int], exp: int) -> None:\n\"\"\"\u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09\"\"\"\n# \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\ncounter = [0] * 10\nn = len(nums)\n# \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor i in range(n):\nd = digit(nums[i], exp)  # \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d] += 1  # \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n# \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor i in range(1, 10):\ncounter[i] += counter[i - 1]\n# \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nres = [0] * n\nfor i in range(n - 1, -1, -1):\nd = digit(nums[i], exp)\nj = counter[d] - 1  # \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i]  # \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d] -= 1  # \u5c06 d \u7684\u6570\u91cf\u51cf 1\n# \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor i in range(n):\nnums[i] = res[i]\ndef radix_sort(nums: list[int]) -> None:\n\"\"\"\u57fa\u6570\u6392\u5e8f\"\"\"\n# \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nm = max(nums)\n# \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nexp = 1\nwhile exp <= m:\n# \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n# k = 1 -> exp = 1\n# k = 2 -> exp = 10\n# \u5373 exp = 10^(k-1)\ncounting_sort_digit(nums, exp)\nexp *= 10\n
    radix_sort.go
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfunc digit(num, exp int) int {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num / exp) % 10\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfunc countingSortDigit(nums []int, exp int) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\ncounter := make([]int, 10)\nn := len(nums)\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor i := 0; i < n; i++ {\nd := digit(nums[i], exp) // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++             // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor i := 1; i < 10; i++ {\ncounter[i] += counter[i-1]\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nres := make([]int, n)\nfor i := n - 1; i >= 0; i-- {\nd := digit(nums[i], exp)\nj := counter[d] - 1 // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i]    // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--        // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor i := 0; i < n; i++ {\nnums[i] = res[i]\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nfunc radixSort(nums []int) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nmax := math.MinInt\nfor _, num := range nums {\nif num > max {\nmax = num\n}\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor exp := 1; max >= exp; exp *= 10 {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp)\n}\n}\n
    radix_sort.js
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfunction digit(num, exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn Math.floor(num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfunction countingSortDigit(nums, exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nconst counter = new Array(10).fill(0);\nconst n = nums.length;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (let i = 0; i < n; i++) {\nconst d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++; // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (let i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nconst res = new Array(n).fill(0);\nfor (let i = n - 1; i >= 0; i--) {\nconst d = digit(nums[i], exp);\nconst j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (let i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nfunction radixSort(nums) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nlet m = Number.MIN_VALUE;\nfor (const num of nums) {\nif (num > m) {\nm = num;\n}\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (let exp = 1; exp <= m; exp *= 10) {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n}\n
    radix_sort.ts
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfunction digit(num: number, exp: number): number {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn Math.floor(num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfunction countingSortDigit(nums: number[], exp: number): void {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nconst counter = new Array(10).fill(0);\nconst n = nums.length;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (let i = 0; i < n; i++) {\nconst d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++; // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (let i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nconst res = new Array(n).fill(0);\nfor (let i = n - 1; i >= 0; i--) {\nconst d = digit(nums[i], exp);\nconst j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (let i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nfunction radixSort(nums: number[]): void {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nlet m = Number.MIN_VALUE;\nfor (const num of nums) {\nif (num > m) {\nm = num;\n}\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (let exp = 1; exp <= m; exp *= 10) {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n}\n
    radix_sort.c
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nint digit(int num, int exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nvoid countingSortDigit(int nums[], int size, int exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nint *counter = (int *)malloc((sizeof(int) * 10));\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (int i = 0; i < size; i++) {\n// \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\nint d = digit(nums[i], exp);\n// \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\ncounter[d]++;\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (int i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nint *res = (int *)malloc(sizeof(int) * size);\nfor (int i = size - 1; i >= 0; i--) {\nint d = digit(nums[i], exp);\nint j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < size; i++) {\nnums[i] = res[i];\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nvoid radixSort(int nums[], int size) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nint max = INT32_MIN;\nfor (size_t i = 0; i < size - 1; i++) {\nif (nums[i] > max) {\nmax = nums[i];\n}\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (int exp = 1; max >= exp; exp *= 10)\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, size, exp);\n}\n
    radix_sort.cs
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nint digit(int num, int exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num / exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nvoid countingSortDigit(int[] nums, int exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nint[] counter = new int[10];\nint n = nums.Length;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (int i = 0; i < n; i++) {\nint d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++;                // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (int i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nint[] res = new int[n];\nfor (int i = n - 1; i >= 0; i--) {\nint d = digit(nums[i], exp);\nint j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++) {\nnums[i] = res[i];\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nvoid radixSort(int[] nums) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nint m = int.MinValue;\nforeach (int num in nums) {\nif (num > m) m = num;\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (int exp = 1; exp <= m; exp *= 10) {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n}\n
    radix_sort.swift
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfunc digit(num: Int, exp: Int) -> Int {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\n(num / exp) % 10\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfunc countingSortDigit(nums: inout [Int], exp: Int) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nvar counter = Array(repeating: 0, count: 10)\nlet n = nums.count\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor i in nums.indices {\nlet d = digit(num: nums[i], exp: exp) // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d] += 1 // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor i in 1 ..< 10 {\ncounter[i] += counter[i - 1]\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nvar res = Array(repeating: 0, count: n)\nfor i in stride(from: n - 1, through: 0, by: -1) {\nlet d = digit(num: nums[i], exp: exp)\nlet j = counter[d] - 1 // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i] // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d] -= 1 // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor i in nums.indices {\nnums[i] = res[i]\n}\n}\n/* \u57fa\u6570\u6392\u5e8f */\nfunc radixSort(nums: inout [Int]) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nvar m = Int.min\nfor num in nums {\nif num > m {\nm = num\n}\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor exp in sequence(first: 1, next: { m >= ($0 * 10) ? $0 * 10 : nil }) {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums: &nums, exp: exp)\n}\n}\n
    radix_sort.zig
    // \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1)\nfn digit(num: i32, exp: i32) i32 {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn @mod(@divFloor(num, exp), 10);\n}\n// \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09\nfn countingSortDigit(nums: []i32, exp: i32) !void {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nvar mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);\n// defer mem_arena.deinit();\nconst mem_allocator = mem_arena.allocator();\nvar counter = try mem_allocator.alloc(usize, 10);\n@memset(counter, 0);\nvar n = nums.len;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (nums) |num| {\nvar d: u32 = @bitCast(digit(num, exp)); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d] += 1; // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nvar i: usize = 1;\nwhile (i < 10) : (i += 1) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nvar res = try mem_allocator.alloc(i32, n);\ni = n - 1;\nwhile (i >= 0) : (i -= 1) {\nvar d: u32 = @bitCast(digit(nums[i], exp));\nvar j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d] -= 1;        // \u5c06 d \u7684\u6570\u91cf\u51cf 1\nif (i == 0) break;\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\ni = 0;\nwhile (i < n) : (i += 1) {\nnums[i] = res[i];\n}\n}\n// \u57fa\u6570\u6392\u5e8f\nfn radixSort(nums: []i32) !void {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\nvar m: i32 = std.math.minInt(i32);\nfor (nums) |num| {\nif (num > m) m = num;\n}\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nvar exp: i32 = 1;\nwhile (exp <= m) : (exp *= 10) {\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ntry countingSortDigit(nums, exp);    }\n}
    radix_sort.dart
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nint digit(int num, int exp) {\n// \u4f20\u5165 exp \u800c\u975e k \u53ef\u4ee5\u907f\u514d\u5728\u6b64\u91cd\u590d\u6267\u884c\u6602\u8d35\u7684\u6b21\u65b9\u8ba1\u7b97\nreturn (num ~/ exp) % 10;\n}\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nvoid countingSortDigit(List<int> nums, int exp) {\n// \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\nList<int> counter = List<int>.filled(10, 0);\nint n = nums.length;\n// \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\nfor (int i = 0; i < n; i++) {\nint d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\ncounter[d]++; // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n}\n// \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\nfor (int i = 1; i < 10; i++) {\ncounter[i] += counter[i - 1];\n}\n// \u5012\u5e8f\u904d\u5386\uff0c\u6839\u636e\u6876\u5185\u7edf\u8ba1\u7ed3\u679c\uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165 res\nList<int> res = List<int>.filled(n, 0);\nfor (int i = n - 1; i >= 0; i--) {\nint d = digit(nums[i], exp);\nint j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\nres[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\ncounter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n}\n// \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\nfor (int i = 0; i < n; i++) nums[i] = res[i];\n}\n/* \u57fa\u6570\u6392\u5e8f */\nvoid radixSort(List<int> nums) {\n// \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\n// dart \u4e2d int \u7684\u957f\u5ea6\u662f 64 \u4f4d\u7684\nint m = -1 << 63; for (int num in nums) if (num > m) m = num;\n// \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\nfor (int exp = 1; exp <= m; exp *= 10)\n// \u5bf9\u6570\u7ec4\u5143\u7d20\u7684\u7b2c k \u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\n// k = 1 -> exp = 1\n// k = 2 -> exp = 10\n// \u5373 exp = 10^(k-1)\ncountingSortDigit(nums, exp);\n}\n

    \u4e3a\u4ec0\u4e48\u4ece\u6700\u4f4e\u4f4d\u5f00\u59cb\u6392\u5e8f\uff1f

    \u5728\u8fde\u7eed\u7684\u6392\u5e8f\u8f6e\u6b21\u4e2d\uff0c\u540e\u4e00\u8f6e\u6392\u5e8f\u4f1a\u8986\u76d6\u524d\u4e00\u8f6e\u6392\u5e8f\u7684\u7ed3\u679c\u3002\u4e3e\u4f8b\u6765\u8bf4\uff0c\u5982\u679c\u7b2c\u4e00\u8f6e\u6392\u5e8f\u7ed3\u679c \\(a < b\\) \uff0c\u800c\u7b2c\u4e8c\u8f6e\u6392\u5e8f\u7ed3\u679c \\(a > b\\) \uff0c\u90a3\u4e48\u7b2c\u4e8c\u8f6e\u7684\u7ed3\u679c\u5c06\u53d6\u4ee3\u7b2c\u4e00\u8f6e\u7684\u7ed3\u679c\u3002\u7531\u4e8e\u6570\u5b57\u7684\u9ad8\u4f4d\u4f18\u5148\u7ea7\u9ad8\u4e8e\u4f4e\u4f4d\uff0c\u6211\u4eec\u5e94\u8be5\u5148\u6392\u5e8f\u4f4e\u4f4d\u518d\u6392\u5e8f\u9ad8\u4f4d\u3002

    "},{"location":"chapter_sorting/radix_sort/#11102","title":"11.10.2. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"

    \u76f8\u8f83\u4e8e\u8ba1\u6570\u6392\u5e8f\uff0c\u57fa\u6570\u6392\u5e8f\u9002\u7528\u4e8e\u6570\u503c\u8303\u56f4\u8f83\u5927\u7684\u60c5\u51b5\uff0c\u4f46\u524d\u63d0\u662f\u6570\u636e\u5fc5\u987b\u53ef\u4ee5\u8868\u793a\u4e3a\u56fa\u5b9a\u4f4d\u6570\u7684\u683c\u5f0f\uff0c\u4e14\u4f4d\u6570\u4e0d\u80fd\u8fc7\u5927\u3002\u4f8b\u5982\uff0c\u6d6e\u70b9\u6570\u4e0d\u9002\u5408\u4f7f\u7528\u57fa\u6570\u6392\u5e8f\uff0c\u56e0\u4e3a\u5176\u4f4d\u6570 \\(k\\) \u8fc7\u5927\uff0c\u53ef\u80fd\u5bfc\u81f4\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(nk) \\gg O(n^2)\\) \u3002

    • \u65f6\u95f4\u590d\u6742\u5ea6 \\(O(nk)\\) \uff1a\u8bbe\u6570\u636e\u91cf\u4e3a \\(n\\) \u3001\u6570\u636e\u4e3a \\(d\\) \u8fdb\u5236\u3001\u6700\u5927\u4f4d\u6570\u4e3a \\(k\\) \uff0c\u5219\u5bf9\u67d0\u4e00\u4f4d\u6267\u884c\u8ba1\u6570\u6392\u5e8f\u4f7f\u7528 \\(O(n + d)\\) \u65f6\u95f4\uff0c\u6392\u5e8f\u6240\u6709 \\(k\\) \u4f4d\u4f7f\u7528 \\(O((n + d)k)\\) \u65f6\u95f4\u3002\u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\\(d\\) \u548c \\(k\\) \u90fd\u76f8\u5bf9\u8f83\u5c0f\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u8d8b\u5411 \\(O(n)\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(n + d)\\) \u3001\u975e\u539f\u5730\u6392\u5e8f \uff1a\u4e0e\u8ba1\u6570\u6392\u5e8f\u76f8\u540c\uff0c\u57fa\u6570\u6392\u5e8f\u9700\u8981\u501f\u52a9\u957f\u5ea6\u4e3a \\(n\\) \u548c \\(d\\) \u7684\u6570\u7ec4 res \u548c counter \u3002
    • \u7a33\u5b9a\u6392\u5e8f\uff1a\u4e0e\u8ba1\u6570\u6392\u5e8f\u76f8\u540c\u3002
    "},{"location":"chapter_sorting/selection_sort/","title":"11.2. \u00a0 \u9009\u62e9\u6392\u5e8f","text":"

    \u300c\u9009\u62e9\u6392\u5e8f Selection Sort\u300d\u7684\u5de5\u4f5c\u539f\u7406\u975e\u5e38\u76f4\u63a5\uff1a\u5f00\u542f\u4e00\u4e2a\u5faa\u73af\uff0c\u6bcf\u8f6e\u4ece\u672a\u6392\u5e8f\u533a\u95f4\u9009\u62e9\u6700\u5c0f\u7684\u5143\u7d20\uff0c\u5c06\u5176\u653e\u5230\u5df2\u6392\u5e8f\u533a\u95f4\u7684\u672b\u5c3e\u3002

    \u8bbe\u6570\u7ec4\u7684\u957f\u5ea6\u4e3a \\(n\\) \uff0c\u9009\u62e9\u6392\u5e8f\u7684\u7b97\u6cd5\u6d41\u7a0b\u5982\u4e0b\uff1a

    1. \u521d\u59cb\u72b6\u6001\u4e0b\uff0c\u6240\u6709\u5143\u7d20\u672a\u6392\u5e8f\uff0c\u5373\u672a\u6392\u5e8f\uff08\u7d22\u5f15\uff09\u533a\u95f4\u4e3a \\([0, n-1]\\) \u3002
    2. \u9009\u53d6\u533a\u95f4 \\([0, n-1]\\) \u4e2d\u7684\u6700\u5c0f\u5143\u7d20\uff0c\u5c06\u5176\u4e0e\u7d22\u5f15 \\(0\\) \u5904\u5143\u7d20\u4ea4\u6362\u3002\u5b8c\u6210\u540e\uff0c\u6570\u7ec4\u524d 1 \u4e2a\u5143\u7d20\u5df2\u6392\u5e8f\u3002
    3. \u9009\u53d6\u533a\u95f4 \\([1, n-1]\\) \u4e2d\u7684\u6700\u5c0f\u5143\u7d20\uff0c\u5c06\u5176\u4e0e\u7d22\u5f15 \\(1\\) \u5904\u5143\u7d20\u4ea4\u6362\u3002\u5b8c\u6210\u540e\uff0c\u6570\u7ec4\u524d 2 \u4e2a\u5143\u7d20\u5df2\u6392\u5e8f\u3002
    4. \u4ee5\u6b64\u7c7b\u63a8\u3002\u7ecf\u8fc7 \\(n - 1\\) \u8f6e\u9009\u62e9\u4e0e\u4ea4\u6362\u540e\uff0c\u6570\u7ec4\u524d \\(n - 1\\) \u4e2a\u5143\u7d20\u5df2\u6392\u5e8f\u3002
    5. \u4ec5\u5269\u7684\u4e00\u4e2a\u5143\u7d20\u5fc5\u5b9a\u662f\u6700\u5927\u5143\u7d20\uff0c\u65e0\u9700\u6392\u5e8f\uff0c\u56e0\u6b64\u6570\u7ec4\u6392\u5e8f\u5b8c\u6210\u3002
    <1><2><3><4><5><6><7><8><9><10><11>

    \u5728\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u7528 \\(k\\) \u6765\u8bb0\u5f55\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart selection_sort.java
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(int[] nums) {\nint n = nums.length;\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (int i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nint k = i;\nfor (int j = i + 1; j < n; j++) {\nif (nums[j] < nums[k])\nk = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nint temp = nums[i];\nnums[i] = nums[k];\nnums[k] = temp;\n}\n}\n
    selection_sort.cpp
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(vector<int> &nums) {\nint n = nums.size();\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (int i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nint k = i;\nfor (int j = i + 1; j < n; j++) {\nif (nums[j] < nums[k])\nk = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nswap(nums[i], nums[k]);\n}\n}\n
    selection_sort.py
    def selection_sort(nums: list[int]):\n\"\"\"\u9009\u62e9\u6392\u5e8f\"\"\"\nn = len(nums)\n# \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor i in range(n - 1):\n# \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nk = i\nfor j in range(i + 1, n):\nif nums[j] < nums[k]:\nk = j  # \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n# \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nnums[i], nums[k] = nums[k], nums[i]\n
    selection_sort.go
    /* \u9009\u62e9\u6392\u5e8f */\nfunc selectionSort(nums []int) {\nn := len(nums)\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor i := 0; i < n-1; i++ {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nk := i\nfor j := i + 1; j < n; j++ {\nif nums[j] < nums[k] {\n// \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\nk = j\n}\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nnums[i], nums[k] = nums[k], nums[i]\n}\n}\n
    selection_sort.js
    /* \u9009\u62e9\u6392\u5e8f */\nfunction selectionSort(nums) {\nlet n = nums.length;\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (let i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nlet k = i;\nfor (let j = i + 1; j < n; j++) {\nif (nums[j] < nums[k]) {\nk = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\n[nums[i], nums[k]] = [nums[k], nums[i]];\n}\n}\n
    selection_sort.ts
    /* \u9009\u62e9\u6392\u5e8f */\nfunction selectionSort(nums: number[]): void {\nlet n = nums.length;\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (let i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nlet k = i;\nfor (let j = i + 1; j < n; j++) {\nif (nums[j] < nums[k]) {\nk = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\n[nums[i], nums[k]] = [nums[k], nums[i]];\n}\n}\n
    selection_sort.c
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(int nums[], int n) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (int i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nint k = i;\nfor (int j = i + 1; j < n; j++) {\nif (nums[j] < nums[k])\nk = j;  // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nint temp = nums[i];\nnums[i] = nums[k];\nnums[k] = temp;\n}\n}\n
    selection_sort.cs
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(int[] nums) {\nint n = nums.Length;\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (int i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nint k = i;\nfor (int j = i + 1; j < n; j++) {\nif (nums[j] < nums[k])\nk = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\n(nums[k], nums[i]) = (nums[i], nums[k]);\n}\n}\n
    selection_sort.swift
    /* \u9009\u62e9\u6392\u5e8f */\nfunc selectionSort(nums: inout [Int]) {\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor i in nums.indices.dropLast() {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nvar k = i\nfor j in nums.indices.dropFirst(i + 1) {\nif nums[j] < nums[k] {\nk = j // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nnums.swapAt(i, k)\n}\n}\n
    selection_sort.zig
    [class]{}-[func]{selectionSort}\n
    selection_sort.dart
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(List<int> nums) {\nint n = nums.length;\n// \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\nfor (int i = 0; i < n - 1; i++) {\n// \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\nint k = i;\nfor (int j = i + 1; j < n; j++) {\nif (nums[j] < nums[k]) k = j; // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n}\n// \u5c06\u8be5\u6700\u5c0f\u5143\u7d20\u4e0e\u672a\u6392\u5e8f\u533a\u95f4\u7684\u9996\u4e2a\u5143\u7d20\u4ea4\u6362\nint temp = nums[i];\nnums[i] = nums[k];\nnums[k] = temp;\n}\n}\n
    "},{"location":"chapter_sorting/selection_sort/#1121","title":"11.2.1. \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3001\u975e\u81ea\u9002\u5e94\u6392\u5e8f\uff1a\u5916\u5faa\u73af\u5171 \\(n - 1\\) \u8f6e\uff0c\u7b2c\u4e00\u8f6e\u7684\u672a\u6392\u5e8f\u533a\u95f4\u957f\u5ea6\u4e3a \\(n\\) \uff0c\u6700\u540e\u4e00\u8f6e\u7684\u672a\u6392\u5e8f\u533a\u95f4\u957f\u5ea6\u4e3a \\(2\\) \uff0c\u5373\u5404\u8f6e\u5916\u5faa\u73af\u5206\u522b\u5305\u542b \\(n\\) , \\(n - 1\\) , \\(\\cdots\\) , \\(2\\) \u8f6e\u5185\u5faa\u73af\uff0c\u6c42\u548c\u4e3a \\(\\frac{(n - 1)(n + 2)}{2}\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6 \\(O(1)\\) \u3001\u539f\u5730\u6392\u5e8f\uff1a\u6307\u9488 \\(i\\) , \\(j\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u975e\u7a33\u5b9a\u6392\u5e8f\uff1a\u5728\u4ea4\u6362\u5143\u7d20\u65f6\uff0c\u6709\u53ef\u80fd\u5c06 nums[i] \u4ea4\u6362\u81f3\u5176\u76f8\u7b49\u5143\u7d20\u7684\u53f3\u8fb9\uff0c\u5bfc\u81f4\u4e24\u8005\u7684\u76f8\u5bf9\u987a\u5e8f\u53d1\u751f\u6539\u53d8\u3002

    Fig. \u9009\u62e9\u6392\u5e8f\u975e\u7a33\u5b9a\u793a\u4f8b

    "},{"location":"chapter_sorting/sorting_algorithm/","title":"11.1. \u00a0 \u6392\u5e8f\u7b97\u6cd5","text":"

    \u300c\u6392\u5e8f\u7b97\u6cd5 Sorting Algorithm\u300d\u7528\u4e8e\u5bf9\u4e00\u7ec4\u6570\u636e\u6309\u7167\u7279\u5b9a\u987a\u5e8f\u8fdb\u884c\u6392\u5217\u3002\u6392\u5e8f\u7b97\u6cd5\u6709\u7740\u5e7f\u6cdb\u7684\u5e94\u7528\uff0c\u56e0\u4e3a\u6709\u5e8f\u6570\u636e\u901a\u5e38\u80fd\u591f\u88ab\u66f4\u6709\u6548\u5730\u67e5\u627e\u3001\u5206\u6790\u548c\u5904\u7406\u3002

    \u5728\u6392\u5e8f\u7b97\u6cd5\u4e2d\uff0c\u6570\u636e\u7c7b\u578b\u53ef\u4ee5\u662f\u6574\u6570\u3001\u6d6e\u70b9\u6570\u3001\u5b57\u7b26\u6216\u5b57\u7b26\u4e32\u7b49\uff1b\u987a\u5e8f\u7684\u5224\u65ad\u89c4\u5219\u53ef\u6839\u636e\u9700\u6c42\u8bbe\u5b9a\uff0c\u5982\u6570\u5b57\u5927\u5c0f\u3001\u5b57\u7b26 ASCII \u7801\u987a\u5e8f\u6216\u81ea\u5b9a\u4e49\u89c4\u5219\u3002

    Fig. \u6570\u636e\u7c7b\u578b\u548c\u5224\u65ad\u89c4\u5219\u793a\u4f8b

    "},{"location":"chapter_sorting/sorting_algorithm/#1111","title":"11.1.1. \u00a0 \u8bc4\u4ef7\u7ef4\u5ea6","text":"

    \u8fd0\u884c\u6548\u7387\uff1a\u6211\u4eec\u671f\u671b\u6392\u5e8f\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5c3d\u91cf\u4f4e\uff0c\u4e14\u603b\u4f53\u64cd\u4f5c\u6570\u91cf\u8f83\u5c11\uff08\u5373\u65f6\u95f4\u590d\u6742\u5ea6\u4e2d\u7684\u5e38\u6570\u9879\u964d\u4f4e\uff09\u3002\u5bf9\u4e8e\u5927\u6570\u636e\u91cf\u60c5\u51b5\uff0c\u8fd0\u884c\u6548\u7387\u663e\u5f97\u5c24\u4e3a\u91cd\u8981\u3002

    \u5c31\u5730\u6027\uff1a\u987e\u540d\u601d\u4e49\uff0c\u300c\u539f\u5730\u6392\u5e8f\u300d\u901a\u8fc7\u5728\u539f\u6570\u7ec4\u4e0a\u76f4\u63a5\u64cd\u4f5c\u5b9e\u73b0\u6392\u5e8f\uff0c\u65e0\u9700\u501f\u52a9\u989d\u5916\u7684\u8f85\u52a9\u6570\u7ec4\uff0c\u4ece\u800c\u8282\u7701\u5185\u5b58\u3002\u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\u539f\u5730\u6392\u5e8f\u7684\u6570\u636e\u642c\u8fd0\u64cd\u4f5c\u8f83\u5c11\uff0c\u8fd0\u884c\u901f\u5ea6\u4e5f\u66f4\u5feb\u3002

    \u7a33\u5b9a\u6027\uff1a\u300c\u7a33\u5b9a\u6392\u5e8f\u300d\u5728\u5b8c\u6210\u6392\u5e8f\u540e\uff0c\u76f8\u7b49\u5143\u7d20\u5728\u6570\u7ec4\u4e2d\u7684\u76f8\u5bf9\u987a\u5e8f\u4e0d\u53d1\u751f\u6539\u53d8\u3002\u7a33\u5b9a\u6392\u5e8f\u662f\u4f18\u826f\u7279\u6027\uff0c\u4e5f\u662f\u591a\u7ea7\u6392\u5e8f\u573a\u666f\u7684\u5fc5\u8981\u6761\u4ef6\u3002

    \u5047\u8bbe\u6211\u4eec\u6709\u4e00\u4e2a\u5b58\u50a8\u5b66\u751f\u4fe1\u606f\u7684\u8868\u683c\uff0c\u7b2c 1, 2 \u5217\u5206\u522b\u662f\u59d3\u540d\u548c\u5e74\u9f84\u3002\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u300c\u975e\u7a33\u5b9a\u6392\u5e8f\u300d\u53ef\u80fd\u5bfc\u81f4\u8f93\u5165\u6570\u636e\u7684\u6709\u5e8f\u6027\u4e27\u5931\u3002

    # \u8f93\u5165\u6570\u636e\u662f\u6309\u7167\u59d3\u540d\u6392\u5e8f\u597d\u7684\n# (name, age)\n('A', 19)\n('B', 18)\n('C', 21)\n('D', 19)\n('E', 23)\n# \u5047\u8bbe\u4f7f\u7528\u975e\u7a33\u5b9a\u6392\u5e8f\u7b97\u6cd5\u6309\u5e74\u9f84\u6392\u5e8f\u5217\u8868\uff0c\n# \u7ed3\u679c\u4e2d ('D', 19) \u548c ('A', 19) \u7684\u76f8\u5bf9\u4f4d\u7f6e\u6539\u53d8\uff0c\n# \u8f93\u5165\u6570\u636e\u6309\u59d3\u540d\u6392\u5e8f\u7684\u6027\u8d28\u4e22\u5931\n('B', 18)\n('D', 19)\n('A', 19)\n('C', 21)\n('E', 23)\n

    \u81ea\u9002\u5e94\u6027\uff1a\u300c\u81ea\u9002\u5e94\u6392\u5e8f\u300d\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4f1a\u53d7\u8f93\u5165\u6570\u636e\u7684\u5f71\u54cd\uff0c\u5373\u6700\u4f73\u3001\u6700\u5dee\u3001\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u5e76\u4e0d\u5b8c\u5168\u76f8\u7b49\u3002

    \u81ea\u9002\u5e94\u6027\u9700\u8981\u6839\u636e\u5177\u4f53\u60c5\u51b5\u6765\u8bc4\u4f30\u3002\u5982\u679c\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u5dee\u4e8e\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u8bf4\u660e\u6392\u5e8f\u7b97\u6cd5\u5728\u67d0\u4e9b\u6570\u636e\u4e0b\u6027\u80fd\u53ef\u80fd\u52a3\u5316\uff0c\u56e0\u6b64\u88ab\u89c6\u4e3a\u8d1f\u9762\u5c5e\u6027\uff1b\u800c\u5982\u679c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u4f18\u4e8e\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u5219\u88ab\u89c6\u4e3a\u6b63\u9762\u5c5e\u6027\u3002

    \u662f\u5426\u57fa\u4e8e\u6bd4\u8f83\uff1a\u300c\u57fa\u4e8e\u6bd4\u8f83\u7684\u6392\u5e8f\u300d\u4f9d\u8d56\u4e8e\u6bd4\u8f83\u8fd0\u7b97\u7b26\uff08\\(<\\) , \\(=\\) , \\(>\\)\uff09\u6765\u5224\u65ad\u5143\u7d20\u7684\u76f8\u5bf9\u987a\u5e8f\uff0c\u4ece\u800c\u6392\u5e8f\u6574\u4e2a\u6570\u7ec4\uff0c\u7406\u8bba\u6700\u4f18\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002\u800c\u300c\u975e\u6bd4\u8f83\u6392\u5e8f\u300d\u4e0d\u4f7f\u7528\u6bd4\u8f83\u8fd0\u7b97\u7b26\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u8fbe \\(O(n)\\) \uff0c\u4f46\u5176\u901a\u7528\u6027\u76f8\u5bf9\u8f83\u5dee\u3002

    "},{"location":"chapter_sorting/sorting_algorithm/#1112","title":"11.1.2. \u00a0 \u7406\u60f3\u6392\u5e8f\u7b97\u6cd5","text":"

    \u8fd0\u884c\u5feb\u3001\u539f\u5730\u3001\u7a33\u5b9a\u3001\u6b63\u5411\u81ea\u9002\u5e94\u3001\u901a\u7528\u6027\u597d\u3002\u663e\u7136\uff0c\u8fc4\u4eca\u4e3a\u6b62\u5c1a\u672a\u53d1\u73b0\u517c\u5177\u4ee5\u4e0a\u6240\u6709\u7279\u6027\u7684\u6392\u5e8f\u7b97\u6cd5\u3002\u56e0\u6b64\uff0c\u5728\u9009\u62e9\u6392\u5e8f\u7b97\u6cd5\u65f6\uff0c\u9700\u8981\u6839\u636e\u5177\u4f53\u7684\u6570\u636e\u7279\u70b9\u548c\u95ee\u9898\u9700\u6c42\u6765\u51b3\u5b9a\u3002

    \u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c06\u5171\u540c\u5b66\u4e60\u5404\u79cd\u6392\u5e8f\u7b97\u6cd5\uff0c\u5e76\u57fa\u4e8e\u4e0a\u8ff0\u8bc4\u4ef7\u7ef4\u5ea6\u5bf9\u5404\u4e2a\u6392\u5e8f\u7b97\u6cd5\u7684\u4f18\u7f3a\u70b9\u8fdb\u884c\u5206\u6790\u3002

    "},{"location":"chapter_sorting/summary/","title":"11.11. \u00a0 \u5c0f\u7ed3","text":"
    • \u5192\u6ce1\u6392\u5e8f\u901a\u8fc7\u4ea4\u6362\u76f8\u90bb\u5143\u7d20\u6765\u5b9e\u73b0\u6392\u5e8f\u3002\u901a\u8fc7\u6dfb\u52a0\u4e00\u4e2a\u6807\u5fd7\u4f4d\u6765\u5b9e\u73b0\u63d0\u524d\u8fd4\u56de\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5192\u6ce1\u6392\u5e8f\u7684\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u5230 \\(O(n)\\) \u3002
    • \u63d2\u5165\u6392\u5e8f\u6bcf\u8f6e\u5c06\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u5143\u7d20\u63d2\u5165\u5230\u5df2\u6392\u5e8f\u533a\u95f4\u7684\u6b63\u786e\u4f4d\u7f6e\uff0c\u4ece\u800c\u5b8c\u6210\u6392\u5e8f\u3002\u867d\u7136\u63d2\u5165\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff0c\u4f46\u7531\u4e8e\u5355\u5143\u64cd\u4f5c\u76f8\u5bf9\u8f83\u5c11\uff0c\u5b83\u5728\u5c0f\u6570\u636e\u91cf\u7684\u6392\u5e8f\u4efb\u52a1\u4e2d\u975e\u5e38\u53d7\u6b22\u8fce\u3002
    • \u5feb\u901f\u6392\u5e8f\u57fa\u4e8e\u54e8\u5175\u5212\u5206\u64cd\u4f5c\u5b9e\u73b0\u6392\u5e8f\u3002\u5728\u54e8\u5175\u5212\u5206\u4e2d\uff0c\u6709\u53ef\u80fd\u6bcf\u6b21\u90fd\u9009\u53d6\u5230\u6700\u5dee\u7684\u57fa\u51c6\u6570\uff0c\u5bfc\u81f4\u65f6\u95f4\u590d\u6742\u5ea6\u52a3\u5316\u81f3 \\(O(n^2)\\) \u3002\u5f15\u5165\u4e2d\u4f4d\u6570\u57fa\u51c6\u6570\u6216\u968f\u673a\u57fa\u51c6\u6570\u53ef\u4ee5\u964d\u4f4e\u8fd9\u79cd\u52a3\u5316\u7684\u6982\u7387\u3002\u5c3e\u9012\u5f52\u65b9\u6cd5\u53ef\u4ee5\u6709\u6548\u5730\u51cf\u5c11\u9012\u5f52\u6df1\u5ea6\uff0c\u5c06\u7a7a\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u5230 \\(O(\\log n)\\) \u3002
    • \u5f52\u5e76\u6392\u5e8f\u5305\u62ec\u5212\u5206\u548c\u5408\u5e76\u4e24\u4e2a\u9636\u6bb5\uff0c\u5178\u578b\u5730\u4f53\u73b0\u4e86\u5206\u6cbb\u7b56\u7565\u3002\u5728\u5f52\u5e76\u6392\u5e8f\u4e2d\uff0c\u6392\u5e8f\u6570\u7ec4\u9700\u8981\u521b\u5efa\u8f85\u52a9\u6570\u7ec4\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff1b\u7136\u800c\u6392\u5e8f\u94fe\u8868\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u4f18\u5316\u81f3 \\(O(1)\\) \u3002
    • \u6876\u6392\u5e8f\u5305\u542b\u4e09\u4e2a\u6b65\u9aa4\uff1a\u6570\u636e\u5206\u6876\u3001\u6876\u5185\u6392\u5e8f\u548c\u5408\u5e76\u7ed3\u679c\u3002\u5b83\u540c\u6837\u4f53\u73b0\u4e86\u5206\u6cbb\u7b56\u7565\uff0c\u9002\u7528\u4e8e\u6570\u636e\u4f53\u91cf\u5f88\u5927\u7684\u60c5\u51b5\u3002\u6876\u6392\u5e8f\u7684\u5173\u952e\u5728\u4e8e\u5bf9\u6570\u636e\u8fdb\u884c\u5e73\u5747\u5206\u914d\u3002
    • \u8ba1\u6570\u6392\u5e8f\u662f\u6876\u6392\u5e8f\u7684\u4e00\u4e2a\u7279\u4f8b\uff0c\u5b83\u901a\u8fc7\u7edf\u8ba1\u6570\u636e\u51fa\u73b0\u7684\u6b21\u6570\u6765\u5b9e\u73b0\u6392\u5e8f\u3002\u8ba1\u6570\u6392\u5e8f\u9002\u7528\u4e8e\u6570\u636e\u91cf\u5927\u4f46\u6570\u636e\u8303\u56f4\u6709\u9650\u7684\u60c5\u51b5\uff0c\u5e76\u4e14\u8981\u6c42\u6570\u636e\u80fd\u591f\u8f6c\u6362\u4e3a\u6b63\u6574\u6570\u3002
    • \u57fa\u6570\u6392\u5e8f\u901a\u8fc7\u9010\u4f4d\u6392\u5e8f\u6765\u5b9e\u73b0\u6570\u636e\u6392\u5e8f\uff0c\u8981\u6c42\u6570\u636e\u80fd\u591f\u8868\u793a\u4e3a\u56fa\u5b9a\u4f4d\u6570\u7684\u6570\u5b57\u3002

    Fig. \u6392\u5e8f\u7b97\u6cd5\u5bf9\u6bd4

    • \u603b\u7684\u6765\u8bf4\uff0c\u6211\u4eec\u5e0c\u671b\u627e\u5230\u4e00\u79cd\u6392\u5e8f\u7b97\u6cd5\uff0c\u5177\u6709\u9ad8\u6548\u7387\u3001\u7a33\u5b9a\u3001\u539f\u5730\u4ee5\u53ca\u6b63\u5411\u81ea\u9002\u5e94\u6027\u7b49\u4f18\u70b9\u3002\u7136\u800c\uff0c\u6b63\u5982\u5176\u4ed6\u6570\u636e\u7ed3\u6784\u548c\u7b97\u6cd5\u4e00\u6837\uff0c\u6ca1\u6709\u4e00\u79cd\u6392\u5e8f\u7b97\u6cd5\u80fd\u591f\u540c\u65f6\u6ee1\u8db3\u6240\u6709\u8fd9\u4e9b\u6761\u4ef6\u3002\u5728\u5b9e\u9645\u5e94\u7528\u4e2d\uff0c\u6211\u4eec\u9700\u8981\u6839\u636e\u6570\u636e\u7684\u7279\u6027\u6765\u9009\u62e9\u5408\u9002\u7684\u6392\u5e8f\u7b97\u6cd5\u3002
    "},{"location":"chapter_sorting/summary/#11111-q-a","title":"11.11.1. \u00a0 Q & A","text":"

    \u6392\u5e8f\u7b97\u6cd5\u7a33\u5b9a\u6027\u5728\u4ec0\u4e48\u60c5\u51b5\u4e0b\u662f\u5fc5\u987b\u7684\uff1f

    \u5728\u73b0\u5b9e\u4e2d\uff0c\u6211\u4eec\u6709\u53ef\u80fd\u662f\u5728\u5bf9\u8c61\u7684\u67d0\u4e2a\u5c5e\u6027\u4e0a\u8fdb\u884c\u6392\u5e8f\u3002\u4f8b\u5982\uff0c\u5b66\u751f\u6709\u59d3\u540d\u548c\u8eab\u9ad8\u4e24\u4e2a\u5c5e\u6027\uff0c\u6211\u4eec\u5e0c\u671b\u5b9e\u73b0\u4e00\u4e2a\u591a\u7ea7\u6392\u5e8f/

    \u5148\u6309\u7167\u59d3\u540d\u8fdb\u884c\u6392\u5e8f\uff0c\u5f97\u5230 (A, 180) (B, 185) (C, 170) (D, 170) \uff1b\u63a5\u4e0b\u6765\u5bf9\u8eab\u9ad8\u8fdb\u884c\u6392\u5e8f\u3002\u7531\u4e8e\u6392\u5e8f\u7b97\u6cd5\u4e0d\u7a33\u5b9a\uff0c\u6211\u4eec\u53ef\u80fd\u5f97\u5230 (D, 170) (C, 170) (A, 180) (B, 185) \u3002

    \u53ef\u4ee5\u53d1\u73b0\uff0c\u5b66\u751f D \u548c C \u7684\u4f4d\u7f6e\u53d1\u751f\u4e86\u4ea4\u6362\uff0c\u59d3\u540d\u7684\u6709\u5e8f\u6027\u88ab\u7834\u574f\u4e86\uff0c\u800c\u8fd9\u662f\u6211\u4eec\u4e0d\u5e0c\u671b\u770b\u5230\u7684\u3002

    \u54e8\u5175\u5212\u5206\u4e2d\u201c\u4ece\u53f3\u5f80\u5de6\u67e5\u627e\u201d\u4e0e\u201c\u4ece\u5de6\u5f80\u53f3\u67e5\u627e\u201d\u7684\u987a\u5e8f\u53ef\u4ee5\u4ea4\u6362\u5417\uff1f

    \u4e0d\u884c\uff0c\u5f53\u6211\u4eec\u4ee5\u6700\u5de6\u7aef\u5143\u7d20\u4e3a\u57fa\u51c6\u6570\u65f6\uff0c\u5fc5\u987b\u5148\u201c\u4ece\u53f3\u5f80\u5de6\u67e5\u627e\u201d\u518d\u201c\u4ece\u5de6\u5f80\u53f3\u67e5\u627e\u201d\u3002\u8fd9\u4e2a\u7ed3\u8bba\u6709\u4e9b\u53cd\u76f4\u89c9\uff0c\u6211\u4eec\u6765\u5256\u6790\u4e00\u4e0b\u539f\u56e0\u3002

    \u54e8\u5175\u5212\u5206 partition() \u7684\u6700\u540e\u4e00\u6b65\u662f\u4ea4\u6362 nums[left] \u548c nums[i] \u3002\u5b8c\u6210\u4ea4\u6362\u540e\uff0c\u57fa\u51c6\u6570\u5de6\u8fb9\u7684\u5143\u7d20\u90fd <= \u57fa\u51c6\u6570\uff0c\u8fd9\u5c31\u8981\u6c42\u6700\u540e\u4e00\u6b65\u4ea4\u6362\u524d nums[left] >= nums[i] \u5fc5\u987b\u6210\u7acb\u3002\u5047\u8bbe\u6211\u4eec\u5148\u201c\u4ece\u5de6\u5f80\u53f3\u67e5\u627e\u201d\uff0c\u90a3\u4e48\u5982\u679c\u627e\u4e0d\u5230\u6bd4\u57fa\u51c6\u6570\u66f4\u5c0f\u7684\u5143\u7d20\uff0c\u5219\u4f1a\u5728 i == j \u65f6\u8df3\u51fa\u5faa\u73af\uff0c\u6b64\u65f6\u53ef\u80fd nums[j] == nums[i] > nums[left]\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u6b64\u65f6\u6700\u540e\u4e00\u6b65\u4ea4\u6362\u64cd\u4f5c\u4f1a\u628a\u4e00\u4e2a\u6bd4\u57fa\u51c6\u6570\u66f4\u5927\u7684\u5143\u7d20\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\uff0c\u5bfc\u81f4\u54e8\u5175\u5212\u5206\u5931\u8d25\u3002

    \u4e3e\u4e2a\u4f8b\u5b50\uff0c\u7ed9\u5b9a\u6570\u7ec4 [0, 0, 0, 0, 1] \uff0c\u5982\u679c\u5148\u201c\u4ece\u5de6\u5411\u53f3\u67e5\u627e\u201d\uff0c\u54e8\u5175\u5212\u5206\u540e\u6570\u7ec4\u4e3a [1, 0, 0, 0, 0] \uff0c\u8fd9\u4e2a\u7ed3\u679c\u662f\u4e0d\u6b63\u786e\u7684\u3002

    \u518d\u6df1\u5165\u601d\u8003\u4e00\u4e0b\uff0c\u5982\u679c\u6211\u4eec\u9009\u62e9 nums[right] \u4e3a\u57fa\u51c6\u6570\uff0c\u90a3\u4e48\u6b63\u597d\u53cd\u8fc7\u6765\uff0c\u5fc5\u987b\u5148\u201c\u4ece\u5de6\u5f80\u53f3\u67e5\u627e\u201d\u3002

    \u5173\u4e8e\u5c3e\u9012\u5f52\u4f18\u5316\uff0c\u4e3a\u4ec0\u4e48\u9009\u77ed\u7684\u6570\u7ec4\u80fd\u4fdd\u8bc1\u9012\u5f52\u6df1\u5ea6\u4e0d\u8d85\u8fc7 \\(log n\\) \uff1f

    \u9012\u5f52\u6df1\u5ea6\u5c31\u662f\u5f53\u524d\u672a\u8fd4\u56de\u7684\u9012\u5f52\u65b9\u6cd5\u7684\u6570\u91cf\u3002\u6bcf\u8f6e\u54e8\u5175\u5212\u5206\u6211\u4eec\u5c06\u539f\u6570\u7ec4\u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\u3002\u5728\u5c3e\u9012\u5f52\u4f18\u5316\u540e\uff0c\u5411\u4e0b\u9012\u5f52\u7684\u5b50\u6570\u7ec4\u957f\u5ea6\u6700\u5927\u4e3a\u539f\u6570\u7ec4\u7684\u4e00\u534a\u957f\u5ea6\u3002\u5047\u8bbe\u6700\u5dee\u60c5\u51b5\uff0c\u4e00\u76f4\u4e3a\u4e00\u534a\u957f\u5ea6\uff0c\u90a3\u4e48\u6700\u7ec8\u7684\u9012\u5f52\u6df1\u5ea6\u5c31\u662f \\(log n\\) \u3002

    \u56de\u987e\u539f\u59cb\u7684\u5feb\u901f\u6392\u5e8f\uff0c\u6211\u4eec\u6709\u53ef\u80fd\u4f1a\u8fde\u7eed\u5730\u9012\u5f52\u957f\u5ea6\u8f83\u5927\u7684\u6570\u7ec4\uff0c\u6700\u5dee\u60c5\u51b5\u4e0b\u4e3a \\(n, n - 1, n - 2, ..., 2, 1\\) \uff0c\u4ece\u800c\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \u3002\u5c3e\u9012\u5f52\u4f18\u5316\u53ef\u4ee5\u907f\u514d\u8fd9\u79cd\u60c5\u51b5\u7684\u51fa\u73b0\u3002

    \u5f53\u6570\u7ec4\u4e2d\u6240\u6709\u5143\u7d20\u90fd\u76f8\u7b49\u65f6\uff0c\u5feb\u901f\u6392\u5e8f\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(n^2)\\) \u5417\uff1f\u8be5\u5982\u4f55\u5904\u7406\u8fd9\u79cd\u9000\u5316\u60c5\u51b5\uff1f

    \u662f\u7684\u3002\u8fd9\u79cd\u60c5\u51b5\u53ef\u4ee5\u8003\u8651\u901a\u8fc7\u54e8\u5175\u5212\u5206\u5c06\u6570\u7ec4\u5212\u5206\u4e3a\u4e09\u4e2a\u90e8\u5206\uff1a\u5c0f\u4e8e\u3001\u7b49\u4e8e\u3001\u5927\u4e8e\u57fa\u51c6\u6570\u3002\u4ec5\u5411\u4e0b\u9012\u5f52\u5c0f\u4e8e\u548c\u5927\u4e8e\u7684\u4e24\u90e8\u5206\u3002\u5728\u8be5\u65b9\u6cd5\u4e0b\uff0c\u8f93\u5165\u5143\u7d20\u5168\u90e8\u76f8\u7b49\u7684\u6570\u7ec4\uff0c\u4ec5\u4e00\u8f6e\u54e8\u5175\u5212\u5206\u5373\u53ef\u5b8c\u6210\u6392\u5e8f\u3002

    \u6876\u6392\u5e8f\u7684\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a\u4ec0\u4e48\u662f \\(O(n^2)\\) \uff1f

    \u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u6240\u6709\u5143\u7d20\u88ab\u5206\u81f3\u540c\u4e00\u4e2a\u6876\u4e2d\u3002\u5982\u679c\u6211\u4eec\u91c7\u7528\u4e00\u4e2a \\(O(n^2)\\) \u7b97\u6cd5\u6765\u6392\u5e8f\u8fd9\u4e9b\u5143\u7d20\uff0c\u5219\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    "},{"location":"chapter_stack_and_queue/","title":"5. \u00a0 \u6808\u4e0e\u961f\u5217","text":""},{"location":"chapter_stack_and_queue/deque/","title":"5.3. \u00a0 \u53cc\u5411\u961f\u5217","text":"

    \u5bf9\u4e8e\u961f\u5217\uff0c\u6211\u4eec\u4ec5\u80fd\u5728\u5934\u90e8\u5220\u9664\u6216\u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\u3002\u7136\u800c\uff0c\u300c\u53cc\u5411\u961f\u5217 Deque\u300d\u63d0\u4f9b\u4e86\u66f4\u9ad8\u7684\u7075\u6d3b\u6027\uff0c\u5141\u8bb8\u5728\u5934\u90e8\u548c\u5c3e\u90e8\u6267\u884c\u5143\u7d20\u7684\u6dfb\u52a0\u6216\u5220\u9664\u64cd\u4f5c\u3002

    Fig. \u53cc\u5411\u961f\u5217\u7684\u64cd\u4f5c

    "},{"location":"chapter_stack_and_queue/deque/#531","title":"5.3.1. \u00a0 \u53cc\u5411\u961f\u5217\u5e38\u7528\u64cd\u4f5c","text":"

    \u53cc\u5411\u961f\u5217\u7684\u5e38\u7528\u64cd\u4f5c\u5982\u4e0b\u8868\u6240\u793a\uff0c\u5177\u4f53\u7684\u65b9\u6cd5\u540d\u79f0\u9700\u8981\u6839\u636e\u6240\u4f7f\u7528\u7684\u7f16\u7a0b\u8bed\u8a00\u6765\u786e\u5b9a\u3002

    \u65b9\u6cd5\u540d \u63cf\u8ff0 \u65f6\u95f4\u590d\u6742\u5ea6 pushFirst() \u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u961f\u9996 \\(O(1)\\) pushLast() \u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u961f\u5c3e \\(O(1)\\) popFirst() \u5220\u9664\u961f\u9996\u5143\u7d20 \\(O(1)\\) popLast() \u5220\u9664\u961f\u5c3e\u5143\u7d20 \\(O(1)\\) peekFirst() \u8bbf\u95ee\u961f\u9996\u5143\u7d20 \\(O(1)\\) peekLast() \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 \\(O(1)\\)

    \u540c\u6837\u5730\uff0c\u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u4e2d\u5df2\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\u7c7b\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart deque.java
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\nDeque<Integer> deque = new LinkedList<>();\n/* \u5143\u7d20\u5165\u961f */\ndeque.offerLast(2);   // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.offerFirst(1);\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.peekFirst();  // \u961f\u9996\u5143\u7d20\nint peekLast = deque.peekLast();    // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\nint popFirst = deque.pollFirst();  // \u961f\u9996\u5143\u7d20\u51fa\u961f\nint popLast = deque.pollLast();    // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.size();\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = deque.isEmpty();\n
    deque.cpp
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\ndeque<int> deque;\n/* \u5143\u7d20\u5165\u961f */\ndeque.push_back(2);   // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.push_front(1);\n/* \u8bbf\u95ee\u5143\u7d20 */\nint front = deque.front(); // \u961f\u9996\u5143\u7d20\nint back = deque.back();   // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\ndeque.pop_front();  // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.pop_back();   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.size();\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty = deque.empty();\n
    deque.py
    # \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217\ndeque: Deque[int] = collections.deque()\n# \u5143\u7d20\u5165\u961f\ndeque.append(2)      # \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.append(5)\ndeque.append(4)\ndeque.appendleft(3)  # \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.appendleft(1)\n# \u8bbf\u95ee\u5143\u7d20\nfront: int = deque[0]  # \u961f\u9996\u5143\u7d20\nrear: int = deque[-1]  # \u961f\u5c3e\u5143\u7d20\n# \u5143\u7d20\u51fa\u961f\npop_front: int = deque.popleft()  # \u961f\u9996\u5143\u7d20\u51fa\u961f\npop_rear: int = deque.pop()       # \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n# \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nsize: int = len(deque)\n# \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(deque) == 0\n
    deque_test.go
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// \u5728 Go \u4e2d\uff0c\u5c06 list \u4f5c\u4e3a\u53cc\u5411\u961f\u5217\u4f7f\u7528\ndeque := list.New()\n/* \u5143\u7d20\u5165\u961f */\ndeque.PushBack(2)      // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.PushFront(1)\n/* \u8bbf\u95ee\u5143\u7d20 */\nfront := deque.Front() // \u961f\u9996\u5143\u7d20\nrear := deque.Back()   // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\ndeque.Remove(front)    // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.Remove(rear)     // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize := deque.Len()\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty := deque.Len() == 0\n
    deque.js
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// JavaScript \u6ca1\u6709\u5185\u7f6e\u7684\u53cc\u7aef\u961f\u5217\uff0c\u53ea\u80fd\u628a Array \u5f53\u4f5c\u53cc\u7aef\u961f\u5217\u6765\u4f7f\u7528\nconst deque = [];\n/* \u5143\u7d20\u5165\u961f */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// \u8bf7\u6ce8\u610f\uff0c\u7531\u4e8e\u662f\u6570\u7ec4\uff0cunshift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\ndeque.unshift(3);\ndeque.unshift(1);\nconsole.log(\"\u53cc\u5411\u961f\u5217 deque = \", deque);\n/* \u8bbf\u95ee\u5143\u7d20 */\nconst peekFirst = deque[0];\nconsole.log(\"\u961f\u9996\u5143\u7d20 peekFirst = \" + peekFirst);\nconst peekLast = deque[deque.length - 1];\nconsole.log(\"\u961f\u5c3e\u5143\u7d20 peekLast = \" + peekLast);\n/* \u5143\u7d20\u51fa\u961f */\n// \u8bf7\u6ce8\u610f\uff0c\u7531\u4e8e\u662f\u6570\u7ec4\uff0cshift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\nconst popFront = deque.shift();\nconsole.log(\"\u961f\u9996\u51fa\u961f\u5143\u7d20 popFront = \" + popFront + \"\uff0c\u961f\u9996\u51fa\u961f\u540e deque = \" + deque);\nconst popBack = deque.pop();\nconsole.log(\"\u961f\u5c3e\u51fa\u961f\u5143\u7d20 popBack = \" + popBack + \"\uff0c\u961f\u5c3e\u51fa\u961f\u540e deque = \" + deque);\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = deque.length;\nconsole.log(\"\u53cc\u5411\u961f\u5217\u957f\u5ea6 size = \" + size);\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst isEmpty = size === 0;\nconsole.log(\"\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a = \" + isEmpty);\n
    deque.ts
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// TypeScript \u6ca1\u6709\u5185\u7f6e\u7684\u53cc\u7aef\u961f\u5217\uff0c\u53ea\u80fd\u628a Array \u5f53\u4f5c\u53cc\u7aef\u961f\u5217\u6765\u4f7f\u7528\nconst deque: number[] = [];\n/* \u5143\u7d20\u5165\u961f */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// \u8bf7\u6ce8\u610f\uff0c\u7531\u4e8e\u662f\u6570\u7ec4\uff0cunshift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\ndeque.unshift(3);\ndeque.unshift(1);\nconsole.log(\"\u53cc\u5411\u961f\u5217 deque = \", deque);\n/* \u8bbf\u95ee\u5143\u7d20 */\nconst peekFirst: number = deque[0];\nconsole.log(\"\u961f\u9996\u5143\u7d20 peekFirst = \" + peekFirst);\nconst peekLast: number = deque[deque.length - 1];\nconsole.log(\"\u961f\u5c3e\u5143\u7d20 peekLast = \" + peekLast);\n/* \u5143\u7d20\u51fa\u961f */\n// \u8bf7\u6ce8\u610f\uff0c\u7531\u4e8e\u662f\u6570\u7ec4\uff0cshift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\nconst popFront: number = deque.shift() as number;\nconsole.log(\"\u961f\u9996\u51fa\u961f\u5143\u7d20 popFront = \" + popFront + \"\uff0c\u961f\u9996\u51fa\u961f\u540e deque = \" + deque);\nconst popBack: number = deque.pop() as number;\nconsole.log(\"\u961f\u5c3e\u51fa\u961f\u5143\u7d20 popBack = \" + popBack + \"\uff0c\u961f\u5c3e\u51fa\u961f\u540e deque = \" + deque);\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nconst size: number = deque.length;\nconsole.log(\"\u53cc\u5411\u961f\u5217\u957f\u5ea6 size = \" + size);\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst isEmpty: boolean = size === 0;\nconsole.log(\"\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a = \" + isEmpty);\n
    deque.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u53cc\u5411\u961f\u5217\n
    deque.cs
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// \u5728 C# \u4e2d\uff0c\u5c06\u94fe\u8868 LinkedList \u770b\u4f5c\u53cc\u5411\u961f\u5217\u6765\u4f7f\u7528\nLinkedList<int> deque = new LinkedList<int>();\n/* \u5143\u7d20\u5165\u961f */\ndeque.AddLast(2);   // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.AddFirst(1);\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.First.Value;  // \u961f\u9996\u5143\u7d20\nint peekLast = deque.Last.Value;    // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\ndeque.RemoveFirst();  // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.RemoveLast();   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.Count;\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = deque.Count == 0;\n
    deque.swift
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// Swift \u6ca1\u6709\u5185\u7f6e\u7684\u53cc\u5411\u961f\u5217\u7c7b\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u53cc\u5411\u961f\u5217\u6765\u4f7f\u7528\nvar deque: [Int] = []\n/* \u5143\u7d20\u5165\u961f */\ndeque.append(2) // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.insert(1, at: 0)\n/* \u8bbf\u95ee\u5143\u7d20 */\nlet peekFirst = deque.first! // \u961f\u9996\u5143\u7d20\nlet peekLast = deque.last! // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\n// \u4f7f\u7528 Array \u6a21\u62df\u65f6 popFirst \u7684\u590d\u6742\u5ea6\u4e3a O(n)\nlet popFirst = deque.removeFirst() // \u961f\u9996\u5143\u7d20\u51fa\u961f\nlet popLast = deque.removeLast() // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = deque.count\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = deque.isEmpty\n
    deque.zig
    \n
    deque.dart
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// \u5728 Dart \u4e2d\uff0cQueue \u88ab\u5b9a\u4e49\u4e3a\u53cc\u5411\u961f\u5217\nQueue<int> deque = Queue<int>();\n/* \u5143\u7d20\u5165\u961f */\ndeque.addLast(2);  // \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // \u6dfb\u52a0\u81f3\u961f\u9996\ndeque.addFirst(1);\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.first; // \u961f\u9996\u5143\u7d20\nint peekLast = deque.last;   // \u961f\u5c3e\u5143\u7d20\n/* \u5143\u7d20\u51fa\u961f */\nint popFirst = deque.removeFirst(); // \u961f\u9996\u5143\u7d20\u51fa\u961f\nint popLast = deque.removeLast();   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.length;\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = deque.isEmpty;W\n
    "},{"location":"chapter_stack_and_queue/deque/#532","title":"5.3.2. \u00a0 \u53cc\u5411\u961f\u5217\u5b9e\u73b0 *","text":"

    \u53cc\u5411\u961f\u5217\u7684\u5b9e\u73b0\u4e0e\u961f\u5217\u7c7b\u4f3c\uff0c\u53ef\u4ee5\u9009\u62e9\u94fe\u8868\u6216\u6570\u7ec4\u4f5c\u4e3a\u5e95\u5c42\u6570\u636e\u7ed3\u6784\u3002

    "},{"location":"chapter_stack_and_queue/deque/#_1","title":"\u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u7684\u5b9e\u73b0","text":"

    \u56de\u987e\u4e0a\u4e00\u8282\u5185\u5bb9\uff0c\u6211\u4eec\u4f7f\u7528\u666e\u901a\u5355\u5411\u94fe\u8868\u6765\u5b9e\u73b0\u961f\u5217\uff0c\u56e0\u4e3a\u5b83\u53ef\u4ee5\u65b9\u4fbf\u5730\u5220\u9664\u5934\u8282\u70b9\uff08\u5bf9\u5e94\u51fa\u961f\u64cd\u4f5c\uff09\u548c\u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0\u65b0\u8282\u70b9\uff08\u5bf9\u5e94\u5165\u961f\u64cd\u4f5c\uff09\u3002

    \u5bf9\u4e8e\u53cc\u5411\u961f\u5217\u800c\u8a00\uff0c\u5934\u90e8\u548c\u5c3e\u90e8\u90fd\u53ef\u4ee5\u6267\u884c\u5165\u961f\u548c\u51fa\u961f\u64cd\u4f5c\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u53cc\u5411\u961f\u5217\u9700\u8981\u5b9e\u73b0\u53e6\u4e00\u4e2a\u5bf9\u79f0\u65b9\u5411\u7684\u64cd\u4f5c\u3002\u4e3a\u6b64\uff0c\u6211\u4eec\u91c7\u7528\u300c\u53cc\u5411\u94fe\u8868\u300d\u4f5c\u4e3a\u53cc\u5411\u961f\u5217\u7684\u5e95\u5c42\u6570\u636e\u7ed3\u6784\u3002

    \u6211\u4eec\u5c06\u53cc\u5411\u94fe\u8868\u7684\u5934\u8282\u70b9\u548c\u5c3e\u8282\u70b9\u89c6\u4e3a\u53cc\u5411\u961f\u5217\u7684\u961f\u9996\u548c\u961f\u5c3e\uff0c\u540c\u65f6\u5b9e\u73b0\u5728\u4e24\u7aef\u6dfb\u52a0\u548c\u5220\u9664\u8282\u70b9\u7684\u529f\u80fd\u3002

    LinkedListDequepushLast()pushFirst()popLast()popFirst()

    \u4ee5\u4e0b\u662f\u5177\u4f53\u5b9e\u73b0\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linkedlist_deque.java
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\nint val; // \u8282\u70b9\u503c\nListNode next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nListNode prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nListNode(int val) {\nthis.val = val;\nprev = next = null;\n}\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\nprivate ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\nprivate int queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\npublic LinkedListDeque() {\nfront = rear = null;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f\u64cd\u4f5c */\nprivate void push(int num, boolean isFront) {\nListNode node = new ListNode(num);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (isEmpty())\nfront = rear = node;\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelse if (isFront) {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nfront.prev = node;\nnode.next = front;\nfront = node; // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nrear.next = node;\nnode.prev = rear;\nrear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\npublic void pushFirst(int num) {\npush(num, true);\n}\n/* \u961f\u5c3e\u5165\u961f */\npublic void pushLast(int num) {\npush(num, false);\n}\n/* \u51fa\u961f\u64cd\u4f5c */\nprivate Integer pop(boolean isFront) {\n// \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de null\nif (isEmpty())\nreturn null;\nint val;\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif (isFront) {\nval = front.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nListNode fNext = front.next;\nif (fNext != null) {\nfNext.prev = null;\nfront.next = null;\n}\nfront = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n} else {\nval = rear.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nListNode rPrev = rear.prev;\nif (rPrev != null) {\nrPrev.next = null;\nrear.prev = null;\n}\nrear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n}\n/* \u961f\u9996\u51fa\u961f */\npublic Integer popFirst() {\nreturn pop(true);\n}\n/* \u961f\u5c3e\u51fa\u961f */\npublic Integer popLast() {\nreturn pop(false);\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic Integer peekFirst() {\nreturn isEmpty() ? null : front.val;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npublic Integer peekLast() {\nreturn isEmpty() ? null : rear.val;\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\npublic int[] toArray() {\nListNode node = front;\nint[] res = new int[size()];\nfor (int i = 0; i < res.length; i++) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_deque.cpp
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nstruct DoublyListNode {\nint val;              // \u8282\u70b9\u503c\nDoublyListNode *next; // \u540e\u7ee7\u8282\u70b9\u6307\u9488\nDoublyListNode *prev; // \u524d\u9a71\u8282\u70b9\u6307\u9488\nDoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n}\n};\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\nprivate:\nDoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\nint queSize = 0;              // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nLinkedListDeque() : front(nullptr), rear(nullptr) {\n}\n/* \u6790\u6784\u65b9\u6cd5 */\n~LinkedListDeque() {\n// \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\nDoublyListNode *pre, *cur = front;\nwhile (cur != nullptr) {\npre = cur;\ncur = cur->next;\ndelete pre;\n}\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f\u64cd\u4f5c */\nvoid push(int num, bool isFront) {\nDoublyListNode *node = new DoublyListNode(num);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (isEmpty())\nfront = rear = node;\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelse if (isFront) {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nfront->prev = node;\nnode->next = front;\nfront = node; // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nrear->next = node;\nnode->prev = rear;\nrear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(int num) {\npush(num, true);\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(int num) {\npush(num, false);\n}\n/* \u51fa\u961f\u64cd\u4f5c */\nint pop(bool isFront) {\n// \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de -1\nif (isEmpty())\nreturn -1;\nint val;\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif (isFront) {\nval = front->val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nDoublyListNode *fNext = front->next;\nif (fNext != nullptr) {\nfNext->prev = nullptr;\nfront->next = nullptr;\ndelete front;\n}\nfront = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n} else {\nval = rear->val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nDoublyListNode *rPrev = rear->prev;\nif (rPrev != nullptr) {\nrPrev->next = nullptr;\nrear->prev = nullptr;\ndelete rear;\n}\nrear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n}\n/* \u961f\u9996\u51fa\u961f */\nint popFirst() {\nreturn pop(true);\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast() {\nreturn pop(false);\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst() {\nreturn isEmpty() ? -1 : front->val;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast() {\nreturn isEmpty() ? -1 : rear->val;\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nvector<int> toVector() {\nDoublyListNode *node = front;\nvector<int> res(size());\nfor (int i = 0; i < res.size(); i++) {\nres[i] = node->val;\nnode = node->next;\n}\nreturn res;\n}\n};\n
    linkedlist_deque.py
    class ListNode:\n\"\"\"\u53cc\u5411\u94fe\u8868\u8282\u70b9\"\"\"\ndef __init__(self, val: int) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.val: int = val\nself.next: ListNode | None = None  # \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nself.prev: ListNode | None = None  # \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nclass LinkedListDeque:\n\"\"\"\u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\ndef __init__(self) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.front: ListNode | None = None  # \u5934\u8282\u70b9 front\nself.rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\nself.__size: int = 0  # \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\nreturn self.__size\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn self.size() == 0\ndef push(self, num: int, is_front: bool) -> None:\n\"\"\"\u5165\u961f\u64cd\u4f5c\"\"\"\nnode = ListNode(num)\n# \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif self.is_empty():\nself.front = self.rear = node\n# \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelif is_front:\n# \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nself.front.prev = node\nnode.next = self.front\nself.front = node  # \u66f4\u65b0\u5934\u8282\u70b9\n# \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\nelse:\n# \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nself.rear.next = node\nnode.prev = self.rear\nself.rear = node  # \u66f4\u65b0\u5c3e\u8282\u70b9\nself.__size += 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\ndef push_first(self, num: int) -> None:\n\"\"\"\u961f\u9996\u5165\u961f\"\"\"\nself.push(num, True)\ndef push_last(self, num: int) -> None:\n\"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\nself.push(num, False)\ndef pop(self, is_front: bool) -> int:\n\"\"\"\u51fa\u961f\u64cd\u4f5c\"\"\"\n# \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de None\nif self.is_empty():\nreturn None\n# \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif is_front:\nval: int = self.front.val  # \u6682\u5b58\u5934\u8282\u70b9\u503c\n# \u5220\u9664\u5934\u8282\u70b9\nfnext: ListNode | None = self.front.next\nif fnext != None:\nfnext.prev = None\nself.front.next = None\nself.front = fnext  # \u66f4\u65b0\u5934\u8282\u70b9\n# \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\nelse:\nval: int = self.rear.val  # \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n# \u5220\u9664\u5c3e\u8282\u70b9\nrprev: ListNode | None = self.rear.prev\nif rprev != None:\nrprev.next = None\nself.rear.prev = None\nself.rear = rprev  # \u66f4\u65b0\u5c3e\u8282\u70b9\nself.__size -= 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val\ndef pop_first(self) -> int:\n\"\"\"\u961f\u9996\u51fa\u961f\"\"\"\nreturn self.pop(True)\ndef pop_last(self) -> int:\n\"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\nreturn self.pop(False)\ndef peek_first(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\nreturn None if self.is_empty() else self.front.val\ndef peek_last(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\nreturn None if self.is_empty() else self.rear.val\ndef to_array(self) -> list[int]:\n\"\"\"\u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\"\"\"\nnode = self.front\nres = [0] * self.size()\nfor i in range(self.size()):\nres[i] = node.val\nnode = node.next\nreturn res\n
    linkedlist_deque.go
    /* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntype linkedListDeque struct {\n// \u4f7f\u7528\u5185\u7f6e\u5305 list\ndata *list.List\n}\n/* \u521d\u59cb\u5316\u53cc\u7aef\u961f\u5217 */\nfunc newLinkedListDeque() *linkedListDeque {\nreturn &linkedListDeque{\ndata: list.New(),\n}\n}\n/* \u961f\u9996\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushFirst(value any) {\ns.data.PushFront(value)\n}\n/* \u961f\u5c3e\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushLast(value any) {\ns.data.PushBack(value)\n}\n/* \u961f\u9996\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popFirst() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Front()\ns.data.Remove(e)\nreturn e.Value\n}\n/* \u961f\u5c3e\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popLast() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Back()\ns.data.Remove(e)\nreturn e.Value\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListDeque) peekFirst() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Front()\nreturn e.Value\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (s *linkedListDeque) peekLast() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Back()\nreturn e.Value\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListDeque) size() int {\nreturn s.data.Len()\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListDeque) isEmpty() bool {\nreturn s.data.Len() == 0\n}\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListDeque) toList() *list.List {\nreturn s.data\n}\n
    linkedlist_deque.js
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\nprev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\nnext; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\nval; // \u8282\u70b9\u503c\nconstructor(val) {\nthis.val = val;\nthis.next = null;\nthis.prev = null;\n}\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n#front; // \u5934\u8282\u70b9 front\n#rear; // \u5c3e\u8282\u70b9 rear\n#queSize; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nconstructor() {\nthis.#front = null;\nthis.#rear = null;\nthis.#queSize = 0;\n}\n/* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\npushLast(val) {\nconst node = new ListNode(val);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (this.#queSize === 0) {\nthis.#front = node;\nthis.#rear = node;\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nthis.#rear.next = node;\nnode.prev = this.#rear;\nthis.#rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nthis.#queSize++;\n}\n/* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\npushFirst(val) {\nconst node = new ListNode(val);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (this.#queSize === 0) {\nthis.#front = node;\nthis.#rear = node;\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nthis.#front.prev = node;\nnode.next = this.#front;\nthis.#front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n}\nthis.#queSize++;\n}\n/* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\npopLast() {\nif (this.#queSize === 0) {\nreturn null;\n}\nconst value = this.#rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nlet temp = this.#rear.prev;\nif (temp !== null) {\ntemp.next = null;\nthis.#rear.prev = null;\n}\nthis.#rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\nthis.#queSize--;\nreturn value;\n}\n/* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\npopFirst() {\nif (this.#queSize === 0) {\nreturn null;\n}\nconst value = this.#front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nlet temp = this.#front.next;\nif (temp !== null) {\ntemp.prev = null;\nthis.#front.next = null;\n}\nthis.#front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\nthis.#queSize--;\nreturn value;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npeekLast() {\nreturn this.#queSize === 0 ? null : this.#rear.val;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeekFirst() {\nreturn this.#queSize === 0 ? null : this.#front.val;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize() {\nreturn this.#queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty() {\nreturn this.#queSize === 0;\n}\n/* \u6253\u5370\u53cc\u5411\u961f\u5217 */\nprint() {\nconst arr = [];\nlet temp = this.#front;\nwhile (temp !== null) {\narr.push(temp.val);\ntemp = temp.next;\n}\nconsole.log('[' + arr.join(', ') + ']');\n}\n}\n
    linkedlist_deque.ts
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\nprev: ListNode; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\nnext: ListNode; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\nval: number; // \u8282\u70b9\u503c\nconstructor(val: number) {\nthis.val = val;\nthis.next = null;\nthis.prev = null;\n}\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\nprivate front: ListNode; // \u5934\u8282\u70b9 front\nprivate rear: ListNode; // \u5c3e\u8282\u70b9 rear\nprivate queSize: number; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nconstructor() {\nthis.front = null;\nthis.rear = null;\nthis.queSize = 0;\n}\n/* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\npushLast(val: number): void {\nconst node: ListNode = new ListNode(val);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (this.queSize === 0) {\nthis.front = node;\nthis.rear = node;\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nthis.rear.next = node;\nnode.prev = this.rear;\nthis.rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nthis.queSize++;\n}\n/* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\npushFirst(val: number): void {\nconst node: ListNode = new ListNode(val);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (this.queSize === 0) {\nthis.front = node;\nthis.rear = node;\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nthis.front.prev = node;\nnode.next = this.front;\nthis.front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n}\nthis.queSize++;\n}\n/* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\npopLast(): number {\nif (this.queSize === 0) {\nreturn null;\n}\nconst value: number = this.rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nlet temp: ListNode = this.rear.prev;\nif (temp !== null) {\ntemp.next = null;\nthis.rear.prev = null;\n}\nthis.rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\nthis.queSize--;\nreturn value;\n}\n/* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\npopFirst(): number {\nif (this.queSize === 0) {\nreturn null;\n}\nconst value: number = this.front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nlet temp: ListNode = this.front.next;\nif (temp !== null) {\ntemp.prev = null;\nthis.front.next = null;\n}\nthis.front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\nthis.queSize--;\nreturn value;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npeekLast(): number {\nreturn this.queSize === 0 ? null : this.rear.val;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeekFirst(): number {\nreturn this.queSize === 0 ? null : this.front.val;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize(): number {\nreturn this.queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty(): boolean {\nreturn this.queSize === 0;\n}\n/* \u6253\u5370\u53cc\u5411\u961f\u5217 */\nprint(): void {\nconst arr: number[] = [];\nlet temp: ListNode = this.front;\nwhile (temp !== null) {\narr.push(temp.val);\ntemp = temp.next;\n}\nconsole.log('[' + arr.join(', ') + ']');\n}\n}\n
    linkedlist_deque.c
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nstruct doublyListNode {\nint val;                     // \u8282\u70b9\u503c\nstruct doublyListNode *next; // \u540e\u7ee7\u8282\u70b9\nstruct doublyListNode *prev; // \u524d\u9a71\u8282\u70b9\n};\ntypedef struct doublyListNode doublyListNode;\n/* \u6784\u9020\u51fd\u6570 */\ndoublyListNode *newDoublyListNode(int num) {\ndoublyListNode *new = (doublyListNode *)malloc(sizeof(doublyListNode));\nnew->val = num;\nnew->next = NULL;\nnew->prev = NULL;\nreturn new;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delDoublyListNode(doublyListNode *node) {\nfree(node);\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nstruct linkedListDeque {\ndoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\nint queSize;                  // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n};\ntypedef struct linkedListDeque linkedListDeque;\n/* \u6784\u9020\u51fd\u6570 */\nlinkedListDeque *newLinkedListDeque() {\nlinkedListDeque *deque = (linkedListDeque *)malloc(sizeof(linkedListDeque));\ndeque->front = NULL;\ndeque->rear = NULL;\ndeque->queSize = 0;\nreturn deque;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListdeque(linkedListDeque *deque) {\n// \u91ca\u653e\u6240\u6709\u8282\u70b9\nfor (int i = 0; i < deque->queSize && deque->front != NULL; i++) {\ndoublyListNode *tmp = deque->front;\ndeque->front = deque->front->next;\nfree(tmp);\n}\n// \u91ca\u653e deque \u7ed3\u6784\u4f53\nfree(deque);\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(linkedListDeque *deque) {\nreturn deque->queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(linkedListDeque *deque) {\nreturn (size(deque) == 0);\n}\n/* \u5165\u961f */\nvoid push(linkedListDeque *deque, int num, bool isFront) {\ndoublyListNode *node = newDoublyListNode(num);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411node\nif (empty(deque)) {\ndeque->front = deque->rear = node;\n}\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelse if (isFront) {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\ndeque->front->prev = node;\nnode->next = deque->front;\ndeque->front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n}\n// \u5bf9\u5c3e\u5165\u961f\u64cd\u4f5c\nelse {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\ndeque->rear->next = node;\nnode->prev = deque->rear;\ndeque->rear = node;\n}\ndeque->queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(linkedListDeque *deque, int num) {\npush(deque, num, true);\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(linkedListDeque *deque, int num) {\npush(deque, num, false);\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(linkedListDeque *deque) {\nassert(size(deque) && deque->front);\nreturn deque->front->val;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(linkedListDeque *deque) {\nassert(size(deque) && deque->rear);\nreturn deque->rear->val;\n}\n/* \u51fa\u961f */\nint pop(linkedListDeque *deque, bool isFront) {\nif (empty(deque))\nreturn -1;\nint val;\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif (isFront) {\nval = peekFirst(deque); // \u6682\u5b58\u5934\u8282\u70b9\u503c\ndoublyListNode *fNext = deque->front->next;\nif (fNext) {\nfNext->prev = NULL;\ndeque->front->next = NULL;\ndelDoublyListNode(deque->front);\n}\ndeque->front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n}\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\nelse {\nval = peekLast(deque); // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\ndoublyListNode *rPrev = deque->rear->prev;\nif (rPrev) {\nrPrev->next = NULL;\ndeque->rear->prev = NULL;\ndelDoublyListNode(deque->rear);\n}\ndeque->rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\ndeque->queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n}\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(linkedListDeque *deque) {\nreturn pop(deque, true);\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(linkedListDeque *deque) {\nreturn pop(deque, false);\n}\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListDeque(linkedListDeque *deque) {\nint arr[deque->queSize];\n// \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\nint i;\ndoublyListNode *node;\nfor (i = 0, node = deque->front; i < deque->queSize; i++) {\narr[i] = node->val;\nnode = node->next;\n}\nprintArray(arr, deque->queSize);\n}\n
    linkedlist_deque.cs
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\npublic int val;       // \u8282\u70b9\u503c\npublic ListNode? next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\npublic ListNode? prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\npublic ListNode(int val) {\nthis.val = val;\nprev = null;\nnext = null;\n}\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\nprivate ListNode? front, rear; // \u5934\u8282\u70b9 front, \u5c3e\u8282\u70b9 rear\nprivate int queSize = 0;      // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\npublic LinkedListDeque() {\nfront = null;\nrear = null;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f\u64cd\u4f5c */\nprivate void push(int num, bool isFront) {\nListNode node = new ListNode(num);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (isEmpty()) {\nfront = node;\nrear = node;\n}\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelse if (isFront) {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nfront.prev = node;\nnode.next = front;\nfront = node; // \u66f4\u65b0\u5934\u8282\u70b9                           \n}\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\nelse {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nrear.next = node;\nnode.prev = rear;\nrear = node;  // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\npublic void pushFirst(int num) {\npush(num, true);\n}\n/* \u961f\u5c3e\u5165\u961f */\npublic void pushLast(int num) {\npush(num, false);\n}\n/* \u51fa\u961f\u64cd\u4f5c */\nprivate int? pop(bool isFront) {\n// \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de null\nif (isEmpty()) {\nreturn null;\n}\nint val;\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif (isFront) {\nval = front.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nListNode fNext = front.next;\nif (fNext != null) {\nfNext.prev = null;\nfront.next = null;\n}\nfront = fNext;   // \u66f4\u65b0\u5934\u8282\u70b9\n}\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\nelse {\nval = rear.val;  // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nListNode rPrev = rear.prev;\nif (rPrev != null) {\nrPrev.next = null;\nrear.prev = null;\n}\nrear = rPrev;    // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n}\n/* \u961f\u9996\u51fa\u961f */\npublic int? popFirst() {\nreturn pop(true);\n}\n/* \u961f\u5c3e\u51fa\u961f */\npublic int? popLast() {\nreturn pop(false);\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int? peekFirst() {\nreturn isEmpty() ? null : front.val;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npublic int? peekLast() {\nreturn isEmpty() ? null : rear.val;\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\npublic int[] toArray() {\nListNode node = front;\nint[] res = new int[size()];\nfor (int i = 0; i < res.Length; i++) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_deque.swift
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\nvar val: Int // \u8282\u70b9\u503c\nvar next: ListNode? // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nvar prev: ListNode? // \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\ninit(val: Int) {\nself.val = val\n}\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\nprivate var front: ListNode? // \u5934\u8282\u70b9 front\nprivate var rear: ListNode? // \u5c3e\u8282\u70b9 rear\nprivate var queSize: Int // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\ninit() {\nqueSize = 0\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nfunc size() -> Int {\nqueSize\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nsize() == 0\n}\n/* \u5165\u961f\u64cd\u4f5c */\nprivate func push(num: Int, isFront: Bool) {\nlet node = ListNode(val: num)\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif isEmpty() {\nfront = node\nrear = node\n}\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\nelse if isFront {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nfront?.prev = node\nnode.next = front\nfront = node // \u66f4\u65b0\u5934\u8282\u70b9\n}\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\nelse {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nrear?.next = node\nnode.prev = rear\nrear = node // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize += 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\nfunc pushFirst(num: Int) {\npush(num: num, isFront: true)\n}\n/* \u961f\u5c3e\u5165\u961f */\nfunc pushLast(num: Int) {\npush(num: num, isFront: false)\n}\n/* \u51fa\u961f\u64cd\u4f5c */\nprivate func pop(isFront: Bool) -> Int {\nif isEmpty() {\nfatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n}\nlet val: Int\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif isFront {\nval = front!.val // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nlet fNext = front?.next\nif fNext != nil {\nfNext?.prev = nil\nfront?.next = nil\n}\nfront = fNext // \u66f4\u65b0\u5934\u8282\u70b9\n}\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\nelse {\nval = rear!.val // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nlet rPrev = rear?.prev\nif rPrev != nil {\nrPrev?.next = nil\nrear?.prev = nil\n}\nrear = rPrev // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nqueSize -= 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val\n}\n/* \u961f\u9996\u51fa\u961f */\nfunc popFirst() -> Int {\npop(isFront: true)\n}\n/* \u961f\u5c3e\u51fa\u961f */\nfunc popLast() -> Int {\npop(isFront: false)\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc peekFirst() -> Int? {\nisEmpty() ? nil : front?.val\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc peekLast() -> Int? {\nisEmpty() ? nil : rear?.val\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nfunc toArray() -> [Int] {\nvar node = front\nvar res = Array(repeating: 0, count: size())\nfor i in res.indices {\nres[i] = node!.val\nnode = node?.next\n}\nreturn res\n}\n}\n
    linkedlist_deque.zig
    // \u53cc\u5411\u94fe\u8868\u8282\u70b9\nfn ListNode(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nval: T = undefined,     // \u8282\u70b9\u503c\nnext: ?*Self = null,    // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nprev: ?*Self = null,    // \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\n// Initialize a list node with specific value\npub fn init(self: *Self, x: i32) void {\nself.val = x;\nself.next = null;\nself.prev = null;\n}\n};\n}\n// \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\nfn LinkedListDeque(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nfront: ?*ListNode(T) = null,                    // \u5934\u8282\u70b9 front\nrear: ?*ListNode(T) = null,                     // \u5c3e\u8282\u70b9 rear\nque_size: usize = 0,                             // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nmem_arena: ?std.heap.ArenaAllocator = null,\nmem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n// \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator) !void {\nif (self.mem_arena == null) {\nself.mem_arena = std.heap.ArenaAllocator.init(allocator);\nself.mem_allocator = self.mem_arena.?.allocator();\n}\nself.front = null;\nself.rear = null;\nself.que_size = 0;\n}\n// \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.mem_arena == null) return;\nself.mem_arena.?.deinit();\n}\n// \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\npub fn size(self: *Self) usize {\nreturn self.que_size;\n}\n// \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\npub fn isEmpty(self: *Self) bool {\nreturn self.size() == 0;\n}\n// \u5165\u961f\u64cd\u4f5c\npub fn push(self: *Self, num: T, is_front: bool) !void {\nvar node = try self.mem_allocator.create(ListNode(T));\nnode.init(num);\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front, rear \u90fd\u6307\u5411 node\nif (self.isEmpty()) {\nself.front = node;\nself.rear = node;\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\n} else if (is_front) {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\nself.front.?.prev = node;\nnode.next = self.front;\nself.front = node;  // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n} else {\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\nself.rear.?.next = node;\nnode.prev = self.rear;\nself.rear = node;   // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nself.que_size += 1;      // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n} // \u961f\u9996\u5165\u961f\npub fn pushFirst(self: *Self, num: T) !void {\ntry self.push(num, true);\n} // \u961f\u5c3e\u5165\u961f\npub fn pushLast(self: *Self, num: T) !void {\ntry self.push(num, false);\n} // \u51fa\u961f\u64cd\u4f5c\npub fn pop(self: *Self, is_front: bool) T {\nif (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\nvar val: T = undefined;\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nif (is_front) {\nval = self.front.?.val;     // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nvar fNext = self.front.?.next;\nif (fNext != null) {\nfNext.?.prev = null;\nself.front.?.next = null;\n}\nself.front = fNext;         // \u66f4\u65b0\u5934\u8282\u70b9\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n} else {\nval = self.rear.?.val;      // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nvar rPrev = self.rear.?.prev;\nif (rPrev != null) {\nrPrev.?.next = null;\nself.rear.?.prev = null;\n}\nself.rear = rPrev;          // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\nself.que_size -= 1;              // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n} // \u961f\u9996\u51fa\u961f\npub fn popFirst(self: *Self) T {\nreturn self.pop(true);\n} // \u961f\u5c3e\u51fa\u961f\npub fn popLast(self: *Self) T {\nreturn self.pop(false);\n} // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\npub fn peekFirst(self: *Self) T {\nif (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\nreturn self.front.?.val;\n}  // \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\npub fn peekLast(self: *Self) T {\nif (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\nreturn self.rear.?.val;\n}\n// \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\npub fn toArray(self: *Self) ![]T {\nvar node = self.front;\nvar res = try self.mem_allocator.alloc(T, self.size());\n@memset(res, @as(T, 0));\nvar i: usize = 0;\nwhile (i < res.len) : (i += 1) {\nres[i] = node.?.val;\nnode = node.?.next;\n}\nreturn res;\n}\n};\n}\n
    linkedlist_deque.dart
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\nint val; // \u8282\u70b9\u503c\nListNode? next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nListNode? prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\nListNode(this.val, {this.next, this.prev});\n}\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u5bf9\u5217 */\nclass LinkedListDeque {\nlate ListNode? _front; // \u5934\u8282\u70b9 _front\nlate ListNode? _rear; // \u5c3e\u8282\u70b9 _rear\nint _queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nLinkedListDeque() {\nthis._front = null;\nthis._rear = null;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u957f\u5ea6 */\nint size() {\nreturn this._queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f\u64cd\u4f5c */\nvoid push(int num, bool isFront) {\nfinal ListNode node = ListNode(num);\nif (isEmpty()) {\n// \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 _front\uff0c_rear \u90fd\u6307\u5411 node\n_front = _rear = node;\n} else if (isFront) {\n// \u961f\u9996\u5165\u961f\u64cd\u4f5c\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n_front!.prev = node;\nnode.next = _front;\n_front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n} else {\n// \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n// \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n_rear!.next = node;\nnode.prev = _rear;\n_rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\n_queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(int num) {\npush(num, true);\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(int num) {\npush(num, false);\n}\n/* \u51fa\u961f\u64cd\u4f5c */\nint? pop(bool isFront) {\n// \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de null\nif (isEmpty()) {\nreturn null;\n}\nfinal int val;\nif (isFront) {\n// \u961f\u9996\u51fa\u961f\u64cd\u4f5c\nval = _front!.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n// \u5220\u9664\u5934\u8282\u70b9\nListNode? fNext = _front!.next;\nif (fNext != null) {\nfNext.prev = null;\n_front!.next = null;\n}\n_front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n} else {\n// \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\nval = _rear!.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n// \u5220\u9664\u5c3e\u8282\u70b9\nListNode? rPrev = _rear!.prev;\nif (rPrev != null) {\nrPrev.next = null;\n_rear!.prev = null;\n}\n_rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n}\n_queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\nreturn val;\n}\n/* \u961f\u9996\u51fa\u961f */\nint? popFirst() {\nreturn pop(true);\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint? popLast() {\nreturn pop(false);\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint? peekFirst() {\nreturn _front?.val;\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint? peekLast() {\nreturn _rear?.val;\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nList<int> toArray() {\nListNode? node = _front;\nfinal List<int> res = [];\nfor (int i = 0; i < _queSize; i++) {\nres.add(node!.val);\nnode = node.next;\n}\nreturn res;\n}\n}\n
    "},{"location":"chapter_stack_and_queue/deque/#_2","title":"\u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u4e0e\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u961f\u5217\u7c7b\u4f3c\uff0c\u6211\u4eec\u4e5f\u53ef\u4ee5\u4f7f\u7528\u73af\u5f62\u6570\u7ec4\u6765\u5b9e\u73b0\u53cc\u5411\u961f\u5217\u3002\u5728\u961f\u5217\u7684\u5b9e\u73b0\u57fa\u7840\u4e0a\uff0c\u4ec5\u9700\u589e\u52a0\u201c\u961f\u9996\u5165\u961f\u201d\u548c\u201c\u961f\u5c3e\u51fa\u961f\u201d\u7684\u65b9\u6cd5\u3002

    ArrayDequepushLast()pushFirst()popLast()popFirst()

    \u4ee5\u4e0b\u662f\u5177\u4f53\u5b9e\u73b0\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array_deque.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nprivate int[] nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\npublic ArrayDeque(int capacity) {\nthis.nums = new int[capacity];\nfront = queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\npublic int capacity() {\nreturn nums.length;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn queSize == 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nprivate int index(int i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + capacity()) % capacity();\n}\n/* \u961f\u9996\u5165\u961f */\npublic void pushFirst(int num) {\nif (queSize == capacity()) {\nSystem.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nfront = index(front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nnums[front] = num;\nqueSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\npublic void pushLast(int num) {\nif (queSize == capacity()) {\nSystem.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nint rear = index(front + queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\npublic int popFirst() {\nint num = peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfront = index(front + 1);\nqueSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\npublic int popLast() {\nint num = peekLast();\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peekFirst() {\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\nreturn nums[front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npublic int peekLast() {\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nint last = index(front + queSize - 1);\nreturn nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\npublic int[] toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] res = new int[queSize];\nfor (int i = 0, j = front; i < queSize; i++, j++) {\nres[i] = nums[index(j)];\n}\nreturn res;\n}\n}\n
    array_deque.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nprivate:\nvector<int> nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nint front;        // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nint queSize;      // \u53cc\u5411\u961f\u5217\u957f\u5ea6\npublic:\n/* \u6784\u9020\u65b9\u6cd5 */\nArrayDeque(int capacity) {\nnums.resize(capacity);\nfront = queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity() {\nreturn nums.size();\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn queSize == 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nint index(int i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + capacity()) % capacity();\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(int num) {\nif (queSize == capacity()) {\ncout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nfront = index(front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nnums[front] = num;\nqueSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(int num) {\nif (queSize == capacity()) {\ncout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nint rear = index(front + queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\nint popFirst() {\nint num = peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfront = index(front + 1);\nqueSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast() {\nint num = peekLast();\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst() {\nif (isEmpty())\nthrow out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\nreturn nums[front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast() {\nif (isEmpty())\nthrow out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nint last = index(front + queSize - 1);\nreturn nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nvector<int> toVector() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvector<int> res(queSize);\nfor (int i = 0, j = front; i < queSize; i++, j++) {\nres[i] = nums[index(j)];\n}\nreturn res;\n}\n};\n
    array_deque.py
    class ArrayDeque:\n\"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\ndef __init__(self, capacity: int) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__nums: list[int] = [0] * capacity\nself.__front: int = 0\nself.__size: int = 0\ndef capacity(self) -> int:\n\"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\nreturn len(self.__nums)\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\nreturn self.__size\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn self.__size == 0\ndef index(self, i: int) -> int:\n\"\"\"\u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15\"\"\"\n# \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n# \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n# \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + self.capacity()) % self.capacity()\ndef push_first(self, num: int) -> None:\n\"\"\"\u961f\u9996\u5165\u961f\"\"\"\nif self.__size == self.capacity():\nprint(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n# \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n# \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nself.__front = self.index(self.__front - 1)\n# \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nself.__nums[self.__front] = num\nself.__size += 1\ndef push_last(self, num: int) -> None:\n\"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\nif self.__size == self.capacity():\nprint(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n# \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nrear = self.index(self.__front + self.__size)\n# \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nself.__nums[rear] = num\nself.__size += 1\ndef pop_first(self) -> int:\n\"\"\"\u961f\u9996\u51fa\u961f\"\"\"\nnum = self.peek_first()\n# \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nself.__front = self.index(self.__front + 1)\nself.__size -= 1\nreturn num\ndef pop_last(self) -> int:\n\"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\nnum = self.peek_last()\nself.__size -= 1\nreturn num\ndef peek_first(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\nif self.is_empty():\nraise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\nreturn self.__nums[self.__front]\ndef peek_last(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\nif self.is_empty():\nraise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n# \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nlast = self.index(self.__front + self.__size - 1)\nreturn self.__nums[last]\ndef to_array(self) -> list[int]:\n\"\"\"\u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\"\"\"\n# \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nres = []\nfor i in range(self.__size):\nres.append(self.__nums[self.index(self.__front + i)])\nreturn res\n
    array_deque.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntype arrayDeque struct {\nnums        []int // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nfront       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nqueSize     int   // \u53cc\u5411\u961f\u5217\u957f\u5ea6\nqueCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\nreturn &arrayDeque{\nnums:        make([]int, queCapacity),\nqueCapacity: queCapacity,\nfront:       0,\nqueSize:     0,\n}\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayDeque) size() int {\nreturn q.queSize\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayDeque) isEmpty() bool {\nreturn q.queSize == 0\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nfunc (q *arrayDeque) index(i int) int {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + q.queCapacity) % q.queCapacity\n}\n/* \u961f\u9996\u5165\u961f */\nfunc (q *arrayDeque) pushFirst(num int) {\nif q.queSize == q.queCapacity {\nfmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nq.front = q.index(q.front - 1)\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nq.nums[q.front] = num\nq.queSize++\n}\n/* \u961f\u5c3e\u5165\u961f */\nfunc (q *arrayDeque) pushLast(num int) {\nif q.queSize == q.queCapacity {\nfmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nrear := q.index(q.front + q.queSize)\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nq.nums[rear] = num\nq.queSize++\n}\n/* \u961f\u9996\u51fa\u961f */\nfunc (q *arrayDeque) popFirst() any {\nnum := q.peekFirst()\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nq.front = q.index(q.front + 1)\nq.queSize--\nreturn num\n}\n/* \u961f\u5c3e\u51fa\u961f */\nfunc (q *arrayDeque) popLast() any {\nnum := q.peekLast()\nq.queSize--\nreturn num\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayDeque) peekFirst() any {\nif q.isEmpty() {\nreturn nil\n}\nreturn q.nums[q.front]\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (q *arrayDeque) peekLast() any {\nif q.isEmpty() {\nreturn nil\n}\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nlast := q.index(q.front + q.queSize - 1)\nreturn q.nums[last]\n}\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (q *arrayDeque) toSlice() []int {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nres := make([]int, q.queSize)\nfor i, j := 0, q.front; i < q.queSize; i++ {\nres[i] = q.nums[q.index(j)]\nj++\n}\nreturn res\n}\n
    array_deque.js
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n#nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n#front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n#queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor(capacity) {\nthis.#nums = new Array(capacity);\nthis.#front = 0;\nthis.#queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\ncapacity() {\nreturn this.#nums.length;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize() {\nreturn this.#queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty() {\nreturn this.#queSize === 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nindex(i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + this.capacity()) % this.capacity();\n}\n/* \u961f\u9996\u5165\u961f */\npushFirst(num) {\nif (this.#queSize === this.capacity()) {\nconsole.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nthis.#front = this.index(this.#front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nthis.#nums[this.#front] = num;\nthis.#queSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\npushLast(num) {\nif (this.#queSize === this.capacity()) {\nconsole.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nconst rear = this.index(this.#front + this.#queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nthis.#nums[rear] = num;\nthis.#queSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\npopFirst() {\nconst num = this.peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nthis.#front = this.index(this.#front + 1);\nthis.#queSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\npopLast() {\nconst num = this.peekLast();\nthis.#queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeekFirst() {\nif (this.isEmpty()) throw new Error('The Deque Is Empty.');\nreturn this.#nums[this.#front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npeekLast() {\nif (this.isEmpty()) throw new Error('The Deque Is Empty.');\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nconst last = this.index(this.#front + this.#queSize - 1);\nreturn this.#nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\ntoArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst res = [];\nfor (let i = 0, j = this.#front; i < this.#queSize; i++, j++) {\nres[i] = this.#nums[this.index(j)];\n}\nreturn res;\n}\n}\n
    array_deque.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nprivate nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate queSize: number; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\nconstructor(capacity: number) {\nthis.nums = new Array(capacity);\nthis.front = 0;\nthis.queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\ncapacity(): number {\nreturn this.nums.length;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize(): number {\nreturn this.queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty(): boolean {\nreturn this.queSize === 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nindex(i: number): number {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + this.capacity()) % this.capacity();\n}\n/* \u961f\u9996\u5165\u961f */\npushFirst(num: number): void {\nif (this.queSize === this.capacity()) {\nconsole.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nthis.front = this.index(this.front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nthis.nums[this.front] = num;\nthis.queSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\npushLast(num: number): void {\nif (this.queSize === this.capacity()) {\nconsole.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nconst rear: number = this.index(this.front + this.queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nthis.nums[rear] = num;\nthis.queSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\npopFirst(): number {\nconst num: number = this.peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nthis.front = this.index(this.front + 1);\nthis.queSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\npopLast(): number {\nconst num: number = this.peekLast();\nthis.queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeekFirst(): number {\nif (this.isEmpty()) throw new Error('The Deque Is Empty.');\nreturn this.nums[this.front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npeekLast(): number {\nif (this.isEmpty()) throw new Error('The Deque Is Empty.');\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nconst last = this.index(this.front + this.queSize - 1);\nreturn this.nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\ntoArray(): number[] {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst res: number[] = [];\nfor (let i = 0, j = this.front; i < this.queSize; i++, j++) {\nres[i] = this.nums[this.index(j)];\n}\nreturn res;\n}\n}\n
    array_deque.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nstruct arrayDeque {\nint *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nint front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nint queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\nint queCapacity; // \u961f\u5217\u5bb9\u91cf\n};\ntypedef struct arrayDeque arrayDeque;\n/* \u6784\u9020\u51fd\u6570 */\narrayDeque *newArrayDeque(int capacity) {\narrayDeque *deque = (arrayDeque *)malloc(sizeof(arrayDeque));\n// \u521d\u59cb\u5316\u6570\u7ec4\ndeque->queCapacity = capacity;\ndeque->nums = (int *)malloc(sizeof(int) * deque->queCapacity);\ndeque->front = deque->queSize = 0;\nreturn deque;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayDeque(arrayDeque *deque) {\nfree(deque->nums);\ndeque->queCapacity = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(arrayDeque *deque) {\nreturn deque->queCapacity;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size(arrayDeque *deque) {\nreturn deque->queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(arrayDeque *deque) {\nreturn deque->queSize == 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nint dequeIndex(arrayDeque *deque, int i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn ((i + capacity(deque)) % capacity(deque));\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(arrayDeque *deque, int num) {\nif (deque->queSize == capacity(deque)) {\nprintf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u56de\u5230\u5c3e\u90e8\ndeque->front = dequeIndex(deque, deque->front - 1);\n// \u5c06 num \u6dfb\u52a0\u5230\u961f\u9996\ndeque->nums[deque->front] = num;\ndeque->queSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(arrayDeque *deque, int num) {\nif (deque->queSize == capacity(deque)) {\nprintf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nint rear = dequeIndex(deque, deque->front + deque->queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\ndeque->nums[rear] = num;\ndeque->queSize++;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(arrayDeque *deque) {\n// \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\nassert(empty(deque) == 0);\nreturn deque->nums[deque->front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(arrayDeque *deque) {\n// \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\nassert(empty(deque) == 0);\nint last = dequeIndex(deque, deque->front + deque->queSize - 1);\nreturn deque->nums[last];\n}\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(arrayDeque *deque) {\nint num = peekFirst(deque);\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\ndeque->front = dequeIndex(deque, deque->front + 1);\ndeque->queSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(arrayDeque *deque) {\nint num = peekLast(deque);\ndeque->queSize--;\nreturn num;\n}\n/* \u6253\u5370\u961f\u5217 */\nvoid printArrayDeque(arrayDeque *deque) {\nint arr[deque->queSize];\n// \u62f7\u8d1d\nfor (int i = 0, j = deque->front; i < deque->queSize; i++, j++) {\narr[i] = deque->nums[j % deque->queCapacity];\n}\nprintArray(arr, deque->queSize);\n}\n
    array_deque.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nprivate readonly int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\npublic ArrayDeque(int capacity) {\nthis.nums = new int[capacity];\nfront = queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\npublic int capacity() {\nreturn nums.Length;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn queSize == 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nprivate int index(int i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + capacity()) % capacity();\n}\n/* \u961f\u9996\u5165\u961f */\npublic void pushFirst(int num) {\nif (queSize == capacity()) {\nConsole.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nfront = index(front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nnums[front] = num;\nqueSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\npublic void pushLast(int num) {\nif (queSize == capacity()) {\nConsole.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nint rear = index(front + queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\npublic int popFirst() {\nint num = peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfront = index(front + 1);\nqueSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\npublic int popLast() {\nint num = peekLast();\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peekFirst() {\nif (isEmpty()) {\nthrow new InvalidOperationException();\n}\nreturn nums[front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\npublic int peekLast() {\nif (isEmpty()) {\nthrow new InvalidOperationException();\n}\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nint last = index(front + queSize - 1);\nreturn nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\npublic int[] toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] res = new int[queSize];\nfor (int i = 0, j = front; i < queSize; i++, j++) {\nres[i] = nums[index(j)];\n}\nreturn res;\n}\n}\n
    array_deque.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nprivate var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate var front: Int // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate var queSize: Int // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\ninit(capacity: Int) {\nnums = Array(repeating: 0, count: capacity)\nfront = 0\nqueSize = 0\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nfunc capacity() -> Int {\nnums.count\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nfunc size() -> Int {\nqueSize\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nsize() == 0\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nprivate func index(i: Int) -> Int {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\n(i + capacity()) % capacity()\n}\n/* \u961f\u9996\u5165\u961f */\nfunc pushFirst(num: Int) {\nif size() == capacity() {\nprint(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\nfront = index(i: front - 1)\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\nnums[front] = num\nqueSize += 1\n}\n/* \u961f\u5c3e\u5165\u961f */\nfunc pushLast(num: Int) {\nif size() == capacity() {\nprint(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\nreturn\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nlet rear = index(i: front + size())\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num\nqueSize += 1\n}\n/* \u961f\u9996\u51fa\u961f */\nfunc popFirst() -> Int {\nlet num = peekFirst()\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\nfront = index(i: front + 1)\nqueSize -= 1\nreturn num\n}\n/* \u961f\u5c3e\u51fa\u961f */\nfunc popLast() -> Int {\nlet num = peekLast()\nqueSize -= 1\nreturn num\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc peekFirst() -> Int {\nif isEmpty() {\nfatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n}\nreturn nums[front]\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc peekLast() -> Int {\nif isEmpty() {\nfatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n}\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nlet last = index(i: front + size() - 1)\nreturn nums[last]\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nfunc toArray() -> [Int] {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvar res = Array(repeating: 0, count: size())\nfor (i, j) in sequence(first: (0, front), next: { $0 < self.size() - 1 ? ($0 + 1, $1 + 1) : nil }) {\nres[i] = nums[index(i: j)]\n}\nreturn res\n}\n}\n
    array_deque.zig
    [class]{ArrayDeque}-[func]{}\n
    array_deque.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\nlate List<int> _nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nlate int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nlate int _queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n/* \u6784\u9020\u65b9\u6cd5 */\nArrayDeque(int capacity) {\nthis._nums = List.filled(capacity, 0);\nthis._front = this._queSize = 0;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity() {\nreturn _nums.length;\n}\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn _queSize;\n}\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn _queSize == 0;\n}\n/* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\nint index(int i) {\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0\u6570\u7ec4\u9996\u5c3e\u76f8\u8fde\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\uff0c\u56de\u5230\u5934\u90e8\n// \u5f53 i \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\uff0c\u56de\u5230\u5c3e\u90e8\nreturn (i + capacity()) % capacity();\n}\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(int num) {\nif (_queSize == capacity()) {\nthrow Exception(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n}\n// \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 _front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n_front = index(_front - 1);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n_nums[_front] = num;\n_queSize++;\n}\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(int num) {\nif (_queSize == capacity()) {\nthrow Exception(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\nint rear = index(_front + _queSize);\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n_nums[rear] = num;\n_queSize++;\n}\n/* \u961f\u9996\u51fa\u961f */\nint popFirst() {\nint num = peekFirst();\n// \u961f\u9996\u6307\u9488\u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n_front = index(_front + 1);\n_queSize--;\nreturn num;\n}\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast() {\nint num = peekLast();\n_queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst() {\nif (isEmpty()) {\nthrow Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n}\nreturn _nums[_front];\n}\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast() {\nif (isEmpty()) {\nthrow Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n}\n// \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\nint last = index(_front + _queSize - 1);\nreturn _nums[last];\n}\n/* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\nList<int> toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nList<int> res = List.filled(_queSize, 0);\nfor (int i = 0, j = _front; i < _queSize; i++, j++) {\nres[i] = _nums[index(j)];\n}\nreturn res;\n}\n}\n
    "},{"location":"chapter_stack_and_queue/deque/#533","title":"5.3.3. \u00a0 \u53cc\u5411\u961f\u5217\u5e94\u7528","text":"

    \u53cc\u5411\u961f\u5217\u517c\u5177\u6808\u4e0e\u961f\u5217\u7684\u903b\u8f91\uff0c\u56e0\u6b64\u5b83\u53ef\u4ee5\u5b9e\u73b0\u8fd9\u4e24\u8005\u7684\u6240\u6709\u5e94\u7528\u573a\u666f\uff0c\u540c\u65f6\u63d0\u4f9b\u66f4\u9ad8\u7684\u81ea\u7531\u5ea6\u3002

    \u6211\u4eec\u77e5\u9053\uff0c\u8f6f\u4ef6\u7684\u201c\u64a4\u9500\u201d\u529f\u80fd\u901a\u5e38\u4f7f\u7528\u6808\u6765\u5b9e\u73b0\uff1a\u7cfb\u7edf\u5c06\u6bcf\u6b21\u66f4\u6539\u64cd\u4f5c push \u5230\u6808\u4e2d\uff0c\u7136\u540e\u901a\u8fc7 pop \u5b9e\u73b0\u64a4\u9500\u3002\u7136\u800c\uff0c\u8003\u8651\u5230\u7cfb\u7edf\u8d44\u6e90\u7684\u9650\u5236\uff0c\u8f6f\u4ef6\u901a\u5e38\u4f1a\u9650\u5236\u64a4\u9500\u7684\u6b65\u6570\uff08\u4f8b\u5982\u4ec5\u5141\u8bb8\u4fdd\u5b58 \\(50\\) \u6b65\uff09\u3002\u5f53\u6808\u7684\u957f\u5ea6\u8d85\u8fc7 \\(50\\) \u65f6\uff0c\u8f6f\u4ef6\u9700\u8981\u5728\u6808\u5e95\uff08\u5373\u961f\u9996\uff09\u6267\u884c\u5220\u9664\u64cd\u4f5c\u3002\u4f46\u6808\u65e0\u6cd5\u5b9e\u73b0\u8be5\u529f\u80fd\uff0c\u6b64\u65f6\u5c31\u9700\u8981\u4f7f\u7528\u53cc\u5411\u961f\u5217\u6765\u66ff\u4ee3\u6808\u3002\u8bf7\u6ce8\u610f\uff0c\u201c\u64a4\u9500\u201d\u7684\u6838\u5fc3\u903b\u8f91\u4ecd\u7136\u9075\u5faa\u6808\u7684\u5148\u5165\u540e\u51fa\u539f\u5219\uff0c\u53ea\u662f\u53cc\u5411\u961f\u5217\u80fd\u591f\u66f4\u52a0\u7075\u6d3b\u5730\u5b9e\u73b0\u4e00\u4e9b\u989d\u5916\u903b\u8f91\u3002

    "},{"location":"chapter_stack_and_queue/queue/","title":"5.2. \u00a0 \u961f\u5217","text":"

    \u300c\u961f\u5217 Queue\u300d\u662f\u4e00\u79cd\u9075\u5faa\u5148\u5165\u5148\u51fa\uff08First In, First Out\uff09\u89c4\u5219\u7684\u7ebf\u6027\u6570\u636e\u7ed3\u6784\u3002\u987e\u540d\u601d\u4e49\uff0c\u961f\u5217\u6a21\u62df\u4e86\u6392\u961f\u73b0\u8c61\uff0c\u5373\u65b0\u6765\u7684\u4eba\u4e0d\u65ad\u52a0\u5165\u961f\u5217\u7684\u5c3e\u90e8\uff0c\u800c\u4f4d\u4e8e\u961f\u5217\u5934\u90e8\u7684\u4eba\u9010\u4e2a\u79bb\u5f00\u3002

    \u6211\u4eec\u628a\u961f\u5217\u7684\u5934\u90e8\u79f0\u4e3a\u300c\u961f\u9996\u300d\uff0c\u5c3e\u90e8\u79f0\u4e3a\u300c\u961f\u5c3e\u300d\uff0c\u628a\u5c06\u5143\u7d20\u52a0\u5165\u961f\u5c3e\u7684\u64cd\u4f5c\u79f0\u4e3a\u300c\u5165\u961f\u300d\uff0c\u5220\u9664\u961f\u9996\u5143\u7d20\u7684\u64cd\u4f5c\u79f0\u4e3a\u300c\u51fa\u961f\u300d\u3002

    Fig. \u961f\u5217\u7684\u5148\u5165\u5148\u51fa\u89c4\u5219

    "},{"location":"chapter_stack_and_queue/queue/#521","title":"5.2.1. \u00a0 \u961f\u5217\u5e38\u7528\u64cd\u4f5c","text":"

    \u961f\u5217\u7684\u5e38\u89c1\u64cd\u4f5c\u5982\u4e0b\u8868\u6240\u793a\u3002\u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u4e0d\u540c\u7f16\u7a0b\u8bed\u8a00\u7684\u65b9\u6cd5\u540d\u79f0\u53ef\u80fd\u4f1a\u6709\u6240\u4e0d\u540c\u3002\u6211\u4eec\u5728\u6b64\u91c7\u7528\u4e0e\u6808\u76f8\u540c\u7684\u65b9\u6cd5\u547d\u540d\u3002

    \u65b9\u6cd5\u540d \u63cf\u8ff0 \u65f6\u95f4\u590d\u6742\u5ea6 push() \u5143\u7d20\u5165\u961f\uff0c\u5373\u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u961f\u5c3e \\(O(1)\\) pop() \u961f\u9996\u5143\u7d20\u51fa\u961f \\(O(1)\\) peek() \u8bbf\u95ee\u961f\u9996\u5143\u7d20 \\(O(1)\\)

    \u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u4e2d\u73b0\u6210\u7684\u961f\u5217\u7c7b\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart queue.java
    /* \u521d\u59cb\u5316\u961f\u5217 */\nQueue<Integer> queue = new LinkedList<>();\n/* \u5143\u7d20\u5165\u961f */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.peek();\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.poll();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.size();\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = queue.isEmpty();\n
    queue.cpp
    /* \u521d\u59cb\u5316\u961f\u5217 */\nqueue<int> queue;\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint front = queue.front();\n/* \u5143\u7d20\u51fa\u961f */\nqueue.pop();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.size();\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty = queue.empty();\n
    queue.py
    # \u521d\u59cb\u5316\u961f\u5217\n# \u5728 Python \u4e2d\uff0c\u6211\u4eec\u4e00\u822c\u5c06\u53cc\u5411\u961f\u5217\u7c7b deque \u770b\u4f5c\u961f\u5217\u4f7f\u7528\n# \u867d\u7136 queue.Queue() \u662f\u7eaf\u6b63\u7684\u961f\u5217\u7c7b\uff0c\u4f46\u4e0d\u592a\u597d\u7528\uff0c\u56e0\u6b64\u4e0d\u5efa\u8bae\nque: Deque[int] = collections.deque()\n# \u5143\u7d20\u5165\u961f\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n# \u8bbf\u95ee\u961f\u9996\u5143\u7d20\nfront: int = que[0];\n# \u5143\u7d20\u51fa\u961f\npop: int = que.popleft()\n# \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\nsize: int = len(que)\n# \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(que) == 0\n
    queue_test.go
    /* \u521d\u59cb\u5316\u961f\u5217 */\n// \u5728 Go \u4e2d\uff0c\u5c06 list \u4f5c\u4e3a\u961f\u5217\u6765\u4f7f\u7528\nqueue := list.New()\n/* \u5143\u7d20\u5165\u961f */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek := queue.Front()\n/* \u5143\u7d20\u51fa\u961f */\npop := queue.Front()\nqueue.Remove(pop)\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nsize := queue.Len()\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty := queue.Len() == 0\n
    queue.js
    /* \u521d\u59cb\u5316\u961f\u5217 */\n// JavaScript \u6ca1\u6709\u5185\u7f6e\u7684\u961f\u5217\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u961f\u5217\u6765\u4f7f\u7528\nconst queue = [];\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nconst peek = queue[0];\n/* \u5143\u7d20\u51fa\u961f */\n// \u5e95\u5c42\u662f\u6570\u7ec4\uff0c\u56e0\u6b64 shift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\nconst pop = queue.shift();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = queue.length;\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst empty = queue.length === 0;\n
    queue.ts
    /* \u521d\u59cb\u5316\u961f\u5217 */\n// TypeScript \u6ca1\u6709\u5185\u7f6e\u7684\u961f\u5217\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u961f\u5217\u6765\u4f7f\u7528 \nconst queue: number[] = [];\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nconst peek = queue[0];\n/* \u5143\u7d20\u51fa\u961f */\n// \u5e95\u5c42\u662f\u6570\u7ec4\uff0c\u56e0\u6b64 shift() \u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\nconst pop = queue.shift();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = queue.length;\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst empty = queue.length === 0;\n
    queue.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u961f\u5217\n
    queue.cs
    /* \u521d\u59cb\u5316\u961f\u5217 */\nQueue<int> queue = new();\n/* \u5143\u7d20\u5165\u961f */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.Peek();\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.Dequeue();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.Count();\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = queue.Count() == 0;\n
    queue.swift
    /* \u521d\u59cb\u5316\u961f\u5217 */\n// Swift \u6ca1\u6709\u5185\u7f6e\u7684\u961f\u5217\u7c7b\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u961f\u5217\u6765\u4f7f\u7528\nvar queue: [Int] = []\n/* \u5143\u7d20\u5165\u961f */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nlet peek = queue.first!\n/* \u5143\u7d20\u51fa\u961f */\n// \u7531\u4e8e\u662f\u6570\u7ec4\uff0c\u56e0\u6b64 removeFirst \u7684\u590d\u6742\u5ea6\u4e3a O(n)\nlet pool = queue.removeFirst()\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = queue.count\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = queue.isEmpty\n
    queue.zig
    \n
    queue.dart
    /* \u521d\u59cb\u5316\u961f\u5217 */\n// \u5728 Dart \u4e2d\uff0c\u961f\u5217\u7c7b Qeque \u662f\u53cc\u5411\u961f\u5217\uff0c\u4e5f\u53ef\u4f5c\u4e3a\u961f\u5217\u4f7f\u7528\nQueue<int> queue = Queue();\n/* \u5143\u7d20\u5165\u961f */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.first;\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.removeFirst();\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.length;\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = queue.isEmpty;\n
    "},{"location":"chapter_stack_and_queue/queue/#522","title":"5.2.2. \u00a0 \u961f\u5217\u5b9e\u73b0","text":"

    \u4e3a\u4e86\u5b9e\u73b0\u961f\u5217\uff0c\u6211\u4eec\u9700\u8981\u4e00\u79cd\u6570\u636e\u7ed3\u6784\uff0c\u53ef\u4ee5\u5728\u4e00\u7aef\u6dfb\u52a0\u5143\u7d20\uff0c\u5e76\u5728\u53e6\u4e00\u7aef\u5220\u9664\u5143\u7d20\u3002\u56e0\u6b64\uff0c\u94fe\u8868\u548c\u6570\u7ec4\u90fd\u53ef\u4ee5\u7528\u6765\u5b9e\u73b0\u961f\u5217\u3002

    "},{"location":"chapter_stack_and_queue/queue/#_1","title":"\u57fa\u4e8e\u94fe\u8868\u7684\u5b9e\u73b0","text":"

    \u5bf9\u4e8e\u94fe\u8868\u5b9e\u73b0\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u94fe\u8868\u7684\u300c\u5934\u8282\u70b9\u300d\u548c\u300c\u5c3e\u8282\u70b9\u300d\u5206\u522b\u89c6\u4e3a\u961f\u9996\u548c\u961f\u5c3e\uff0c\u89c4\u5b9a\u961f\u5c3e\u4ec5\u53ef\u6dfb\u52a0\u8282\u70b9\uff0c\u800c\u961f\u9996\u4ec5\u53ef\u5220\u9664\u8282\u70b9\u3002

    LinkedListQueuepush()pop()

    \u4ee5\u4e0b\u662f\u7528\u94fe\u8868\u5b9e\u73b0\u961f\u5217\u7684\u793a\u4f8b\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linkedlist_queue.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nprivate ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\nprivate int queSize = 0;\npublic LinkedListQueue() {\nfront = null;\nrear = null;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f */\npublic void push(int num) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nListNode node = new ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (front == null) {\nfront = node;\nrear = node;\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n} else {\nrear.next = node;\nrear = node;\n}\nqueSize++;\n}\n/* \u51fa\u961f */\npublic int pop() {\nint num = peek();\n// \u5220\u9664\u5934\u8282\u70b9\nfront = front.next;\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peek() {\nif (size() == 0)\nthrow new IndexOutOfBoundsException();\nreturn front.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic int[] toArray() {\nListNode node = front;\nint[] res = new int[size()];\nfor (int i = 0; i < res.length; i++) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_queue.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nprivate:\nListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\nint queSize;\npublic:\nLinkedListQueue() {\nfront = nullptr;\nrear = nullptr;\nqueSize = 0;\n}\n~LinkedListQueue() {\n// \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\nfreeMemoryLinkedList(front);\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty() {\nreturn queSize == 0;\n}\n/* \u5165\u961f */\nvoid push(int num) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nListNode *node = new ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (front == nullptr) {\nfront = node;\nrear = node;\n}\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\nelse {\nrear->next = node;\nrear = node;\n}\nqueSize++;\n}\n/* \u51fa\u961f */\nvoid pop() {\nint num = peek();\n// \u5220\u9664\u5934\u8282\u70b9\nListNode *tmp = front;\nfront = front->next;\n// \u91ca\u653e\u5185\u5b58\ndelete tmp;\nqueSize--;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek() {\nif (size() == 0)\nthrow out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\nreturn front->val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\nvector<int> toVector() {\nListNode *node = front;\nvector<int> res(size());\nfor (int i = 0; i < res.size(); i++) {\nres[i] = node->val;\nnode = node->next;\n}\nreturn res;\n}\n};\n
    linkedlist_queue.py
    class LinkedListQueue:\n\"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__front: ListNode | None = None  # \u5934\u8282\u70b9 front\nself.__rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\nself.__size: int = 0\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\nreturn self.__size\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn not self.__front\ndef push(self, num: int) -> None:\n\"\"\"\u5165\u961f\"\"\"\n# \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nnode = ListNode(num)\n# \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif self.__front is None:\nself.__front = node\nself.__rear = node\n# \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\nelse:\nself.__rear.next = node\nself.__rear = node\nself.__size += 1\ndef pop(self) -> int:\n\"\"\"\u51fa\u961f\"\"\"\nnum = self.peek()\n# \u5220\u9664\u5934\u8282\u70b9\nself.__front = self.__front.next\nself.__size -= 1\nreturn num\ndef peek(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\nif self.size() == 0:\nprint(\"\u961f\u5217\u4e3a\u7a7a\")\nreturn False\nreturn self.__front.val\ndef to_list(self) -> list[int]:\n\"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\nqueue = []\ntemp = self.__front\nwhile temp:\nqueue.append(temp.val)\ntemp = temp.next\nreturn queue\n
    linkedlist_queue.go
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\ntype linkedListQueue struct {\n// \u4f7f\u7528\u5185\u7f6e\u5305 list \u6765\u5b9e\u73b0\u961f\u5217\ndata *list.List\n}\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newLinkedListQueue() *linkedListQueue {\nreturn &linkedListQueue{\ndata: list.New(),\n}\n}\n/* \u5165\u961f */\nfunc (s *linkedListQueue) push(value any) {\ns.data.PushBack(value)\n}\n/* \u51fa\u961f */\nfunc (s *linkedListQueue) pop() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Front()\ns.data.Remove(e)\nreturn e.Value\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListQueue) peek() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Front()\nreturn e.Value\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListQueue) size() int {\nreturn s.data.Len()\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListQueue) isEmpty() bool {\nreturn s.data.Len() == 0\n}\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListQueue) toList() *list.List {\nreturn s.data\n}\n
    linkedlist_queue.js
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n#front; // \u5934\u8282\u70b9 #front\n#rear; // \u5c3e\u8282\u70b9 #rear\n#queSize = 0;\nconstructor() {\nthis.#front = null;\nthis.#rear = null;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nget size() {\nreturn this.#queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty() {\nreturn this.size === 0;\n}\n/* \u5165\u961f */\npush(num) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nconst node = new ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (!this.#front) {\nthis.#front = node;\nthis.#rear = node;\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n} else {\nthis.#rear.next = node;\nthis.#rear = node;\n}\nthis.#queSize++;\n}\n/* \u51fa\u961f */\npop() {\nconst num = this.peek();\n// \u5220\u9664\u5934\u8282\u70b9\nthis.#front = this.#front.next;\nthis.#queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek() {\nif (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\nreturn this.#front.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\ntoArray() {\nlet node = this.#front;\nconst res = new Array(this.size);\nfor (let i = 0; i < res.length; i++) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_queue.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nprivate front: ListNode | null; // \u5934\u8282\u70b9 front\nprivate rear: ListNode | null; // \u5c3e\u8282\u70b9 rear\nprivate queSize: number = 0;\nconstructor() {\nthis.front = null;\nthis.rear = null;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nget size(): number {\nreturn this.queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty(): boolean {\nreturn this.size === 0;\n}\n/* \u5165\u961f */\npush(num: number): void {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nconst node = new ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (!this.front) {\nthis.front = node;\nthis.rear = node;\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n} else {\nthis.rear!.next = node;\nthis.rear = node;\n}\nthis.queSize++;\n}\n/* \u51fa\u961f */\npop(): number {\nconst num = this.peek();\nif (!this.front) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n// \u5220\u9664\u5934\u8282\u70b9\nthis.front = this.front.next;\nthis.queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek(): number {\nif (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\nreturn this.front!.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\ntoArray(): number[] {\nlet node = this.front;\nconst res = new Array<number>(this.size);\nfor (let i = 0; i < res.length; i++) {\nres[i] = node!.val;\nnode = node!.next;\n}\nreturn res;\n}\n}\n
    linkedlist_queue.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nstruct linkedListQueue {\nListNode *front, *rear;\nint queSize;\n};\ntypedef struct linkedListQueue linkedListQueue;\n/* \u6784\u9020\u51fd\u6570 */\nlinkedListQueue *newLinkedListQueue() {\nlinkedListQueue *queue = (linkedListQueue *)malloc(sizeof(linkedListQueue));\nqueue->front = NULL;\nqueue->rear = NULL;\nqueue->queSize = 0;\nreturn queue;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListQueue(linkedListQueue *queue) {\n// \u91ca\u653e\u6240\u6709\u8282\u70b9\nfor (int i = 0; i < queue->queSize && queue->front != NULL; i++) {\nListNode *tmp = queue->front;\nqueue->front = queue->front->next;\nfree(tmp);\n}\n// \u91ca\u653e queue \u7ed3\u6784\u4f53\nfree(queue);\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(linkedListQueue *queue) {\nreturn queue->queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(linkedListQueue *queue) {\nreturn (size(queue) == 0);\n}\n/* \u5165\u961f */\nvoid push(linkedListQueue *queue, int num) {\n// \u5c3e\u8282\u70b9\u5904\u6dfb\u52a0 node\nListNode *node = newListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (queue->front == NULL) {\nqueue->front = node;\nqueue->rear = node;\n}\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\nelse {\nqueue->rear->next = node;\nqueue->rear = node;\n}\nqueue->queSize++;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(linkedListQueue *queue) {\nassert(size(queue) && queue->front);\nreturn queue->front->val;\n}\n/* \u51fa\u961f */\nvoid pop(linkedListQueue *queue) {\nint num = peek(queue);\nListNode *tmp = queue->front;\nqueue->front = queue->front->next;\nfree(tmp);\nqueue->queSize--;\n}\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListQueue(linkedListQueue *queue) {\nint arr[queue->queSize];\n// \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\nint i;\nListNode *node;\nfor (i = 0, node = queue->front; i < queue->queSize && queue->front != queue->rear; i++) {\narr[i] = node->val;\nnode = node->next;\n}\nprintArray(arr, queue->queSize);\n}\n
    linkedlist_queue.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nprivate ListNode? front, rear;  // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear \nprivate int queSize = 0;\npublic LinkedListQueue() {\nfront = null;\nrear = null;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u961f */\npublic void push(int num) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nListNode node = new ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (front == null) {\nfront = node;\nrear = node;\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n} else if (rear != null) {\nrear.next = node;\nrear = node;\n}\nqueSize++;\n}\n/* \u51fa\u961f */\npublic int pop() {\nint num = peek();\n// \u5220\u9664\u5934\u8282\u70b9\nfront = front?.next;\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peek() {\nif (size() == 0 || front == null)\nthrow new Exception();\nreturn front.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic int[] toArray() {\nif (front == null)\nreturn Array.Empty<int>();\nListNode node = front;\nint[] res = new int[size()];\nfor (int i = 0; i < res.Length; i++) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_queue.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nprivate var front: ListNode? // \u5934\u8282\u70b9\nprivate var rear: ListNode? // \u5c3e\u8282\u70b9\nprivate var _size = 0\ninit() {}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc size() -> Int {\n_size\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nsize() == 0\n}\n/* \u5165\u961f */\nfunc push(num: Int) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nlet node = ListNode(x: num)\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif front == nil {\nfront = node\nrear = node\n}\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\nelse {\nrear?.next = node\nrear = node\n}\n_size += 1\n}\n/* \u51fa\u961f */\n@discardableResult\nfunc pop() -> Int {\nlet num = peek()\n// \u5220\u9664\u5934\u8282\u70b9\nfront = front?.next\n_size -= 1\nreturn num\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc peek() -> Int {\nif isEmpty() {\nfatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n}\nreturn front!.val\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nfunc toArray() -> [Int] {\nvar node = front\nvar res = Array(repeating: 0, count: size())\nfor i in res.indices {\nres[i] = node!.val\nnode = node?.next\n}\nreturn res\n}\n}\n
    linkedlist_queue.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\nfn LinkedListQueue(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nfront: ?*inc.ListNode(T) = null,                // \u5934\u8282\u70b9 front\nrear: ?*inc.ListNode(T) = null,                 // \u5c3e\u8282\u70b9 rear\nque_size: usize = 0,                            // \u961f\u5217\u7684\u957f\u5ea6\nmem_arena: ?std.heap.ArenaAllocator = null,\nmem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n// \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator) !void {\nif (self.mem_arena == null) {\nself.mem_arena = std.heap.ArenaAllocator.init(allocator);\nself.mem_allocator = self.mem_arena.?.allocator();\n}\nself.front = null;\nself.rear = null;\nself.que_size = 0;\n}\n// \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.mem_arena == null) return;\nself.mem_arena.?.deinit();\n}\n// \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\npub fn size(self: *Self) usize {\nreturn self.que_size;\n}\n// \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\npub fn isEmpty(self: *Self) bool {\nreturn self.size() == 0;\n}\n// \u8bbf\u95ee\u961f\u9996\u5143\u7d20\npub fn peek(self: *Self) T {\nif (self.size() == 0) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\nreturn self.front.?.val;\n}  // \u5165\u961f\npub fn push(self: *Self, num: T) !void {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nvar node = try self.mem_allocator.create(inc.ListNode(T));\nnode.init(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (self.front == null) {\nself.front = node;\nself.rear = node;\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n} else {\nself.rear.?.next = node;\nself.rear = node;\n}\nself.que_size += 1;\n} // \u51fa\u961f\npub fn pop(self: *Self) T {\nvar num = self.peek();\n// \u5220\u9664\u5934\u8282\u70b9\nself.front = self.front.?.next;\nself.que_size -= 1;\nreturn num;\n} // \u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\npub fn toArray(self: *Self) ![]T {\nvar node = self.front;\nvar res = try self.mem_allocator.alloc(T, self.size());\n@memset(res, @as(T, 0));\nvar i: usize = 0;\nwhile (i < res.len) : (i += 1) {\nres[i] = node.?.val;\nnode = node.?.next;\n}\nreturn res;\n}\n};\n}\n
    linkedlist_queue.dart
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\nListNode? _front; // \u5934\u8282\u70b9 _front\nListNode? _rear; // \u5c3e\u8282\u70b9 _rear\nint _queSize = 0; // \u961f\u5217\u957f\u5ea6\nLinkedListQueue() {\n_front = null;\n_rear = null;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn _queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn _queSize == 0;\n}\n/* \u5165\u961f */\nvoid push(int num) {\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nfinal node = ListNode(num);\n// \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\nif (_front == null) {\n_front = node;\n_rear = node;\n} else {\n// \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n_rear!.next = node;\n_rear = node;\n}\n_queSize++;\n}\n/* \u51fa\u961f */\nint pop() {\nfinal int num = peek();\n// \u5220\u9664\u5934\u8282\u70b9\n_front = _front!.next;\n_queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek() {\nif (_queSize == 0) {\nthrow Exception('\u961f\u5217\u4e3a\u7a7a');\n}\nreturn _front!.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nList<int> toArray() {\nListNode? node = _front;\nfinal List<int> queue = [];\nwhile (node != null) {\nqueue.add(node.val);\nnode = node.next;\n}\nreturn queue;\n}\n}\n
    "},{"location":"chapter_stack_and_queue/queue/#_2","title":"\u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u7531\u4e8e\u6570\u7ec4\u5220\u9664\u9996\u5143\u7d20\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u8fd9\u4f1a\u5bfc\u81f4\u51fa\u961f\u64cd\u4f5c\u6548\u7387\u8f83\u4f4e\u3002\u7136\u800c\uff0c\u6211\u4eec\u53ef\u4ee5\u91c7\u7528\u4ee5\u4e0b\u5de7\u5999\u65b9\u6cd5\u6765\u907f\u514d\u8fd9\u4e2a\u95ee\u9898\u3002

    \u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4e00\u4e2a\u53d8\u91cf front \u6307\u5411\u961f\u9996\u5143\u7d20\u7684\u7d22\u5f15\uff0c\u5e76\u7ef4\u62a4\u4e00\u4e2a\u53d8\u91cf queSize \u7528\u4e8e\u8bb0\u5f55\u961f\u5217\u957f\u5ea6\u3002\u5b9a\u4e49 rear = front + queSize \uff0c\u8fd9\u4e2a\u516c\u5f0f\u8ba1\u7b97\u51fa\u7684 rear \u6307\u5411\u961f\u5c3e\u5143\u7d20\u4e4b\u540e\u7684\u4e0b\u4e00\u4e2a\u4f4d\u7f6e\u3002

    \u57fa\u4e8e\u6b64\u8bbe\u8ba1\uff0c\u6570\u7ec4\u4e2d\u5305\u542b\u5143\u7d20\u7684\u6709\u6548\u533a\u95f4\u4e3a [front, rear - 1]\uff0c\u8fdb\u800c\uff1a

    • \u5bf9\u4e8e\u5165\u961f\u64cd\u4f5c\uff0c\u5c06\u8f93\u5165\u5143\u7d20\u8d4b\u503c\u7ed9 rear \u7d22\u5f15\u5904\uff0c\u5e76\u5c06 queSize \u589e\u52a0 1 \uff1b
    • \u5bf9\u4e8e\u51fa\u961f\u64cd\u4f5c\uff0c\u53ea\u9700\u5c06 front \u589e\u52a0 1 \uff0c\u5e76\u5c06 queSize \u51cf\u5c11 1 \uff1b

    \u53ef\u4ee5\u770b\u5230\uff0c\u5165\u961f\u548c\u51fa\u961f\u64cd\u4f5c\u90fd\u53ea\u9700\u8fdb\u884c\u4e00\u6b21\u64cd\u4f5c\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(1)\\) \u3002

    ArrayQueuepush()pop()

    \u4f60\u53ef\u80fd\u4f1a\u53d1\u73b0\u4e00\u4e2a\u95ee\u9898\uff1a\u5728\u4e0d\u65ad\u8fdb\u884c\u5165\u961f\u548c\u51fa\u961f\u7684\u8fc7\u7a0b\u4e2d\uff0cfront \u548c rear \u90fd\u5728\u5411\u53f3\u79fb\u52a8\uff0c\u5f53\u5b83\u4eec\u5230\u8fbe\u6570\u7ec4\u5c3e\u90e8\u65f6\u5c31\u65e0\u6cd5\u7ee7\u7eed\u79fb\u52a8\u4e86\u3002\u4e3a\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u7ec4\u89c6\u4e3a\u9996\u5c3e\u76f8\u63a5\u7684\u300c\u73af\u5f62\u6570\u7ec4\u300d\u3002

    \u5bf9\u4e8e\u73af\u5f62\u6570\u7ec4\uff0c\u6211\u4eec\u9700\u8981\u8ba9 front \u6216 rear \u5728\u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u76f4\u63a5\u56de\u5230\u6570\u7ec4\u5934\u90e8\u7ee7\u7eed\u904d\u5386\u3002\u8fd9\u79cd\u5468\u671f\u6027\u89c4\u5f8b\u53ef\u4ee5\u901a\u8fc7\u201c\u53d6\u4f59\u64cd\u4f5c\u201d\u6765\u5b9e\u73b0\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array_queue.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nprivate int[] nums; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate int queSize; // \u961f\u5217\u957f\u5ea6\npublic ArrayQueue(int capacity) {\nnums = new int[capacity];\nfront = queSize = 0;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\npublic int capacity() {\nreturn nums.length;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn queSize == 0;\n}\n/* \u5165\u961f */\npublic void push(int num) {\nif (queSize == capacity()) {\nSystem.out.println(\"\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nint rear = (front + queSize) % capacity();\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u51fa\u961f */\npublic int pop() {\nint num = peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nfront = (front + 1) % capacity();\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peek() {\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\nreturn nums[front];\n}\n/* \u8fd4\u56de\u6570\u7ec4 */\npublic int[] toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] res = new int[queSize];\nfor (int i = 0, j = front; i < queSize; i++, j++) {\nres[i] = nums[j % capacity()];\n}\nreturn res;\n}\n}\n
    array_queue.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nprivate:\nint *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nint front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nint queSize;     // \u961f\u5217\u957f\u5ea6\nint queCapacity; // \u961f\u5217\u5bb9\u91cf\npublic:\nArrayQueue(int capacity) {\n// \u521d\u59cb\u5316\u6570\u7ec4\nnums = new int[capacity];\nqueCapacity = capacity;\nfront = queSize = 0;\n}\n~ArrayQueue() {\ndelete[] nums;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity() {\nreturn queCapacity;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty() {\nreturn size() == 0;\n}\n/* \u5165\u961f */\nvoid push(int num) {\nif (queSize == queCapacity) {\ncout << \"\u961f\u5217\u5df2\u6ee1\" << endl;\nreturn;\n}\n// \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nint rear = (front + queSize) % queCapacity;\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u51fa\u961f */\nvoid pop() {\nint num = peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nfront = (front + 1) % queCapacity;\nqueSize--;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek() {\nif (empty())\nthrow out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\nreturn nums[front];\n}\n/* \u5c06\u6570\u7ec4\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\nvector<int> toVector() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvector<int> arr(queSize);\nfor (int i = 0, j = front; i < queSize; i++, j++) {\narr[i] = nums[j % queCapacity];\n}\nreturn arr;\n}\n};\n
    array_queue.py
    class ArrayQueue:\n\"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\ndef __init__(self, size: int) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__nums: list[int] = [0] * size  # \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nself.__front: int = 0  # \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nself.__size: int = 0  # \u961f\u5217\u957f\u5ea6\ndef capacity(self) -> int:\n\"\"\"\u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\nreturn len(self.__nums)\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\nreturn self.__size\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn self.__size == 0\ndef push(self, num: int) -> None:\n\"\"\"\u5165\u961f\"\"\"\nif self.__size == self.capacity():\nraise IndexError(\"\u961f\u5217\u5df2\u6ee1\")\n# \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n# \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8F\nrear: int = (self.__front + self.__size) % self.capacity()\n# \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nself.__nums[rear] = num\nself.__size += 1\ndef pop(self) -> int:\n\"\"\"\u51fa\u961f\"\"\"\nnum: int = self.peek()\n# \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nself.__front = (self.__front + 1) % self.capacity()\nself.__size -= 1\nreturn num\ndef peek(self) -> int:\n\"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\nif self.is_empty():\nraise IndexError(\"\u961f\u5217\u4e3a\u7a7a\")\nreturn self.__nums[self.__front]\ndef to_list(self) -> list[int]:\n\"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\nres = [0] * self.size()\nj: int = self.__front\nfor i in range(self.size()):\nres[i] = self.__nums[(j % self.capacity())]\nj += 1\nreturn res\n
    array_queue.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\ntype arrayQueue struct {\nnums        []int // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nfront       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nqueSize     int   // \u961f\u5217\u957f\u5ea6\nqueCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\nreturn &arrayQueue{\nnums:        make([]int, queCapacity),\nqueCapacity: queCapacity,\nfront:       0,\nqueSize:     0,\n}\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayQueue) size() int {\nreturn q.queSize\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayQueue) isEmpty() bool {\nreturn q.queSize == 0\n}\n/* \u5165\u961f */\nfunc (q *arrayQueue) push(num int) {\n// \u5f53 rear == queCapacity \u8868\u793a\u961f\u5217\u5df2\u6ee1\nif q.queSize == q.queCapacity {\nreturn\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nrear := (q.front + q.queSize) % q.queCapacity\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nq.nums[rear] = num\nq.queSize++\n}\n/* \u51fa\u961f */\nfunc (q *arrayQueue) pop() any {\nnum := q.peek()\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nq.front = (q.front + 1) % q.queCapacity\nq.queSize--\nreturn num\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayQueue) peek() any {\nif q.isEmpty() {\nreturn nil\n}\nreturn q.nums[q.front]\n}\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (q *arrayQueue) toSlice() []int {\nrear := (q.front + q.queSize)\nif rear >= q.queCapacity {\nrear %= q.queCapacity\nreturn append(q.nums[q.front:], q.nums[:rear]...)\n}\nreturn q.nums[q.front:rear]\n}\n
    array_queue.js
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n#nums; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n#front = 0; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n#queSize = 0; // \u961f\u5217\u957f\u5ea6\nconstructor(capacity) {\nthis.#nums = new Array(capacity);\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nget capacity() {\nreturn this.#nums.length;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nget size() {\nreturn this.#queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nempty() {\nreturn this.#queSize == 0;\n}\n/* \u5165\u961f */\npush(num) {\nif (this.size == this.capacity) {\nconsole.log('\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nconst rear = (this.#front + this.size) % this.capacity;\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nthis.#nums[rear] = num;\nthis.#queSize++;\n}\n/* \u51fa\u961f */\npop() {\nconst num = this.peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nthis.#front = (this.#front + 1) % this.capacity;\nthis.#queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek() {\nif (this.empty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\nreturn this.#nums[this.#front];\n}\n/* \u8fd4\u56de Array */\ntoArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst arr = new Array(this.size);\nfor (let i = 0, j = this.#front; i < this.size; i++, j++) {\narr[i] = this.#nums[j % this.capacity];\n}\nreturn arr;\n}\n}\n
    array_queue.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nprivate nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate queSize: number; // \u961f\u5217\u957f\u5ea6\nconstructor(capacity: number) {\nthis.nums = new Array(capacity);\nthis.front = this.queSize = 0;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nget capacity(): number {\nreturn this.nums.length;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nget size(): number {\nreturn this.queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nempty(): boolean {\nreturn this.queSize == 0;\n}\n/* \u5165\u961f */\npush(num: number): void {\nif (this.size == this.capacity) {\nconsole.log('\u961f\u5217\u5df2\u6ee1');\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nconst rear = (this.front + this.queSize) % this.capacity;\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nthis.nums[rear] = num;\nthis.queSize++;\n}\n/* \u51fa\u961f */\npop(): number {\nconst num = this.peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nthis.front = (this.front + 1) % this.capacity;\nthis.queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek(): number {\nif (this.empty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\nreturn this.nums[this.front];\n}\n/* \u8fd4\u56de Array */\ntoArray(): number[] {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nconst arr = new Array(this.size);\nfor (let i = 0, j = this.front; i < this.size; i++, j++) {\narr[i] = this.nums[j % this.capacity];\n}\nreturn arr;\n}\n}\n
    array_queue.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nstruct arrayQueue {\nint *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nint front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nint queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\nint queCapacity; // \u961f\u5217\u5bb9\u91cf\n};\ntypedef struct arrayQueue arrayQueue;\n/* \u6784\u9020\u51fd\u6570 */\narrayQueue *newArrayQueue(int capacity) {\narrayQueue *queue = (arrayQueue *)malloc(sizeof(arrayQueue));\n// \u521d\u59cb\u5316\u6570\u7ec4\nqueue->queCapacity = capacity;\nqueue->nums = (int *)malloc(sizeof(int) * queue->queCapacity);\nqueue->front = queue->queSize = 0;\nreturn queue;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayQueue(arrayQueue *queue) {\nfree(queue->nums);\nqueue->queCapacity = 0;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(arrayQueue *queue) {\nreturn queue->queCapacity;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(arrayQueue *queue) {\nreturn queue->queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(arrayQueue *queue) {\nreturn queue->queSize == 0;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(arrayQueue *queue) {\nassert(size(queue) != 0);\nreturn queue->nums[queue->front];\n}\n/* \u5165\u961f */\nvoid push(arrayQueue *queue, int num) {\nif (size(queue) == capacity(queue)) {\nprintf(\"\u961f\u5217\u5df2\u6ee1\\r\\n\");\nreturn;\n}\n// \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nint rear = (queue->front + queue->queSize) % queue->queCapacity;\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nqueue->nums[rear] = num;\nqueue->queSize++;\n}\n/* \u51fa\u961f */\nvoid pop(arrayQueue *queue) {\nint num = peek(queue);\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nqueue->front = (queue->front + 1) % queue->queCapacity;\nqueue->queSize--;\n}\n/* \u6253\u5370\u961f\u5217 */\nvoid printArrayQueue(arrayQueue *queue) {\nint arr[queue->queSize];\n// \u62f7\u8d1d\nfor (int i = 0, j = queue->front; i < queue->queSize; i++, j++) {\narr[i] = queue->nums[j % queue->queCapacity];\n}\nprintArray(arr, queue->queSize);\n}\n
    array_queue.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nprivate int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate int queSize; // \u961f\u5217\u957f\u5ea6\npublic ArrayQueue(int capacity) {\nnums = new int[capacity];\nfront = queSize = 0;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\npublic int capacity() {\nreturn nums.Length;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\npublic int size() {\nreturn queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn queSize == 0;\n}\n/* \u5165\u961f */\npublic void push(int num) {\nif (queSize == capacity()) {\nConsole.WriteLine(\"\u961f\u5217\u5df2\u6ee1\");\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nint rear = (front + queSize) % capacity();\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num;\nqueSize++;\n}\n/* \u51fa\u961f */\npublic int pop() {\nint num = peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nfront = (front + 1) % capacity();\nqueSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npublic int peek() {\nif (isEmpty())\nthrow new Exception();\nreturn nums[front];\n}\n/* \u8fd4\u56de\u6570\u7ec4 */\npublic int[] toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nint[] res = new int[queSize];\nfor (int i = 0, j = front; i < queSize; i++, j++) {\nres[i] = nums[j % this.capacity()];\n}\nreturn res;\n}\n}\n
    array_queue.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nprivate var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nprivate var front = 0 // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nprivate var queSize = 0 // \u961f\u5217\u957f\u5ea6\ninit(capacity: Int) {\n// \u521d\u59cb\u5316\u6570\u7ec4\nnums = Array(repeating: 0, count: capacity)\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nfunc capacity() -> Int {\nnums.count\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc size() -> Int {\nqueSize\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nqueSize == 0\n}\n/* \u5165\u961f */\nfunc push(num: Int) {\nif size() == capacity() {\nprint(\"\u961f\u5217\u5df2\u6ee1\")\nreturn\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nlet rear = (front + queSize) % capacity()\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\nnums[rear] = num\nqueSize += 1\n}\n/* \u51fa\u961f */\n@discardableResult\nfunc pop() -> Int {\nlet num = peek()\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nfront = (front + 1) % capacity()\nqueSize -= 1\nreturn num\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc peek() -> Int {\nif isEmpty() {\nfatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n}\nreturn nums[front]\n}\n/* \u8fd4\u56de\u6570\u7ec4 */\nfunc toArray() -> [Int] {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvar res = Array(repeating: 0, count: queSize)\nfor (i, j) in sequence(first: (0, front), next: { $0 < self.queSize - 1 ? ($0 + 1, $1 + 1) : nil }) {\nres[i] = nums[j % capacity()]\n}\nreturn res\n}\n}\n
    array_queue.zig
    // \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\nfn ArrayQueue(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nnums: []T = undefined,                          // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4     \ncap: usize = 0,                                 // \u961f\u5217\u5bb9\u91cf\nfront: usize = 0,                               // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nqueSize: usize = 0,                             // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\nmem_arena: ?std.heap.ArenaAllocator = null,\nmem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n// \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6570\u7ec4\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator, cap: usize) !void {\nif (self.mem_arena == null) {\nself.mem_arena = std.heap.ArenaAllocator.init(allocator);\nself.mem_allocator = self.mem_arena.?.allocator();\n}\nself.cap = cap;\nself.nums = try self.mem_allocator.alloc(T, self.cap);\n@memset(self.nums, @as(T, 0));\n}\n// \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.mem_arena == null) return;\nself.mem_arena.?.deinit();\n}\n// \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\npub fn capacity(self: *Self) usize {\nreturn self.cap;\n}\n// \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\npub fn size(self: *Self) usize {\nreturn self.queSize;\n}\n// \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\npub fn isEmpty(self: *Self) bool {\nreturn self.queSize == 0;\n}\n// \u5165\u961f\npub fn push(self: *Self, num: T) !void {\nif (self.size() == self.capacity()) {\nstd.debug.print(\"\u961f\u5217\u5df2\u6ee1\\n\", .{});\nreturn;\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nvar rear = (self.front + self.queSize) % self.capacity();\n// \u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\nself.nums[rear] = num;\nself.queSize += 1;\n} // \u51fa\u961f\npub fn pop(self: *Self) T {\nvar num = self.peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\nself.front = (self.front + 1) % self.capacity();\nself.queSize -= 1;\nreturn num;\n} // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\npub fn peek(self: *Self) T {\nif (self.isEmpty()) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\nreturn self.nums[self.front];\n} // \u8fd4\u56de\u6570\u7ec4\npub fn toArray(self: *Self) ![]T {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nvar res = try self.mem_allocator.alloc(T, self.size());\n@memset(res, @as(T, 0));\nvar i: usize = 0;\nvar j: usize = self.front;\nwhile (i < self.size()) : ({ i += 1; j += 1; }) {\nres[i] = self.nums[j % self.capacity()];\n}\nreturn res;\n}\n};\n}\n
    array_queue.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\nlate List<int> _nums; // \u7528\u4e8e\u50a8\u5b58\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\nlate int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\nlate int _queSize; // \u961f\u5217\u957f\u5ea6\nArrayQueue(int capacity) {\n_nums = List.filled(capacity, 0);\n_front = _queSize = 0;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nint capaCity() {\nreturn _nums.length;\n}\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size() {\nreturn _queSize;\n}\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn _queSize == 0;\n}\n/* \u5165\u961f */\nvoid push(int num) {\nif (_queSize == capaCity()) {\nthrow Exception(\"\u961f\u5217\u5df2\u6ee1\");\n}\n// \u8ba1\u7b97\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n// \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\uff0c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\nint rear = (_front + _queSize) % capaCity();\n// \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n_nums[rear] = num;\n_queSize++;\n}\n/* \u51fa\u961f */\nint pop() {\nint num = peek();\n// \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n_front = (_front + 1) % capaCity();\n_queSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek() {\nif (isEmpty()) {\nthrow Exception(\"\u961f\u5217\u4e3a\u7a7a\");\n}\nreturn _nums[_front];\n}\n/* \u8fd4\u56de Array */\nList<int> toArray() {\n// \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\nfinal List<int> res = List.filled(_queSize, 0);\nfor (int i = 0, j = _front; i < _queSize; i++, j++) {\nres[i] = _nums[j % capaCity()];\n}\nreturn res;\n}\n}\n

    \u4ee5\u4e0a\u5b9e\u73b0\u7684\u961f\u5217\u4ecd\u7136\u5177\u6709\u5c40\u9650\u6027\uff0c\u5373\u5176\u957f\u5ea6\u4e0d\u53ef\u53d8\u3002\u7136\u800c\uff0c\u8fd9\u4e2a\u95ee\u9898\u4e0d\u96be\u89e3\u51b3\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u7ec4\u66ff\u6362\u4e3a\u52a8\u6001\u6570\u7ec4\uff0c\u4ece\u800c\u5f15\u5165\u6269\u5bb9\u673a\u5236\u3002\u6709\u5174\u8da3\u7684\u540c\u5b66\u53ef\u4ee5\u5c1d\u8bd5\u81ea\u884c\u5b9e\u73b0\u3002

    \u4e24\u79cd\u5b9e\u73b0\u7684\u5bf9\u6bd4\u7ed3\u8bba\u4e0e\u6808\u4e00\u81f4\uff0c\u5728\u6b64\u4e0d\u518d\u8d58\u8ff0\u3002

    "},{"location":"chapter_stack_and_queue/queue/#523","title":"5.2.3. \u00a0 \u961f\u5217\u5178\u578b\u5e94\u7528","text":"
    • \u6dd8\u5b9d\u8ba2\u5355\u3002\u8d2d\u7269\u8005\u4e0b\u5355\u540e\uff0c\u8ba2\u5355\u5c06\u52a0\u5165\u961f\u5217\u4e2d\uff0c\u7cfb\u7edf\u968f\u540e\u4f1a\u6839\u636e\u987a\u5e8f\u4f9d\u6b21\u5904\u7406\u961f\u5217\u4e2d\u7684\u8ba2\u5355\u3002\u5728\u53cc\u5341\u4e00\u671f\u95f4\uff0c\u77ed\u65f6\u95f4\u5185\u4f1a\u4ea7\u751f\u6d77\u91cf\u8ba2\u5355\uff0c\u9ad8\u5e76\u53d1\u6210\u4e3a\u5de5\u7a0b\u5e08\u4eec\u9700\u8981\u91cd\u70b9\u653b\u514b\u7684\u95ee\u9898\u3002
    • \u5404\u7c7b\u5f85\u529e\u4e8b\u9879\u3002\u4efb\u4f55\u9700\u8981\u5b9e\u73b0\u201c\u5148\u6765\u540e\u5230\u201d\u529f\u80fd\u7684\u573a\u666f\uff0c\u4f8b\u5982\u6253\u5370\u673a\u7684\u4efb\u52a1\u961f\u5217\u3001\u9910\u5385\u7684\u51fa\u9910\u961f\u5217\u7b49\u3002\u961f\u5217\u5728\u8fd9\u4e9b\u573a\u666f\u4e2d\u53ef\u4ee5\u6709\u6548\u5730\u7ef4\u62a4\u5904\u7406\u987a\u5e8f\u3002
    "},{"location":"chapter_stack_and_queue/stack/","title":"5.1. \u00a0 \u6808","text":"

    \u300c\u6808 Stack\u300d\u662f\u4e00\u79cd\u9075\u5faa\u5148\u5165\u540e\u51fa\uff08First In, Last Out\uff09\u539f\u5219\u7684\u7ebf\u6027\u6570\u636e\u7ed3\u6784\u3002

    \u6211\u4eec\u53ef\u4ee5\u5c06\u6808\u7c7b\u6bd4\u4e3a\u684c\u9762\u4e0a\u7684\u4e00\u645e\u76d8\u5b50\uff0c\u5982\u679c\u9700\u8981\u62ff\u51fa\u5e95\u90e8\u7684\u76d8\u5b50\uff0c\u5219\u9700\u8981\u5148\u5c06\u4e0a\u9762\u7684\u76d8\u5b50\u4f9d\u6b21\u53d6\u51fa\u3002\u6211\u4eec\u5c06\u76d8\u5b50\u66ff\u6362\u4e3a\u5404\u79cd\u7c7b\u578b\u7684\u5143\u7d20\uff08\u5982\u6574\u6570\u3001\u5b57\u7b26\u3001\u5bf9\u8c61\u7b49\uff09\uff0c\u5c31\u5f97\u5230\u4e86\u6808\u6570\u636e\u7ed3\u6784\u3002

    \u5728\u6808\u4e2d\uff0c\u6211\u4eec\u628a\u5806\u53e0\u5143\u7d20\u7684\u9876\u90e8\u79f0\u4e3a\u300c\u6808\u9876\u300d\uff0c\u5e95\u90e8\u79f0\u4e3a\u300c\u6808\u5e95\u300d\u3002\u5c06\u628a\u5143\u7d20\u6dfb\u52a0\u5230\u6808\u9876\u7684\u64cd\u4f5c\u53eb\u505a\u300c\u5165\u6808\u300d\uff0c\u800c\u5220\u9664\u6808\u9876\u5143\u7d20\u7684\u64cd\u4f5c\u53eb\u505a\u300c\u51fa\u6808\u300d\u3002

    Fig. \u6808\u7684\u5148\u5165\u540e\u51fa\u89c4\u5219

    "},{"location":"chapter_stack_and_queue/stack/#511","title":"5.1.1. \u00a0 \u6808\u5e38\u7528\u64cd\u4f5c","text":"

    \u6808\u7684\u5e38\u7528\u64cd\u4f5c\u5982\u4e0b\u8868\u6240\u793a\uff0c\u5177\u4f53\u7684\u65b9\u6cd5\u540d\u9700\u8981\u6839\u636e\u6240\u4f7f\u7528\u7684\u7f16\u7a0b\u8bed\u8a00\u6765\u786e\u5b9a\u3002\u5728\u6b64\uff0c\u6211\u4eec\u4ee5\u5e38\u89c1\u7684 push() , pop() , peek() \u547d\u540d\u4e3a\u4f8b\u3002

    \u65b9\u6cd5 \u63cf\u8ff0 \u65f6\u95f4\u590d\u6742\u5ea6 push() \u5143\u7d20\u5165\u6808\uff08\u6dfb\u52a0\u81f3\u6808\u9876\uff09 \\(O(1)\\) pop() \u6808\u9876\u5143\u7d20\u51fa\u6808 \\(O(1)\\) peek() \u8bbf\u95ee\u6808\u9876\u5143\u7d20 \\(O(1)\\)

    \u901a\u5e38\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u5185\u7f6e\u7684\u6808\u7c7b\u3002\u7136\u800c\uff0c\u67d0\u4e9b\u8bed\u8a00\u53ef\u80fd\u6ca1\u6709\u4e13\u95e8\u63d0\u4f9b\u6808\u7c7b\uff0c\u8fd9\u65f6\u6211\u4eec\u53ef\u4ee5\u5c06\u8be5\u8bed\u8a00\u7684\u300c\u6570\u7ec4\u300d\u6216\u300c\u94fe\u8868\u300d\u89c6\u4f5c\u6808\u6765\u4f7f\u7528\uff0c\u5e76\u901a\u8fc7\u201c\u8111\u8865\u201d\u6765\u5ffd\u7565\u4e0e\u6808\u65e0\u5173\u7684\u64cd\u4f5c\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart stack.java
    /* \u521d\u59cb\u5316\u6808 */\nStack<Integer> stack = new Stack<>();\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.peek();\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.pop();\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.size();\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = stack.isEmpty();\n
    stack.cpp
    /* \u521d\u59cb\u5316\u6808 */\nstack<int> stack;\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint top = stack.top();\n/* \u5143\u7d20\u51fa\u6808 */\nstack.pop(); // \u65e0\u8fd4\u56de\u503c\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.size();\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool empty = stack.empty();\n
    stack.py
    # \u521d\u59cb\u5316\u6808\n# Python \u6ca1\u6709\u5185\u7f6e\u7684\u6808\u7c7b\uff0c\u53ef\u4ee5\u628a List \u5f53\u4f5c\u6808\u6765\u4f7f\u7528 \nstack: List[int] = []\n# \u5143\u7d20\u5165\u6808\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n# \u8bbf\u95ee\u6808\u9876\u5143\u7d20\npeek: int = stack[-1]\n# \u5143\u7d20\u51fa\u6808\npop: int = stack.pop()\n# \u83b7\u53d6\u6808\u7684\u957f\u5ea6\nsize: int = len(stack)\n# \u5224\u65ad\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(stack) == 0\n
    stack_test.go
    /* \u521d\u59cb\u5316\u6808 */\n// \u5728 Go \u4e2d\uff0c\u63a8\u8350\u5c06 Slice \u5f53\u4f5c\u6808\u6765\u4f7f\u7528\nvar stack []int\n/* \u5143\u7d20\u5165\u6808 */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npeek := stack[len(stack)-1]\n/* \u5143\u7d20\u51fa\u6808 */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nsize := len(stack)\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nisEmpty := len(stack) == 0\n
    stack.js
    /* \u521d\u59cb\u5316\u6808 */\n// Javascript \u6ca1\u6709\u5185\u7f6e\u7684\u6808\u7c7b\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u6808\u6765\u4f7f\u7528 \nconst stack = [];\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nconst peek = stack[stack.length-1];\n/* \u5143\u7d20\u51fa\u6808 */\nconst pop = stack.pop();\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nconst size = stack.length;\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nconst is_empty = stack.length === 0;\n
    stack.ts
    /* \u521d\u59cb\u5316\u6808 */\n// Typescript \u6ca1\u6709\u5185\u7f6e\u7684\u6808\u7c7b\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u6808\u6765\u4f7f\u7528 \nconst stack: number[] = [];\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nconst peek = stack[stack.length - 1];\n/* \u5143\u7d20\u51fa\u6808 */\nconst pop = stack.pop();\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nconst size = stack.length;\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nconst is_empty = stack.length === 0;\n
    stack.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u6808\n
    stack.cs
    /* \u521d\u59cb\u5316\u6808 */\nStack<int> stack = new ();\n/* \u5143\u7d20\u5165\u6808 */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.Peek();\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.Pop();\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.Count();\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = stack.Count()==0;\n
    stack.swift
    /* \u521d\u59cb\u5316\u6808 */\n// Swift \u6ca1\u6709\u5185\u7f6e\u7684\u6808\u7c7b\uff0c\u53ef\u4ee5\u628a Array \u5f53\u4f5c\u6808\u6765\u4f7f\u7528\nvar stack: [Int] = []\n/* \u5143\u7d20\u5165\u6808 */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nlet peek = stack.last!\n/* \u5143\u7d20\u51fa\u6808 */\nlet pop = stack.removeLast()\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nlet size = stack.count\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = stack.isEmpty\n
    stack.zig
    \n
    stack.dart
    /* \u521d\u59cb\u5316\u6808 */\n// Dart \u6ca1\u6709\u5185\u7f6e\u7684\u6808\u7c7b\uff0c\u53ef\u4ee5\u628a List \u5f53\u4f5c\u6808\u6765\u4f7f\u7528\nList<int> stack = [];\n/* \u5143\u7d20\u5165\u6808 */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.last;\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.removeLast();\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.length;\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = stack.isEmpty;\n
    "},{"location":"chapter_stack_and_queue/stack/#512","title":"5.1.2. \u00a0 \u6808\u7684\u5b9e\u73b0","text":"

    \u4e3a\u4e86\u6df1\u5165\u4e86\u89e3\u6808\u7684\u8fd0\u884c\u673a\u5236\uff0c\u6211\u4eec\u6765\u5c1d\u8bd5\u81ea\u5df1\u5b9e\u73b0\u4e00\u4e2a\u6808\u7c7b\u3002

    \u6808\u9075\u5faa\u5148\u5165\u540e\u51fa\u7684\u539f\u5219\uff0c\u56e0\u6b64\u6211\u4eec\u53ea\u80fd\u5728\u6808\u9876\u6dfb\u52a0\u6216\u5220\u9664\u5143\u7d20\u3002\u7136\u800c\uff0c\u6570\u7ec4\u548c\u94fe\u8868\u90fd\u53ef\u4ee5\u5728\u4efb\u610f\u4f4d\u7f6e\u6dfb\u52a0\u548c\u5220\u9664\u5143\u7d20\uff0c\u56e0\u6b64\u6808\u53ef\u4ee5\u88ab\u89c6\u4e3a\u4e00\u79cd\u53d7\u9650\u5236\u7684\u6570\u7ec4\u6216\u94fe\u8868\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u6211\u4eec\u53ef\u4ee5\u201c\u5c4f\u853d\u201d\u6570\u7ec4\u6216\u94fe\u8868\u7684\u90e8\u5206\u65e0\u5173\u64cd\u4f5c\uff0c\u4f7f\u5176\u5bf9\u5916\u8868\u73b0\u7684\u903b\u8f91\u7b26\u5408\u6808\u7684\u7279\u6027\u3002

    "},{"location":"chapter_stack_and_queue/stack/#_1","title":"\u57fa\u4e8e\u94fe\u8868\u7684\u5b9e\u73b0","text":"

    \u4f7f\u7528\u94fe\u8868\u6765\u5b9e\u73b0\u6808\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u94fe\u8868\u7684\u5934\u8282\u70b9\u89c6\u4e3a\u6808\u9876\uff0c\u5c3e\u8282\u70b9\u89c6\u4e3a\u6808\u5e95\u3002

    \u5bf9\u4e8e\u5165\u6808\u64cd\u4f5c\uff0c\u6211\u4eec\u53ea\u9700\u5c06\u5143\u7d20\u63d2\u5165\u94fe\u8868\u5934\u90e8\uff0c\u8fd9\u79cd\u8282\u70b9\u63d2\u5165\u65b9\u6cd5\u88ab\u79f0\u4e3a\u201c\u5934\u63d2\u6cd5\u201d\u3002\u800c\u5bf9\u4e8e\u51fa\u6808\u64cd\u4f5c\uff0c\u53ea\u9700\u5c06\u5934\u8282\u70b9\u4ece\u94fe\u8868\u4e2d\u5220\u9664\u5373\u53ef\u3002

    LinkedListStackpush()pop()

    \u4ee5\u4e0b\u662f\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u6808\u7684\u793a\u4f8b\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart linkedlist_stack.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nprivate ListNode stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nprivate int stkSize = 0; // \u6808\u7684\u957f\u5ea6\npublic LinkedListStack() {\nstackPeek = null;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\npublic int size() {\nreturn stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u6808 */\npublic void push(int num) {\nListNode node = new ListNode(num);\nnode.next = stackPeek;\nstackPeek = node;\nstkSize++;\n}\n/* \u51fa\u6808 */\npublic int pop() {\nint num = peek();\nstackPeek = stackPeek.next;\nstkSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npublic int peek() {\nif (size() == 0)\nthrow new IndexOutOfBoundsException();\nreturn stackPeek.val;\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic int[] toArray() {\nListNode node = stackPeek;\nint[] res = new int[size()];\nfor (int i = res.length - 1; i >= 0; i--) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_stack.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nprivate:\nListNode *stackTop; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nint stkSize;        // \u6808\u7684\u957f\u5ea6\npublic:\nLinkedListStack() {\nstackTop = nullptr;\nstkSize = 0;\n}\n~LinkedListStack() {\n// \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\nfreeMemoryLinkedList(stackTop);\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size() {\nreturn stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool empty() {\nreturn size() == 0;\n}\n/* \u5165\u6808 */\nvoid push(int num) {\nListNode *node = new ListNode(num);\nnode->next = stackTop;\nstackTop = node;\nstkSize++;\n}\n/* \u51fa\u6808 */\nvoid pop() {\nint num = top();\nListNode *tmp = stackTop;\nstackTop = stackTop->next;\n// \u91ca\u653e\u5185\u5b58\ndelete tmp;\nstkSize--;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint top() {\nif (size() == 0)\nthrow out_of_range(\"\u6808\u4e3a\u7a7a\");\nreturn stackTop->val;\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nvector<int> toVector() {\nListNode *node = stackTop;\nvector<int> res(size());\nfor (int i = res.size() - 1; i >= 0; i--) {\nres[i] = node->val;\nnode = node->next;\n}\nreturn res;\n}\n};\n
    linkedlist_stack.py
    class LinkedListStack:\n\"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\"\"\"\ndef __init__(self):\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__peek: ListNode | None = None\nself.__size: int = 0\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\nreturn self.__size\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn not self.__peek\ndef push(self, val: int) -> None:\n\"\"\"\u5165\u6808\"\"\"\nnode = ListNode(val)\nnode.next = self.__peek\nself.__peek = node\nself.__size += 1\ndef pop(self) -> int:\n\"\"\"\u51fa\u6808\"\"\"\nnum: int = self.peek()\nself.__peek = self.__peek.next\nself.__size -= 1\nreturn num\ndef peek(self) -> int:\n\"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\n# \u5224\u7a7a\u5904\u7406\nif not self.__peek:\nreturn None\nreturn self.__peek.val\ndef to_list(self) -> list[int]:\n\"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\narr = []\nnode = self.__peek\nwhile node:\narr.append(node.val)\nnode = node.next\narr.reverse()\nreturn arr\n
    linkedlist_stack.go
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\ntype linkedListStack struct {\n// \u4f7f\u7528\u5185\u7f6e\u5305 list \u6765\u5b9e\u73b0\u6808\ndata *list.List\n}\n/* \u521d\u59cb\u5316\u6808 */\nfunc newLinkedListStack() *linkedListStack {\nreturn &linkedListStack{\ndata: list.New(),\n}\n}\n/* \u5165\u6808 */\nfunc (s *linkedListStack) push(value int) {\ns.data.PushBack(value)\n}\n/* \u51fa\u6808 */\nfunc (s *linkedListStack) pop() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Back()\ns.data.Remove(e)\nreturn e.Value\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nfunc (s *linkedListStack) peek() any {\nif s.isEmpty() {\nreturn nil\n}\ne := s.data.Back()\nreturn e.Value\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nfunc (s *linkedListStack) size() int {\nreturn s.data.Len()\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListStack) isEmpty() bool {\nreturn s.data.Len() == 0\n}\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListStack) toList() *list.List {\nreturn s.data\n}\n
    linkedlist_stack.js
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n#stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n#stkSize = 0; // \u6808\u7684\u957f\u5ea6\nconstructor() {\nthis.#stackPeek = null;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nget size() {\nreturn this.#stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nisEmpty() {\nreturn this.size == 0;\n}\n/* \u5165\u6808 */\npush(num) {\nconst node = new ListNode(num);\nnode.next = this.#stackPeek;\nthis.#stackPeek = node;\nthis.#stkSize++;\n}\n/* \u51fa\u6808 */\npop() {\nconst num = this.peek();\nthis.#stackPeek = this.#stackPeek.next;\nthis.#stkSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npeek() {\nif (!this.#stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.#stackPeek.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\ntoArray() {\nlet node = this.#stackPeek;\nconst res = new Array(this.size);\nfor (let i = res.length - 1; i >= 0; i--) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_stack.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nprivate stackPeek: ListNode | null; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nprivate stkSize: number = 0; // \u6808\u7684\u957f\u5ea6\nconstructor() {\nthis.stackPeek = null;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nget size(): number {\nreturn this.stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nisEmpty(): boolean {\nreturn this.size == 0;\n}\n/* \u5165\u6808 */\npush(num: number): void {\nconst node = new ListNode(num);\nnode.next = this.stackPeek;\nthis.stackPeek = node;\nthis.stkSize++;\n}\n/* \u51fa\u6808 */\npop(): number {\nconst num = this.peek();\nif (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\nthis.stackPeek = this.stackPeek.next;\nthis.stkSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npeek(): number {\nif (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.stackPeek.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\ntoArray(): number[] {\nlet node = this.stackPeek;\nconst res = new Array<number>(this.size);\nfor (let i = res.length - 1; i >= 0; i--) {\nres[i] = node!.val;\nnode = node!.next;\n}\nreturn res;\n}\n}\n
    linkedlist_stack.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nstruct linkedListStack {\nListNode *top; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nint size;      // \u6808\u7684\u957f\u5ea6\n};\ntypedef struct linkedListStack linkedListStack;\n/* \u6784\u9020\u51fd\u6570 */\nlinkedListStack *newLinkedListStack() {\nlinkedListStack *s = malloc(sizeof(linkedListStack));\ns->top = NULL;\ns->size = 0;\nreturn s;\n}\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListStack(linkedListStack *s) {\nwhile (s->top) {\nListNode *n = s->top->next;\nfree(s->top);\ns->top = n;\n}\nfree(s);\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(linkedListStack *s) {\nassert(s);\nreturn s->size;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(linkedListStack *s) {\nassert(s);\nreturn size(s) == 0;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(linkedListStack *s) {\nassert(s);\nassert(size(s) != 0);\nreturn s->top->val;\n}\n/* \u5165\u6808 */\nvoid push(linkedListStack *s, int num) {\nassert(s);\nListNode *node = (ListNode *)malloc(sizeof(ListNode));\nnode->next = s->top; // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6307\u9488\u57df\nnode->val = num;     // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6570\u636e\u57df\ns->top = node;       // \u66f4\u65b0\u6808\u9876\ns->size++;           // \u66f4\u65b0\u6808\u5927\u5c0f\n}\n/* \u51fa\u6808 */\nint pop(linkedListStack *s) {\nif (s->size == 0) {\nprintf(\"stack is empty.\\n\");\nreturn INT_MAX;\n}\nassert(s);\nint val = peek(s);\nListNode *tmp = s->top;\ns->top = s->top->next;\n// \u91ca\u653e\u5185\u5b58\nfree(tmp);\ns->size--;\nreturn val;\n}\n
    linkedlist_stack.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nprivate ListNode? stackPeek;  // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nprivate int stkSize = 0;   // \u6808\u7684\u957f\u5ea6\npublic LinkedListStack() {\nstackPeek = null;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\npublic int size() {\nreturn stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u6808 */\npublic void push(int num) {\nListNode node = new ListNode(num);\nnode.next = stackPeek;\nstackPeek = node;\nstkSize++;\n}\n/* \u51fa\u6808 */\npublic int pop() {\nif (stackPeek == null)\nthrow new Exception();\nint num = peek();\nstackPeek = stackPeek.next;\nstkSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npublic int peek() {\nif (size() == 0 || stackPeek == null)\nthrow new Exception();\nreturn stackPeek.val;\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic int[] toArray() {\nif (stackPeek == null)\nreturn Array.Empty<int>();\nListNode node = stackPeek;\nint[] res = new int[size()];\nfor (int i = res.Length - 1; i >= 0; i--) {\nres[i] = node.val;\nnode = node.next;\n}\nreturn res;\n}\n}\n
    linkedlist_stack.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nprivate var _peek: ListNode? // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nprivate var _size = 0 // \u6808\u7684\u957f\u5ea6\ninit() {}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nfunc size() -> Int {\n_size\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nsize() == 0\n}\n/* \u5165\u6808 */\nfunc push(num: Int) {\nlet node = ListNode(x: num)\nnode.next = _peek\n_peek = node\n_size += 1\n}\n/* \u51fa\u6808 */\n@discardableResult\nfunc pop() -> Int {\nlet num = peek()\n_peek = _peek?.next\n_size -= 1\nreturn num\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nfunc peek() -> Int {\nif isEmpty() {\nfatalError(\"\u6808\u4e3a\u7a7a\")\n}\nreturn _peek!.val\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nfunc toArray() -> [Int] {\nvar node = _peek\nvar res = Array(repeating: 0, count: _size)\nfor i in sequence(first: res.count - 1, next: { $0 >= 0 + 1 ? $0 - 1 : nil }) {\nres[i] = node!.val\nnode = node?.next\n}\nreturn res\n}\n}\n
    linkedlist_stack.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\nfn LinkedListStack(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nstack_top: ?*inc.ListNode(T) = null,             // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nstk_size: usize = 0,                             // \u6808\u7684\u957f\u5ea6\nmem_arena: ?std.heap.ArenaAllocator = null,\nmem_allocator: std.mem.Allocator = undefined,    // \u5185\u5b58\u5206\u914d\u5668\n// \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator) !void {\nif (self.mem_arena == null) {\nself.mem_arena = std.heap.ArenaAllocator.init(allocator);\nself.mem_allocator = self.mem_arena.?.allocator();\n}\nself.stack_top = null;\nself.stk_size = 0;\n}\n// \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.mem_arena == null) return;\nself.mem_arena.?.deinit();\n}\n// \u83b7\u53d6\u6808\u7684\u957f\u5ea6\npub fn size(self: *Self) usize {\nreturn self.stk_size;\n}\n// \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\npub fn isEmpty(self: *Self) bool {\nreturn self.size() == 0;\n}\n// \u8bbf\u95ee\u6808\u9876\u5143\u7d20\npub fn peek(self: *Self) T {\nif (self.size() == 0) @panic(\"\u6808\u4e3a\u7a7a\");\nreturn self.stack_top.?.val;\n}  // \u5165\u6808\npub fn push(self: *Self, num: T) !void {\nvar node = try self.mem_allocator.create(inc.ListNode(T));\nnode.init(num);\nnode.next = self.stack_top;\nself.stack_top = node;\nself.stk_size += 1;\n} // \u51fa\u6808\npub fn pop(self: *Self) T {\nvar num = self.peek();\nself.stack_top = self.stack_top.?.next;\nself.stk_size -= 1;\nreturn num;\n} // \u5c06\u6808\u8f6c\u6362\u4e3a\u6570\u7ec4\npub fn toArray(self: *Self) ![]T {\nvar node = self.stack_top;\nvar res = try self.mem_allocator.alloc(T, self.size());\n@memset(res, @as(T, 0));\nvar i: usize = 0;\nwhile (i < res.len) : (i += 1) {\nres[res.len - i - 1] = node.?.val;\nnode = node.?.next;\n}\nreturn res;\n}\n};\n}\n
    linkedlist_stack.dart
    /* \u57fa\u4e8e\u94fe\u8868\u7c7b\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\nListNode? _stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\nint _stkSize = 0; // \u6808\u7684\u957f\u5ea6\nLinkedListStack() {\n_stackPeek = null;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size() {\nreturn _stkSize;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn _stkSize == 0;\n}\n/* \u5165\u6808 */\nvoid push(int num) {\nfinal ListNode node = ListNode(num);\nnode.next = _stackPeek;\n_stackPeek = node;\n_stkSize++;\n}\n/* \u51fa\u6808 */\nint pop() {\nfinal int num = peek();\n_stackPeek = _stackPeek!.next;\n_stkSize--;\nreturn num;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek() {\nif (_stackPeek == null) {\nthrow Exception(\"\u6808\u4e3a\u7a7a\");\n}\nreturn _stackPeek!.val;\n}\n/* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a List \u5e76\u8fd4\u56de */\nList<int> toList() {\nListNode? node = _stackPeek;\nList<int> list = [];\nwhile (node != null) {\nlist.add(node.val);\nnode = node.next;\n}\nlist = list.reversed.toList();\nreturn list;\n}\n}\n
    "},{"location":"chapter_stack_and_queue/stack/#_2","title":"\u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u5728\u57fa\u4e8e\u300c\u6570\u7ec4\u300d\u5b9e\u73b0\u6808\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u7ec4\u7684\u5c3e\u90e8\u4f5c\u4e3a\u6808\u9876\u3002\u5728\u8fd9\u6837\u7684\u8bbe\u8ba1\u4e0b\uff0c\u5165\u6808\u4e0e\u51fa\u6808\u64cd\u4f5c\u5c31\u5206\u522b\u5bf9\u5e94\u5728\u6570\u7ec4\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\u4e0e\u5220\u9664\u5143\u7d20\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(1)\\) \u3002

    ArrayStackpush()pop()

    \u7531\u4e8e\u5165\u6808\u7684\u5143\u7d20\u53ef\u80fd\u4f1a\u6e90\u6e90\u4e0d\u65ad\u5730\u589e\u52a0\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u52a8\u6001\u6570\u7ec4\uff0c\u8fd9\u6837\u5c31\u65e0\u9700\u81ea\u884c\u5904\u7406\u6570\u7ec4\u6269\u5bb9\u95ee\u9898\u3002\u4ee5\u4e0b\u4e3a\u793a\u4f8b\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart array_stack.java
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nprivate ArrayList<Integer> stack;\npublic ArrayStack() {\n// \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\nstack = new ArrayList<>();\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\npublic int size() {\nreturn stack.size();\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\npublic boolean isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u6808 */\npublic void push(int num) {\nstack.add(num);\n}\n/* \u51fa\u6808 */\npublic int pop() {\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\nreturn stack.remove(size() - 1);\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npublic int peek() {\nif (isEmpty())\nthrow new IndexOutOfBoundsException();\nreturn stack.get(size() - 1);\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic Object[] toArray() {\nreturn stack.toArray();\n}\n}\n
    array_stack.cpp
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nprivate:\nvector<int> stack;\npublic:\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size() {\nreturn stack.size();\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool empty() {\nreturn stack.empty();\n}\n/* \u5165\u6808 */\nvoid push(int num) {\nstack.push_back(num);\n}\n/* \u51fa\u6808 */\nvoid pop() {\nint oldTop = top();\nstack.pop_back();\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint top() {\nif (empty())\nthrow out_of_range(\"\u6808\u4e3a\u7a7a\");\nreturn stack.back();\n}\n/* \u8fd4\u56de Vector */\nvector<int> toVector() {\nreturn stack;\n}\n};\n
    array_stack.py
    class ArrayStack:\n\"\"\"\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\"\"\"\ndef __init__(self) -> None:\n\"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\nself.__stack: list[int] = []\ndef size(self) -> int:\n\"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\nreturn len(self.__stack)\ndef is_empty(self) -> bool:\n\"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\nreturn self.__stack == []\ndef push(self, item: int) -> None:\n\"\"\"\u5165\u6808\"\"\"\nself.__stack.append(item)\ndef pop(self) -> int:\n\"\"\"\u51fa\u6808\"\"\"\nif self.is_empty():\nraise IndexError(\"\u6808\u4e3a\u7a7a\")\nreturn self.__stack.pop()\ndef peek(self) -> int:\n\"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\nif self.is_empty():\nraise IndexError(\"\u6808\u4e3a\u7a7a\")\nreturn self.__stack[-1]\ndef to_list(self) -> list[int]:\n\"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\nreturn self.__stack\n
    array_stack.go
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\ntype arrayStack struct {\ndata []int // \u6570\u636e\n}\n/* \u521d\u59cb\u5316\u6808 */\nfunc newArrayStack() *arrayStack {\nreturn &arrayStack{\n// \u8bbe\u7f6e\u6808\u7684\u957f\u5ea6\u4e3a 0\uff0c\u5bb9\u91cf\u4e3a 16\ndata: make([]int, 0, 16),\n}\n}\n/* \u6808\u7684\u957f\u5ea6 */\nfunc (s *arrayStack) size() int {\nreturn len(s.data)\n}\n/* \u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *arrayStack) isEmpty() bool {\nreturn s.size() == 0\n}\n/* \u5165\u6808 */\nfunc (s *arrayStack) push(v int) {\n// \u5207\u7247\u4f1a\u81ea\u52a8\u6269\u5bb9\ns.data = append(s.data, v)\n}\n/* \u51fa\u6808 */\nfunc (s *arrayStack) pop() any {\nval := s.peek()\ns.data = s.data[:len(s.data)-1]\nreturn val\n}\n/* \u83b7\u53d6\u6808\u9876\u5143\u7d20 */\nfunc (s *arrayStack) peek() any {\nif s.isEmpty() {\nreturn nil\n}\nval := s.data[len(s.data)-1]\nreturn val\n}\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (s *arrayStack) toSlice() []int {\nreturn s.data\n}\n
    array_stack.js
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n#stack;\nconstructor() {\nthis.#stack = [];\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nget size() {\nreturn this.#stack.length;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nempty() {\nreturn this.#stack.length === 0;\n}\n/* \u5165\u6808 */\npush(num) {\nthis.#stack.push(num);\n}\n/* \u51fa\u6808 */\npop() {\nif (this.empty()) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.#stack.pop();\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\ntop() {\nif (this.empty()) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.#stack[this.#stack.length - 1];\n}\n/* \u8fd4\u56de Array */\ntoArray() {\nreturn this.#stack;\n}\n}\n
    array_stack.ts
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nprivate stack: number[];\nconstructor() {\nthis.stack = [];\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nget size(): number {\nreturn this.stack.length;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nempty(): boolean {\nreturn this.stack.length === 0;\n}\n/* \u5165\u6808 */\npush(num: number): void {\nthis.stack.push(num);\n}\n/* \u51fa\u6808 */\npop(): number | undefined {\nif (this.empty()) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.stack.pop();\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\ntop(): number | undefined {\nif (this.empty()) throw new Error('\u6808\u4e3a\u7a7a');\nreturn this.stack[this.stack.length - 1];\n}\n/* \u8fd4\u56de Array */\ntoArray() {\nreturn this.stack;\n}\n}\n
    array_stack.c
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nstruct arrayStack {\nint *data;\nint size;\n};\ntypedef struct arrayStack arrayStack;\n/* \u6784\u9020\u51fd\u6570 */\narrayStack *newArrayStack() {\narrayStack *s = malloc(sizeof(arrayStack));\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5927\u5bb9\u91cf\uff0c\u907f\u514d\u6269\u5bb9\ns->data = malloc(sizeof(int) * MAX_SIZE);\ns->size = 0;\nreturn s;\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(arrayStack *s) {\nreturn s->size;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(arrayStack *s) {\nreturn s->size == 0;\n}\n/* \u5165\u6808 */\nvoid push(arrayStack *s, int num) {\nif (s->size == MAX_SIZE) {\nprintf(\"stack is full.\\n\");\nreturn;\n}\ns->data[s->size] = num;\ns->size++;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(arrayStack *s) {\nif (s->size == 0) {\nprintf(\"stack is empty.\\n\");\nreturn INT_MAX;\n}\nreturn s->data[s->size - 1];\n}\n/* \u51fa\u6808 */\nint pop(arrayStack *s) {\nif (s->size == 0) {\nprintf(\"stack is empty.\\n\");\nreturn INT_MAX;\n}\nint val = peek(s);\ns->size--;\nreturn val;\n}\n
    array_stack.cs
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nprivate List<int> stack;\npublic ArrayStack() {\n// \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\nstack = new();\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\npublic int size() {\nreturn stack.Count();\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\npublic bool isEmpty() {\nreturn size() == 0;\n}\n/* \u5165\u6808 */\npublic void push(int num) {\nstack.Add(num);\n}\n/* \u51fa\u6808 */\npublic int pop() {\nif (isEmpty())\nthrow new Exception();\nvar val = peek();\nstack.RemoveAt(size() - 1);\nreturn val;\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npublic int peek() {\nif (isEmpty())\nthrow new Exception();\nreturn stack[size() - 1];\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\npublic int[] toArray() {\nreturn stack.ToArray();\n}\n}\n
    array_stack.swift
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nprivate var stack: [Int]\ninit() {\n// \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\nstack = []\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nfunc size() -> Int {\nstack.count\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nfunc isEmpty() -> Bool {\nstack.isEmpty\n}\n/* \u5165\u6808 */\nfunc push(num: Int) {\nstack.append(num)\n}\n/* \u51fa\u6808 */\n@discardableResult\nfunc pop() -> Int {\nif isEmpty() {\nfatalError(\"\u6808\u4e3a\u7a7a\")\n}\nreturn stack.removeLast()\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nfunc peek() -> Int {\nif isEmpty() {\nfatalError(\"\u6808\u4e3a\u7a7a\")\n}\nreturn stack.last!\n}\n/* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nfunc toArray() -> [Int] {\nstack\n}\n}\n
    array_stack.zig
    // \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\nfn ArrayStack(comptime T: type) type {\nreturn struct {\nconst Self = @This();\nstack: ?std.ArrayList(T) = null,     // \u6784\u9020\u65b9\u6cd5\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\npub fn init(self: *Self, allocator: std.mem.Allocator) void {\nif (self.stack == null) {\nself.stack = std.ArrayList(T).init(allocator);\n}\n}\n// \u6790\u6784\u65b9\u6cd5\uff08\u91ca\u653e\u5185\u5b58\uff09\npub fn deinit(self: *Self) void {\nif (self.stack == null) return;\nself.stack.?.deinit();\n}\n// \u83b7\u53d6\u6808\u7684\u957f\u5ea6\npub fn size(self: *Self) usize {\nreturn self.stack.?.items.len;\n}\n// \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\npub fn isEmpty(self: *Self) bool {\nreturn self.size() == 0;\n}\n// \u8bbf\u95ee\u6808\u9876\u5143\u7d20\npub fn peek(self: *Self) T {\nif (self.isEmpty()) @panic(\"\u6808\u4e3a\u7a7a\");\nreturn self.stack.?.items[self.size() - 1];\n}  // \u5165\u6808\npub fn push(self: *Self, num: T) !void {\ntry self.stack.?.append(num);\n} // \u51fa\u6808\npub fn pop(self: *Self) T {\nvar num = self.stack.?.pop();\nreturn num;\n} // \u8fd4\u56de ArrayList\npub fn toList(self: *Self) std.ArrayList(T) {\nreturn self.stack.?;\n}\n};\n}\n
    array_stack.dart
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\nlate List<int> _stack;\nArrayStack() {\n_stack = [];\n}\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size() {\nreturn _stack.length;\n}\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty() {\nreturn _stack.isEmpty;\n}\n/* \u5165\u6808 */\nvoid push(int num) {\n_stack.add(num);\n}\n/* \u51fa\u6808 */\nint pop() {\nif (isEmpty()) {\nthrow Exception(\"\u6808\u4e3a\u7a7a\");\n}\nreturn _stack.removeLast();\n}\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek() {\nif (isEmpty()) {\nthrow Exception(\"\u6808\u4e3a\u7a7a\");\n}\nreturn _stack.last;\n}\n/* \u5c06\u6808\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\nList<int> toArray() => _stack;\n}\n
    "},{"location":"chapter_stack_and_queue/stack/#513","title":"5.1.3. \u00a0 \u4e24\u79cd\u5b9e\u73b0\u5bf9\u6bd4","text":""},{"location":"chapter_stack_and_queue/stack/#_3","title":"\u652f\u6301\u64cd\u4f5c","text":"

    \u4e24\u79cd\u5b9e\u73b0\u90fd\u652f\u6301\u6808\u5b9a\u4e49\u4e2d\u7684\u5404\u9879\u64cd\u4f5c\u3002\u6570\u7ec4\u5b9e\u73b0\u989d\u5916\u652f\u6301\u968f\u673a\u8bbf\u95ee\uff0c\u4f46\u8fd9\u5df2\u8d85\u51fa\u4e86\u6808\u7684\u5b9a\u4e49\u8303\u7574\uff0c\u56e0\u6b64\u4e00\u822c\u4e0d\u4f1a\u7528\u5230\u3002

    "},{"location":"chapter_stack_and_queue/stack/#_4","title":"\u65f6\u95f4\u6548\u7387","text":"

    \u5728\u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0\u4e2d\uff0c\u5165\u6808\u548c\u51fa\u6808\u64cd\u4f5c\u90fd\u662f\u5728\u9884\u5148\u5206\u914d\u597d\u7684\u8fde\u7eed\u5185\u5b58\u4e2d\u8fdb\u884c\uff0c\u5177\u6709\u5f88\u597d\u7684\u7f13\u5b58\u672c\u5730\u6027\uff0c\u56e0\u6b64\u6548\u7387\u8f83\u9ad8\u3002\u7136\u800c\uff0c\u5982\u679c\u5165\u6808\u65f6\u8d85\u51fa\u6570\u7ec4\u5bb9\u91cf\uff0c\u4f1a\u89e6\u53d1\u6269\u5bb9\u673a\u5236\uff0c\u5bfc\u81f4\u8be5\u6b21\u5165\u6808\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u53d8\u4e3a \\(O(n)\\) \u3002

    \u5728\u94fe\u8868\u5b9e\u73b0\u4e2d\uff0c\u94fe\u8868\u7684\u6269\u5bb9\u975e\u5e38\u7075\u6d3b\uff0c\u4e0d\u5b58\u5728\u4e0a\u8ff0\u6570\u7ec4\u6269\u5bb9\u65f6\u6548\u7387\u964d\u4f4e\u7684\u95ee\u9898\u3002\u4f46\u662f\uff0c\u5165\u6808\u64cd\u4f5c\u9700\u8981\u521d\u59cb\u5316\u8282\u70b9\u5bf9\u8c61\u5e76\u4fee\u6539\u6307\u9488\uff0c\u56e0\u6b64\u6548\u7387\u76f8\u5bf9\u8f83\u4f4e\u3002\u4e0d\u8fc7\uff0c\u5982\u679c\u5165\u6808\u5143\u7d20\u672c\u8eab\u5c31\u662f\u8282\u70b9\u5bf9\u8c61\uff0c\u90a3\u4e48\u53ef\u4ee5\u7701\u53bb\u521d\u59cb\u5316\u6b65\u9aa4\uff0c\u4ece\u800c\u63d0\u9ad8\u6548\u7387\u3002

    \u7efc\u4e0a\u6240\u8ff0\uff0c\u5f53\u5165\u6808\u4e0e\u51fa\u6808\u64cd\u4f5c\u7684\u5143\u7d20\u662f\u57fa\u672c\u6570\u636e\u7c7b\u578b\uff08\u5982 int , double \uff09\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u51fa\u4ee5\u4e0b\u7ed3\u8bba\uff1a

    • \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\u5728\u89e6\u53d1\u6269\u5bb9\u65f6\u6548\u7387\u4f1a\u964d\u4f4e\uff0c\u4f46\u7531\u4e8e\u6269\u5bb9\u662f\u4f4e\u9891\u64cd\u4f5c\uff0c\u56e0\u6b64\u5e73\u5747\u6548\u7387\u66f4\u9ad8\uff1b
    • \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\u53ef\u4ee5\u63d0\u4f9b\u66f4\u52a0\u7a33\u5b9a\u7684\u6548\u7387\u8868\u73b0\uff1b
    "},{"location":"chapter_stack_and_queue/stack/#_5","title":"\u7a7a\u95f4\u6548\u7387","text":"

    \u5728\u521d\u59cb\u5316\u5217\u8868\u65f6\uff0c\u7cfb\u7edf\u4f1a\u4e3a\u5217\u8868\u5206\u914d\u201c\u521d\u59cb\u5bb9\u91cf\u201d\uff0c\u8be5\u5bb9\u91cf\u53ef\u80fd\u8d85\u8fc7\u5b9e\u9645\u9700\u6c42\u3002\u5e76\u4e14\uff0c\u6269\u5bb9\u673a\u5236\u901a\u5e38\u662f\u6309\u7167\u7279\u5b9a\u500d\u7387\uff08\u4f8b\u5982 2 \u500d\uff09\u8fdb\u884c\u6269\u5bb9\uff0c\u6269\u5bb9\u540e\u7684\u5bb9\u91cf\u4e5f\u53ef\u80fd\u8d85\u51fa\u5b9e\u9645\u9700\u6c42\u3002\u56e0\u6b64\uff0c\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\u53ef\u80fd\u9020\u6210\u4e00\u5b9a\u7684\u7a7a\u95f4\u6d6a\u8d39\u3002

    \u7136\u800c\uff0c\u7531\u4e8e\u94fe\u8868\u8282\u70b9\u9700\u8981\u989d\u5916\u5b58\u50a8\u6307\u9488\uff0c\u56e0\u6b64\u94fe\u8868\u8282\u70b9\u5360\u7528\u7684\u7a7a\u95f4\u76f8\u5bf9\u8f83\u5927\u3002

    \u7efc\u4e0a\uff0c\u6211\u4eec\u4e0d\u80fd\u7b80\u5355\u5730\u786e\u5b9a\u54ea\u79cd\u5b9e\u73b0\u66f4\u52a0\u8282\u7701\u5185\u5b58\uff0c\u9700\u8981\u9488\u5bf9\u5177\u4f53\u60c5\u51b5\u8fdb\u884c\u5206\u6790\u3002

    "},{"location":"chapter_stack_and_queue/stack/#514","title":"5.1.4. \u00a0 \u6808\u5178\u578b\u5e94\u7528","text":"
    • \u6d4f\u89c8\u5668\u4e2d\u7684\u540e\u9000\u4e0e\u524d\u8fdb\u3001\u8f6f\u4ef6\u4e2d\u7684\u64a4\u9500\u4e0e\u53cd\u64a4\u9500\u3002\u6bcf\u5f53\u6211\u4eec\u6253\u5f00\u65b0\u7684\u7f51\u9875\uff0c\u6d4f\u89c8\u5668\u5c31\u4f1a\u5c06\u4e0a\u4e00\u4e2a\u7f51\u9875\u6267\u884c\u5165\u6808\uff0c\u8fd9\u6837\u6211\u4eec\u5c31\u53ef\u4ee5\u901a\u8fc7\u300c\u540e\u9000\u300d\u64cd\u4f5c\u56de\u5230\u4e0a\u4e00\u9875\u9762\u3002\u540e\u9000\u64cd\u4f5c\u5b9e\u9645\u4e0a\u662f\u5728\u6267\u884c\u51fa\u6808\u3002\u5982\u679c\u8981\u540c\u65f6\u652f\u6301\u540e\u9000\u548c\u524d\u8fdb\uff0c\u90a3\u4e48\u9700\u8981\u4e24\u4e2a\u6808\u6765\u914d\u5408\u5b9e\u73b0\u3002
    • \u7a0b\u5e8f\u5185\u5b58\u7ba1\u7406\u3002\u6bcf\u6b21\u8c03\u7528\u51fd\u6570\u65f6\uff0c\u7cfb\u7edf\u90fd\u4f1a\u5728\u6808\u9876\u6dfb\u52a0\u4e00\u4e2a\u6808\u5e27\uff0c\u7528\u4e8e\u8bb0\u5f55\u51fd\u6570\u7684\u4e0a\u4e0b\u6587\u4fe1\u606f\u3002\u5728\u9012\u5f52\u51fd\u6570\u4e2d\uff0c\u5411\u4e0b\u9012\u63a8\u9636\u6bb5\u4f1a\u4e0d\u65ad\u6267\u884c\u5165\u6808\u64cd\u4f5c\uff0c\u800c\u5411\u4e0a\u56de\u6eaf\u9636\u6bb5\u5219\u4f1a\u6267\u884c\u51fa\u6808\u64cd\u4f5c\u3002
    "},{"location":"chapter_stack_and_queue/summary/","title":"5.4. \u00a0 \u5c0f\u7ed3","text":"
    • \u6808\u662f\u4e00\u79cd\u9075\u5faa\u5148\u5165\u540e\u51fa\u539f\u5219\u7684\u6570\u636e\u7ed3\u6784\uff0c\u53ef\u901a\u8fc7\u6570\u7ec4\u6216\u94fe\u8868\u6765\u5b9e\u73b0\u3002
    • \u4ece\u65f6\u95f4\u6548\u7387\u89d2\u5ea6\u770b\uff0c\u6808\u7684\u6570\u7ec4\u5b9e\u73b0\u5177\u6709\u8f83\u9ad8\u7684\u5e73\u5747\u6548\u7387\uff0c\u4f46\u5728\u6269\u5bb9\u8fc7\u7a0b\u4e2d\uff0c\u5355\u6b21\u5165\u6808\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4f1a\u964d\u4f4e\u81f3 \\(O(n)\\) \u3002\u76f8\u6bd4\u4e4b\u4e0b\uff0c\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\u5177\u6709\u66f4\u4e3a\u7a33\u5b9a\u7684\u6548\u7387\u8868\u73b0\u3002
    • \u5728\u7a7a\u95f4\u6548\u7387\u65b9\u9762\uff0c\u6808\u7684\u6570\u7ec4\u5b9e\u73b0\u53ef\u80fd\u5bfc\u81f4\u4e00\u5b9a\u7a0b\u5ea6\u7684\u7a7a\u95f4\u6d6a\u8d39\u3002\u4f46\u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u94fe\u8868\u8282\u70b9\u6240\u5360\u7528\u7684\u5185\u5b58\u7a7a\u95f4\u6bd4\u6570\u7ec4\u5143\u7d20\u66f4\u5927\u3002
    • \u961f\u5217\u662f\u4e00\u79cd\u9075\u5faa\u5148\u5165\u5148\u51fa\u539f\u5219\u7684\u6570\u636e\u7ed3\u6784\uff0c\u540c\u6837\u53ef\u4ee5\u901a\u8fc7\u6570\u7ec4\u6216\u94fe\u8868\u6765\u5b9e\u73b0\u3002\u5728\u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u7684\u5bf9\u6bd4\u4e0a\uff0c\u961f\u5217\u7684\u7ed3\u8bba\u4e0e\u524d\u8ff0\u6808\u7684\u7ed3\u8bba\u76f8\u4f3c\u3002
    • \u53cc\u5411\u961f\u5217\u662f\u4e00\u79cd\u5177\u6709\u66f4\u9ad8\u81ea\u7531\u5ea6\u7684\u961f\u5217\uff0c\u5b83\u5141\u8bb8\u5728\u4e24\u7aef\u8fdb\u884c\u5143\u7d20\u7684\u6dfb\u52a0\u548c\u5220\u9664\u64cd\u4f5c\u3002
    "},{"location":"chapter_stack_and_queue/summary/#541-q-a","title":"5.4.1. \u00a0 Q & A","text":"

    \u6d4f\u89c8\u5668\u7684\u524d\u8fdb\u540e\u9000\u662f\u5426\u662f\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\uff1f

    \u6d4f\u89c8\u5668\u7684\u524d\u8fdb\u540e\u9000\u529f\u80fd\u672c\u8d28\u4e0a\u662f\u201c\u6808\u201d\u7684\u4f53\u73b0\u3002\u5f53\u7528\u6237\u8bbf\u95ee\u4e00\u4e2a\u65b0\u9875\u9762\u65f6\uff0c\u8be5\u9875\u9762\u4f1a\u88ab\u6dfb\u52a0\u5230\u6808\u9876\uff1b\u5f53\u7528\u6237\u70b9\u51fb\u540e\u9000\u6309\u94ae\u65f6\uff0c\u8be5\u9875\u9762\u4f1a\u4ece\u6808\u9876\u5f39\u51fa\u3002\u4f7f\u7528\u53cc\u5411\u961f\u5217\u53ef\u4ee5\u65b9\u4fbf\u5b9e\u73b0\u4e00\u4e9b\u989d\u5916\u64cd\u4f5c\uff0c\u8fd9\u4e2a\u5728\u53cc\u5411\u961f\u5217\u7ae0\u8282\u6709\u63d0\u5230\u3002

    \u5728\u51fa\u6808\u540e\uff0c\u662f\u5426\u9700\u8981\u91ca\u653e\u51fa\u6808\u8282\u70b9\u7684\u5185\u5b58\uff1f

    \u5982\u679c\u540e\u7eed\u4ecd\u9700\u8981\u4f7f\u7528\u5f39\u51fa\u8282\u70b9\uff0c\u5219\u4e0d\u9700\u8981\u91ca\u653e\u5185\u5b58\u3002\u82e5\u4e4b\u540e\u4e0d\u9700\u8981\u7528\u5230\uff0cJava \u548c Python \u7b49\u8bed\u8a00\u62e5\u6709\u81ea\u52a8\u5783\u573e\u56de\u6536\u673a\u5236\uff0c\u56e0\u6b64\u4e0d\u9700\u8981\u624b\u52a8\u91ca\u653e\u5185\u5b58\uff1b\u5728 C \u548c C++ \u4e2d\u9700\u8981\u624b\u52a8\u91ca\u653e\u5185\u5b58\u3002

    \u53cc\u5411\u961f\u5217\u50cf\u662f\u4e24\u4e2a\u6808\u62fc\u63a5\u5728\u4e86\u4e00\u8d77\uff0c\u5b83\u7684\u7528\u9014\u662f\u4ec0\u4e48\uff1f

    \u53cc\u5411\u961f\u5217\u5c31\u50cf\u662f\u6808\u548c\u961f\u5217\u7684\u7ec4\u5408\uff0c\u6216\u8005\u662f\u4e24\u4e2a\u6808\u62fc\u5728\u4e86\u4e00\u8d77\u3002\u5b83\u8868\u73b0\u7684\u662f\u6808 + \u961f\u5217\u7684\u903b\u8f91\uff0c\u56e0\u6b64\u53ef\u4ee5\u5b9e\u73b0\u6808\u4e0e\u961f\u5217\u7684\u6240\u6709\u5e94\u7528\uff0c\u5e76\u4e14\u66f4\u52a0\u7075\u6d3b\u3002

    "},{"location":"chapter_tree/","title":"7. \u00a0 \u6811","text":""},{"location":"chapter_tree/array_representation_of_tree/","title":"7.3. \u00a0 \u4e8c\u53c9\u6811\u6570\u7ec4\u8868\u793a","text":"

    \u5728\u94fe\u8868\u8868\u793a\u4e0b\uff0c\u4e8c\u53c9\u6811\u7684\u5b58\u50a8\u5355\u5143\u4e3a\u8282\u70b9 TreeNode \uff0c\u8282\u70b9\u4e4b\u95f4\u901a\u8fc7\u6307\u9488\u76f8\u8fde\u63a5\u3002\u5728\u4e0a\u8282\u4e2d\uff0c\u6211\u4eec\u5b66\u4e60\u4e86\u5728\u94fe\u8868\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7684\u5404\u9879\u57fa\u672c\u64cd\u4f5c\u3002

    \u90a3\u4e48\uff0c\u80fd\u5426\u7528\u300c\u6570\u7ec4\u300d\u6765\u8868\u793a\u4e8c\u53c9\u6811\u5462\uff1f\u7b54\u6848\u662f\u80af\u5b9a\u7684\u3002

    "},{"location":"chapter_tree/array_representation_of_tree/#731","title":"7.3.1. \u00a0 \u8868\u793a\u5b8c\u7f8e\u4e8c\u53c9\u6811","text":"

    \u5148\u5206\u6790\u4e00\u4e2a\u7b80\u5355\u6848\u4f8b\uff0c\u7ed9\u5b9a\u4e00\u4e2a\u5b8c\u7f8e\u4e8c\u53c9\u6811\uff0c\u6211\u4eec\u5c06\u8282\u70b9\u6309\u7167\u5c42\u5e8f\u904d\u5386\u7684\u987a\u5e8f\u7f16\u53f7\uff08\u4ece \\(0\\) \u5f00\u59cb\uff09\uff0c\u6b64\u65f6\u6bcf\u4e2a\u8282\u70b9\u90fd\u5bf9\u5e94\u552f\u4e00\u7684\u7d22\u5f15\u3002

    \u6839\u636e\u5c42\u5e8f\u904d\u5386\u7684\u7279\u6027\uff0c\u6211\u4eec\u53ef\u4ee5\u63a8\u5bfc\u51fa\u7236\u8282\u70b9\u7d22\u5f15\u4e0e\u5b50\u8282\u70b9\u7d22\u5f15\u4e4b\u95f4\u7684\u201c\u6620\u5c04\u516c\u5f0f\u201d\uff1a\u82e5\u8282\u70b9\u7684\u7d22\u5f15\u4e3a \\(i\\) \uff0c\u5219\u8be5\u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7d22\u5f15\u4e3a \\(2i + 1\\) \uff0c\u53f3\u5b50\u8282\u70b9\u7d22\u5f15\u4e3a \\(2i + 2\\) \u3002

    Fig. \u5b8c\u7f8e\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    \u6620\u5c04\u516c\u5f0f\u7684\u4f5c\u7528\u76f8\u5f53\u4e8e\u94fe\u8868\u4e2d\u7684\u6307\u9488\u3002\u5982\u679c\u6211\u4eec\u5c06\u8282\u70b9\u6309\u7167\u5c42\u5e8f\u904d\u5386\u7684\u987a\u5e8f\u5b58\u50a8\u5728\u4e00\u4e2a\u6570\u7ec4\u4e2d\uff0c\u90a3\u4e48\u5bf9\u4e8e\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u8282\u70b9\uff0c\u6211\u4eec\u90fd\u53ef\u4ee5\u901a\u8fc7\u6620\u5c04\u516c\u5f0f\u6765\u8bbf\u95ee\u5176\u5b50\u8282\u70b9\u3002

    "},{"location":"chapter_tree/array_representation_of_tree/#732","title":"7.3.2. \u00a0 \u8868\u793a\u4efb\u610f\u4e8c\u53c9\u6811","text":"

    \u7136\u800c\uff0c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u53ea\u662f\u4e00\u4e2a\u7279\u4f8b\u3002\u5728\u4e8c\u53c9\u6811\u7684\u4e2d\u95f4\u5c42\uff0c\u901a\u5e38\u5b58\u5728\u8bb8\u591a \\(\\text{None}\\) \uff0c\u800c\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u5e76\u4e0d\u5305\u542b\u8fd9\u4e9b \\(\\text{None}\\) \u3002\u6211\u4eec\u65e0\u6cd5\u4ec5\u51ed\u8be5\u5e8f\u5217\u6765\u63a8\u6d4b \\(\\text{None}\\) \u7684\u6570\u91cf\u548c\u5206\u5e03\u4f4d\u7f6e\uff0c\u8fd9\u610f\u5473\u7740\u5b58\u5728\u591a\u79cd\u4e8c\u53c9\u6811\u7ed3\u6784\u90fd\u7b26\u5408\u8be5\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u3002\u663e\u7136\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u4e0a\u8ff0\u7684\u6570\u7ec4\u8868\u793a\u65b9\u6cd5\u5df2\u7ecf\u5931\u6548\u3002

    Fig. \u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u5bf9\u5e94\u591a\u79cd\u4e8c\u53c9\u6811\u53ef\u80fd\u6027

    \u4e3a\u4e86\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u8003\u8651\u5728\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u4e2d\u663e\u5f0f\u5730\u5199\u51fa\u6240\u6709 \\(\\text{None}\\)\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u8fd9\u6837\u5904\u7406\u540e\uff0c\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u5c31\u53ef\u4ee5\u552f\u4e00\u8868\u793a\u4e8c\u53c9\u6811\u4e86\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 int \u7684\u5305\u88c5\u7c7b Integer \uff0c\u5c31\u53ef\u4ee5\u4f7f\u7528 null \u6765\u6807\u8bb0\u7a7a\u4f4d\nInteger[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 int \u6700\u5927\u503c\u6807\u8bb0\u7a7a\u4f4d\uff0c\u56e0\u6b64\u8981\u6c42\u8282\u70b9\u503c\u4e0d\u80fd\u4e3a INT_MAX\nvector<int> tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n
    # \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a\n# \u76f4\u63a5\u4f7f\u7528 None \u6765\u8868\u793a\u7a7a\u4f4d\ntree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 any \u7c7b\u578b\u7684\u5207\u7247, \u5c31\u53ef\u4ee5\u4f7f\u7528 nil \u6765\u6807\u8bb0\u7a7a\u4f4d\ntree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u76f4\u63a5\u4f7f\u7528 null \u6765\u8868\u793a\u7a7a\u4f4d\nlet tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u76f4\u63a5\u4f7f\u7528 null \u6765\u8868\u793a\u7a7a\u4f4d\nlet tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 int \u6700\u5927\u503c\u6807\u8bb0\u7a7a\u4f4d\uff0c\u56e0\u6b64\u8981\u6c42\u8282\u70b9\u503c\u4e0d\u80fd\u4e3a INT_MAX\nint tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 int? \u53ef\u7a7a\u7c7b\u578b \uff0c\u5c31\u53ef\u4ee5\u4f7f\u7528 null \u6765\u6807\u8bb0\u7a7a\u4f4d\nint?[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 Int? \u53ef\u7a7a\u7c7b\u578b \uff0c\u5c31\u53ef\u4ee5\u4f7f\u7528 nil \u6765\u6807\u8bb0\u7a7a\u4f4d\nlet tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n
    \n
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 int? \u53ef\u7a7a\u7c7b\u578b \uff0c\u5c31\u53ef\u4ee5\u4f7f\u7528 null \u6765\u6807\u8bb0\u7a7a\u4f4d\nList<int?> tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n

    Fig. \u4efb\u610f\u7c7b\u578b\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    "},{"location":"chapter_tree/array_representation_of_tree/#733","title":"7.3.3. \u00a0 \u4f18\u52bf\u4e0e\u5c40\u9650\u6027","text":"

    \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a\u5b58\u5728\u4ee5\u4e0b\u4f18\u70b9\uff1a

    • \u6570\u7ec4\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\uff0c\u7f13\u5b58\u53cb\u597d\uff0c\u8bbf\u95ee\u4e0e\u904d\u5386\u901f\u5ea6\u8f83\u5feb\uff1b
    • \u4e0d\u9700\u8981\u5b58\u50a8\u6307\u9488\uff0c\u6bd4\u8f83\u8282\u7701\u7a7a\u95f4\uff1b
    • \u5141\u8bb8\u968f\u673a\u8bbf\u95ee\u8282\u70b9\uff1b

    \u7136\u800c\uff0c\u6570\u7ec4\u8868\u793a\u4e5f\u5177\u6709\u4e00\u4e9b\u5c40\u9650\u6027\uff1a

    • \u6570\u7ec4\u5b58\u50a8\u9700\u8981\u8fde\u7eed\u5185\u5b58\u7a7a\u95f4\uff0c\u56e0\u6b64\u4e0d\u9002\u5408\u5b58\u50a8\u6570\u636e\u91cf\u8fc7\u5927\u7684\u6811\u3002
    • \u589e\u5220\u8282\u70b9\u9700\u8981\u901a\u8fc7\u6570\u7ec4\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u5b9e\u73b0\uff0c\u6548\u7387\u8f83\u4f4e\uff1b
    • \u5f53\u4e8c\u53c9\u6811\u4e2d\u5b58\u5728\u5927\u91cf \\(\\text{None}\\) \u65f6\uff0c\u6570\u7ec4\u4e2d\u5305\u542b\u7684\u8282\u70b9\u6570\u636e\u6bd4\u91cd\u8f83\u4f4e\uff0c\u7a7a\u95f4\u5229\u7528\u7387\u8f83\u4f4e\u3002

    \u5b8c\u5168\u4e8c\u53c9\u6811\u975e\u5e38\u9002\u5408\u4f7f\u7528\u6570\u7ec4\u6765\u8868\u793a\u3002\u56de\u987e\u5b8c\u5168\u4e8c\u53c9\u6811\u7684\u5b9a\u4e49\uff0c\\(\\text{None}\\) \u53ea\u51fa\u73b0\u5728\u6700\u5e95\u5c42\u4e14\u9760\u53f3\u7684\u4f4d\u7f6e\uff0c\u8fd9\u610f\u5473\u7740\u6240\u6709 \\(\\text{None}\\) \u4e00\u5b9a\u51fa\u73b0\u5728\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u7684\u672b\u5c3e\u3002\u56e0\u6b64\uff0c\u5728\u4f7f\u7528\u6570\u7ec4\u8868\u793a\u5b8c\u5168\u4e8c\u53c9\u6811\u65f6\uff0c\u53ef\u4ee5\u7701\u7565\u5b58\u50a8\u6240\u6709 \\(\\text{None}\\) \u3002

    Fig. \u5b8c\u5168\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    "},{"location":"chapter_tree/avl_tree/","title":"7.5. \u00a0 AVL \u6811 *","text":"

    \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u7ae0\u8282\u4e2d\uff0c\u6211\u4eec\u63d0\u5230\u4e86\u5728\u591a\u6b21\u63d2\u5165\u548c\u5220\u9664\u64cd\u4f5c\u540e\uff0c\u4e8c\u53c9\u641c\u7d22\u6811\u53ef\u80fd\u9000\u5316\u4e3a\u94fe\u8868\u3002\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u6240\u6709\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5c06\u4ece \\(O(\\log n)\\) \u6076\u5316\u4e3a \\(O(n)\\)\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u7ecf\u8fc7\u4e24\u6b21\u5220\u9664\u8282\u70b9\u64cd\u4f5c\uff0c\u8fd9\u4e2a\u4e8c\u53c9\u641c\u7d22\u6811\u4fbf\u4f1a\u9000\u5316\u4e3a\u94fe\u8868\u3002

    Fig. AVL \u6811\u5728\u5220\u9664\u8282\u70b9\u540e\u53d1\u751f\u9000\u5316

    \u518d\u4f8b\u5982\uff0c\u5728\u4ee5\u4e0b\u5b8c\u7f8e\u4e8c\u53c9\u6811\u4e2d\u63d2\u5165\u4e24\u4e2a\u8282\u70b9\u540e\uff0c\u6811\u5c06\u4e25\u91cd\u5411\u5de6\u503e\u659c\uff0c\u67e5\u627e\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e5f\u968f\u4e4b\u6076\u5316\u3002

    Fig. AVL \u6811\u5728\u63d2\u5165\u8282\u70b9\u540e\u53d1\u751f\u9000\u5316

    G. M. Adelson-Velsky \u548c E. M. Landis \u5728\u5176 1962 \u5e74\u53d1\u8868\u7684\u8bba\u6587 \"An algorithm for the organization of information\" \u4e2d\u63d0\u51fa\u4e86\u300cAVL \u6811\u300d\u3002\u8bba\u6587\u4e2d\u8be6\u7ec6\u63cf\u8ff0\u4e86\u4e00\u7cfb\u5217\u64cd\u4f5c\uff0c\u786e\u4fdd\u5728\u6301\u7eed\u6dfb\u52a0\u548c\u5220\u9664\u8282\u70b9\u540e\uff0cAVL \u6811\u4e0d\u4f1a\u9000\u5316\uff0c\u4ece\u800c\u4f7f\u5f97\u5404\u79cd\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4fdd\u6301\u5728 \\(O(\\log n)\\) \u7ea7\u522b\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u5728\u9700\u8981\u9891\u7e41\u8fdb\u884c\u589e\u5220\u67e5\u6539\u64cd\u4f5c\u7684\u573a\u666f\u4e2d\uff0cAVL \u6811\u80fd\u59cb\u7ec8\u4fdd\u6301\u9ad8\u6548\u7684\u6570\u636e\u64cd\u4f5c\u6027\u80fd\uff0c\u5177\u6709\u5f88\u597d\u7684\u5e94\u7528\u4ef7\u503c\u3002

    "},{"location":"chapter_tree/avl_tree/#751-avl","title":"7.5.1. \u00a0 AVL \u6811\u5e38\u89c1\u672f\u8bed","text":"

    \u300cAVL \u6811\u300d\u65e2\u662f\u4e8c\u53c9\u641c\u7d22\u6811\u4e5f\u662f\u5e73\u8861\u4e8c\u53c9\u6811\uff0c\u540c\u65f6\u6ee1\u8db3\u8fd9\u4e24\u7c7b\u4e8c\u53c9\u6811\u7684\u6240\u6709\u6027\u8d28\uff0c\u56e0\u6b64\u4e5f\u88ab\u79f0\u4e3a\u300c\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811\u300d\u3002

    "},{"location":"chapter_tree/avl_tree/#_1","title":"\u8282\u70b9\u9ad8\u5ea6","text":"

    \u5728\u64cd\u4f5c AVL \u6811\u65f6\uff0c\u6211\u4eec\u9700\u8981\u83b7\u53d6\u8282\u70b9\u7684\u9ad8\u5ea6\uff0c\u56e0\u6b64\u9700\u8981\u4e3a AVL \u6811\u7684\u8282\u70b9\u7c7b\u6dfb\u52a0 height \u53d8\u91cf\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\npublic int val;        // \u8282\u70b9\u503c\npublic int height;     // \u8282\u70b9\u9ad8\u5ea6\npublic TreeNode left;  // \u5de6\u5b50\u8282\u70b9\npublic TreeNode right; // \u53f3\u5b50\u8282\u70b9\npublic TreeNode(int x) { val = x; }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nstruct TreeNode {\nint val{};          // \u8282\u70b9\u503c\nint height = 0;     // \u8282\u70b9\u9ad8\u5ea6\nTreeNode *left{};   // \u5de6\u5b50\u8282\u70b9\nTreeNode *right{};  // \u53f3\u5b50\u8282\u70b9\nTreeNode() = default;\nexplicit TreeNode(int x) : val(x){}\n};\n
    class TreeNode:\n\"\"\"AVL \u6811\u8282\u70b9\u7c7b\"\"\"\ndef __init__(self, val: int):\nself.val: int = val                    # \u8282\u70b9\u503c\nself.height: int = 0                   # \u8282\u70b9\u9ad8\u5ea6\nself.left: Optional[TreeNode] = None   # \u5de6\u5b50\u8282\u70b9\u5f15\u7528\nself.right: Optional[TreeNode] = None  # \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n
    /* AVL \u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype TreeNode struct {\nVal    int       // \u8282\u70b9\u503c\nHeight int       // \u8282\u70b9\u9ad8\u5ea6\nLeft   *TreeNode // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\nRight  *TreeNode // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nval; // \u8282\u70b9\u503c\nheight; //\u8282\u70b9\u9ad8\u5ea6\nleft; // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nright; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nconstructor(val, left, right, height) {\nthis.val = val === undefined ? 0 : val;\nthis.height = height === undefined ? 0 : height;\nthis.left = left === undefined ? null : left;\nthis.right = right === undefined ? null : right;\n}\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nval: number;            // \u8282\u70b9\u503c\nheight: number;         // \u8282\u70b9\u9ad8\u5ea6\nleft: TreeNode | null;  // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nright: TreeNode | null; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nconstructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\nthis.val = val === undefined ? 0 : val;\nthis.height = height === undefined ? 0 : height; this.left = left === undefined ? null : left; this.right = right === undefined ? null : right; }\n}\n
    /* AVL \u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\nint val;\nint height;\nstruct TreeNode *left;\nstruct TreeNode *right;\n};\ntypedef struct TreeNode TreeNode;\n/* \u6784\u9020\u51fd\u6570 */\nTreeNode *newTreeNode(int val) {\nTreeNode *node;\nnode = (TreeNode *)malloc(sizeof(TreeNode));\nnode->val = val;\nnode->height = 0;\nnode->left = NULL;\nnode->right = NULL;\nreturn node;\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\npublic int val;          // \u8282\u70b9\u503c\npublic int height;       // \u8282\u70b9\u9ad8\u5ea6\npublic TreeNode? left;   // \u5de6\u5b50\u8282\u70b9\npublic TreeNode? right;  // \u53f3\u5b50\u8282\u70b9\npublic TreeNode(int x) { val = x; }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nvar val: Int // \u8282\u70b9\u503c\nvar height: Int // \u8282\u70b9\u9ad8\u5ea6\nvar left: TreeNode? // \u5de6\u5b50\u8282\u70b9\nvar right: TreeNode? // \u53f3\u5b50\u8282\u70b9\ninit(x: Int) {\nval = x\nheight = 0\n}\n}\n
    \n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nint val;         // \u8282\u70b9\u503c\nint height;      // \u8282\u70b9\u9ad8\u5ea6\nTreeNode? left;  // \u5de6\u5b50\u8282\u70b9\nTreeNode? right; // \u53f3\u5b50\u8282\u70b9\nTreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n

    \u300c\u8282\u70b9\u9ad8\u5ea6\u300d\u662f\u6307\u4ece\u8be5\u8282\u70b9\u5230\u6700\u8fdc\u53f6\u8282\u70b9\u7684\u8ddd\u79bb\uff0c\u5373\u6240\u7ecf\u8fc7\u7684\u201c\u8fb9\u201d\u7684\u6570\u91cf\u3002\u9700\u8981\u7279\u522b\u6ce8\u610f\u7684\u662f\uff0c\u53f6\u8282\u70b9\u7684\u9ad8\u5ea6\u4e3a 0 \uff0c\u800c\u7a7a\u8282\u70b9\u7684\u9ad8\u5ea6\u4e3a -1 \u3002\u6211\u4eec\u5c06\u521b\u5efa\u4e24\u4e2a\u5de5\u5177\u51fd\u6570\uff0c\u5206\u522b\u7528\u4e8e\u83b7\u53d6\u548c\u66f4\u65b0\u8282\u70b9\u7684\u9ad8\u5ea6\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nint height(TreeNode node) {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn node == null ? -1 : node.height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode node) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.height = Math.max(height(node.left), height(node.right)) + 1;\n}\n
    avl_tree.cpp
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nint height(TreeNode *node) {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn node == nullptr ? -1 : node->height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode *node) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode->height = max(height(node->left), height(node->right)) + 1;\n}\n
    avl_tree.py
    def height(self, node: TreeNode | None) -> int:\n\"\"\"\u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6\"\"\"\n# \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nif node is not None:\nreturn node.height\nreturn -1\ndef __update_height(self, node: TreeNode | None):\n\"\"\"\u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\"\"\"\n# \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.height = max([self.height(node.left), self.height(node.right)]) + 1\n
    avl_tree.go
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nfunc (t *aVLTree) height(node *TreeNode) int {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nif node != nil {\nreturn node.Height\n}\nreturn -1\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\nlh := t.height(node.Left)\nrh := t.height(node.Right)\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nif lh > rh {\nnode.Height = lh + 1\n} else {\nnode.Height = rh + 1\n}\n}\n
    avl_tree.js
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nheight(node) {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn node === null ? -1 : node.height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\n#updateHeight(node) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.height =\nMath.max(this.height(node.left), this.height(node.right)) + 1;\n}\n
    avl_tree.ts
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nheight(node: TreeNode): number {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn node === null ? -1 : node.height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nupdateHeight(node: TreeNode): void {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.height =\nMath.max(this.height(node.left), this.height(node.right)) + 1;\n}\n
    avl_tree.c
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nint height(TreeNode *node) {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nif (node != NULL) {\nreturn node->height;\n}\nreturn -1;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode *node) {\nint lh = height(node->left);\nint rh = height(node->right);\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nif (lh > rh) {\nnode->height = lh + 1;\n} else {\nnode->height = rh + 1;\n}\n}\n
    avl_tree.cs
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nint height(TreeNode? node) {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn node == null ? -1 : node.height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode node) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.height = Math.Max(height(node.left), height(node.right)) + 1;\n}\n
    avl_tree.swift
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nfunc height(node: TreeNode?) -> Int {\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nnode == nil ? -1 : node!.height\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfunc updateHeight(node: TreeNode?) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode?.height = max(height(node: node?.left), height(node: node?.right)) + 1\n}\n
    avl_tree.zig
    // \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6\nfn height(self: *Self, node: ?*inc.TreeNode(T)) i32 {\n_ = self;\n// \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\nreturn if (node == null) -1 else node.?.height;\n}\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nfn updateHeight(self: *Self, node: ?*inc.TreeNode(T)) void {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode.?.height = @max(self.height(node.?.left), self.height(node.?.right)) + 1;\n}\n
    avl_tree.dart
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nint height(TreeNode? node) {\nreturn node == null ? -1 : node.height;\n}\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode? node) {\n// \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\nnode!.height = max(height(node.left), height(node.right)) + 1;\n}\n
    "},{"location":"chapter_tree/avl_tree/#_2","title":"\u8282\u70b9\u5e73\u8861\u56e0\u5b50","text":"

    \u8282\u70b9\u7684\u300c\u5e73\u8861\u56e0\u5b50 Balance Factor\u300d\u5b9a\u4e49\u4e3a\u8282\u70b9\u5de6\u5b50\u6811\u7684\u9ad8\u5ea6\u51cf\u53bb\u53f3\u5b50\u6811\u7684\u9ad8\u5ea6\uff0c\u540c\u65f6\u89c4\u5b9a\u7a7a\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50\u4e3a 0 \u3002\u6211\u4eec\u540c\u6837\u5c06\u83b7\u53d6\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u7684\u529f\u80fd\u5c01\u88c5\u6210\u51fd\u6570\uff0c\u65b9\u4fbf\u540e\u7eed\u4f7f\u7528\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == null)\nreturn 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node.left) - height(node.right);\n}\n
    avl_tree.cpp
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode *node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == nullptr)\nreturn 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node->left) - height(node->right);\n}\n
    avl_tree.py
    def balance_factor(self, node: TreeNode | None) -> int:\n\"\"\"\u83b7\u53d6\u5e73\u8861\u56e0\u5b50\"\"\"\n# \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif node is None:\nreturn 0\n# \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn self.height(node.left) - self.height(node.right)\n
    avl_tree.go
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nfunc (t *aVLTree) balanceFactor(node *TreeNode) int {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif node == nil {\nreturn 0\n}\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn t.height(node.Left) - t.height(node.Right)\n}\n
    avl_tree.js
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nbalanceFactor(node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node === null) return 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn this.height(node.left) - this.height(node.right);\n}\n
    avl_tree.ts
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nbalanceFactor(node: TreeNode): number {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node === null) return 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn this.height(node.left) - this.height(node.right);\n}\n
    avl_tree.c
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode *node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == NULL) {\nreturn 0;\n}\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node->left) - height(node->right);\n}\n
    avl_tree.cs
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode? node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == null) return 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node.left) - height(node.right);\n}\n
    avl_tree.swift
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nfunc balanceFactor(node: TreeNode?) -> Int {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nguard let node = node else { return 0 }\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node: node.left) - height(node: node.right)\n}\n
    avl_tree.zig
    // \u83b7\u53d6\u5e73\u8861\u56e0\u5b50\nfn balanceFactor(self: *Self, node: ?*inc.TreeNode(T)) i32 {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == null) return 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn self.height(node.?.left) - self.height(node.?.right);\n}\n
    avl_tree.dart
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode? node) {\n// \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\nif (node == null) return 0;\n// \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\nreturn height(node.left) - height(node.right);\n}\n

    Note

    \u8bbe\u5e73\u8861\u56e0\u5b50\u4e3a \\(f\\) \uff0c\u5219\u4e00\u68f5 AVL \u6811\u7684\u4efb\u610f\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50\u7686\u6ee1\u8db3 \\(-1 \\le f \\le 1\\) \u3002

    "},{"location":"chapter_tree/avl_tree/#752-avl","title":"7.5.2. \u00a0 AVL \u6811\u65cb\u8f6c","text":"

    AVL \u6811\u7684\u7279\u70b9\u5728\u4e8e\u300c\u65cb\u8f6c Rotation\u300d\u64cd\u4f5c\uff0c\u5b83\u80fd\u591f\u5728\u4e0d\u5f71\u54cd\u4e8c\u53c9\u6811\u7684\u4e2d\u5e8f\u904d\u5386\u5e8f\u5217\u7684\u524d\u63d0\u4e0b\uff0c\u4f7f\u5931\u8861\u8282\u70b9\u91cd\u65b0\u6062\u590d\u5e73\u8861\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u65cb\u8f6c\u64cd\u4f5c\u65e2\u80fd\u4fdd\u6301\u6811\u7684\u300c\u4e8c\u53c9\u641c\u7d22\u6811\u300d\u5c5e\u6027\uff0c\u4e5f\u80fd\u4f7f\u6811\u91cd\u65b0\u53d8\u4e3a\u300c\u5e73\u8861\u4e8c\u53c9\u6811\u300d\u3002

    \u6211\u4eec\u5c06\u5e73\u8861\u56e0\u5b50\u7edd\u5bf9\u503c \\(> 1\\) \u7684\u8282\u70b9\u79f0\u4e3a\u300c\u5931\u8861\u8282\u70b9\u300d\u3002\u6839\u636e\u8282\u70b9\u5931\u8861\u60c5\u51b5\u7684\u4e0d\u540c\uff0c\u65cb\u8f6c\u64cd\u4f5c\u5206\u4e3a\u56db\u79cd\uff1a\u53f3\u65cb\u3001\u5de6\u65cb\u3001\u5148\u53f3\u65cb\u540e\u5de6\u65cb\u3001\u5148\u5de6\u65cb\u540e\u53f3\u65cb\u3002\u4e0b\u9762\u6211\u4eec\u5c06\u8be6\u7ec6\u4ecb\u7ecd\u8fd9\u4e9b\u65cb\u8f6c\u64cd\u4f5c\u3002

    "},{"location":"chapter_tree/avl_tree/#_3","title":"\u53f3\u65cb","text":"

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u8282\u70b9\u4e0b\u65b9\u4e3a\u5e73\u8861\u56e0\u5b50\u3002\u4ece\u5e95\u81f3\u9876\u770b\uff0c\u4e8c\u53c9\u6811\u4e2d\u9996\u4e2a\u5931\u8861\u8282\u70b9\u662f\u201c\u8282\u70b9 3\u201d\u3002\u6211\u4eec\u5173\u6ce8\u4ee5\u8be5\u5931\u8861\u8282\u70b9\u4e3a\u6839\u8282\u70b9\u7684\u5b50\u6811\uff0c\u5c06\u8be5\u8282\u70b9\u8bb0\u4e3a node \uff0c\u5176\u5de6\u5b50\u8282\u70b9\u8bb0\u4e3a child \uff0c\u6267\u884c\u300c\u53f3\u65cb\u300d\u64cd\u4f5c\u3002\u5b8c\u6210\u53f3\u65cb\u540e\uff0c\u5b50\u6811\u5df2\u7ecf\u6062\u590d\u5e73\u8861\uff0c\u5e76\u4e14\u4ecd\u7136\u4fdd\u6301\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u7279\u6027\u3002

    <1><2><3><4>

    \u6b64\u5916\uff0c\u5982\u679c\u8282\u70b9 child \u672c\u8eab\u6709\u53f3\u5b50\u8282\u70b9\uff08\u8bb0\u4e3a grandChild \uff09\uff0c\u5219\u9700\u8981\u5728\u300c\u53f3\u65cb\u300d\u4e2d\u6dfb\u52a0\u4e00\u6b65\uff1a\u5c06 grandChild \u4f5c\u4e3a node \u7684\u5de6\u5b50\u8282\u70b9\u3002

    Fig. \u6709 grandChild \u7684\u53f3\u65cb\u64cd\u4f5c

    \u201c\u5411\u53f3\u65cb\u8f6c\u201d\u662f\u4e00\u79cd\u5f62\u8c61\u5316\u7684\u8bf4\u6cd5\uff0c\u5b9e\u9645\u4e0a\u9700\u8981\u901a\u8fc7\u4fee\u6539\u8282\u70b9\u6307\u9488\u6765\u5b9e\u73b0\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode rightRotate(TreeNode node) {\nTreeNode child = node.left;\nTreeNode grandChild = child.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node;\nnode.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.cpp
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode *rightRotate(TreeNode *node) {\nTreeNode *child = node->left;\nTreeNode *grandChild = child->right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild->right = node;\nnode->left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.py
    def __right_rotate(self, node: TreeNode | None) -> TreeNode | None:\n\"\"\"\u53f3\u65cb\u64cd\u4f5c\"\"\"\nchild = node.left\ngrand_child = child.right\n# \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node\nnode.left = grand_child\n# \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.__update_height(node)\nself.__update_height(child)\n# \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n
    avl_tree.go
    /* \u53f3\u65cb\u64cd\u4f5c */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\nchild := node.Left\ngrandChild := child.Right\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.Right = node\nnode.Left = grandChild\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nt.updateHeight(node)\nt.updateHeight(child)\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n}\n
    avl_tree.js
    /* \u53f3\u65cb\u64cd\u4f5c */\n#rightRotate(node) {\nconst child = node.left;\nconst grandChild = child.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node;\nnode.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nthis.#updateHeight(node);\nthis.#updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.ts
    /* \u53f3\u65cb\u64cd\u4f5c */\nrightRotate(node: TreeNode): TreeNode {\nconst child = node.left;\nconst grandChild = child.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node;\nnode.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nthis.updateHeight(node);\nthis.updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.c
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode *rightRotate(TreeNode *node) {\nTreeNode *child, *grandChild;\nchild = node->left;\ngrandChild = child->right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild->right = node;\nnode->left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.cs
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode? rightRotate(TreeNode? node) {\nTreeNode? child = node.left;\nTreeNode? grandChild = child?.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node;\nnode.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.swift
    /* \u53f3\u65cb\u64cd\u4f5c */\nfunc rightRotate(node: TreeNode?) -> TreeNode? {\nlet child = node?.left\nlet grandChild = child?.right\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild?.right = node\nnode?.left = grandChild\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node: node)\nupdateHeight(node: child)\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n}\n
    avl_tree.zig
    // \u53f3\u65cb\u64cd\u4f5c\nfn rightRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\nvar child = node.?.left;\nvar grandChild = child.?.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.?.right = node;\nnode.?.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.updateHeight(node);\nself.updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.dart
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode? rightRotate(TreeNode? node) {\nTreeNode? child = node!.left;\nTreeNode? grandChild = child!.right;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\nchild.right = node;\nnode.left = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    "},{"location":"chapter_tree/avl_tree/#_4","title":"\u5de6\u65cb","text":"

    \u76f8\u5e94\u7684\uff0c\u5982\u679c\u8003\u8651\u4e0a\u8ff0\u5931\u8861\u4e8c\u53c9\u6811\u7684\u201c\u955c\u50cf\u201d\uff0c\u5219\u9700\u8981\u6267\u884c\u300c\u5de6\u65cb\u300d\u64cd\u4f5c\u3002

    Fig. \u5de6\u65cb\u64cd\u4f5c

    \u540c\u7406\uff0c\u82e5\u8282\u70b9 child \u672c\u8eab\u6709\u5de6\u5b50\u8282\u70b9\uff08\u8bb0\u4e3a grandChild \uff09\uff0c\u5219\u9700\u8981\u5728\u300c\u5de6\u65cb\u300d\u4e2d\u6dfb\u52a0\u4e00\u6b65\uff1a\u5c06 grandChild \u4f5c\u4e3a node \u7684\u53f3\u5b50\u8282\u70b9\u3002

    Fig. \u6709 grandChild \u7684\u5de6\u65cb\u64cd\u4f5c

    \u53ef\u4ee5\u89c2\u5bdf\u5230\uff0c\u53f3\u65cb\u548c\u5de6\u65cb\u64cd\u4f5c\u5728\u903b\u8f91\u4e0a\u662f\u955c\u50cf\u5bf9\u79f0\u7684\uff0c\u5b83\u4eec\u5206\u522b\u89e3\u51b3\u7684\u4e24\u79cd\u5931\u8861\u60c5\u51b5\u4e5f\u662f\u5bf9\u79f0\u7684\u3002\u57fa\u4e8e\u5bf9\u79f0\u6027\uff0c\u6211\u4eec\u53ef\u4ee5\u8f7b\u677e\u5730\u4ece\u53f3\u65cb\u7684\u4ee3\u7801\u63a8\u5bfc\u51fa\u5de6\u65cb\u7684\u4ee3\u7801\u3002\u5177\u4f53\u5730\uff0c\u53ea\u9700\u5c06\u300c\u53f3\u65cb\u300d\u4ee3\u7801\u4e2d\u7684\u628a\u6240\u6709\u7684 left \u66ff\u6362\u4e3a right \uff0c\u5c06\u6240\u6709\u7684 right \u66ff\u6362\u4e3a left \uff0c\u5373\u53ef\u5f97\u5230\u300c\u5de6\u65cb\u300d\u4ee3\u7801\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode leftRotate(TreeNode node) {\nTreeNode child = node.right;\nTreeNode grandChild = child.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node;\nnode.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.cpp
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode *leftRotate(TreeNode *node) {\nTreeNode *child = node->right;\nTreeNode *grandChild = child->left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild->left = node;\nnode->right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.py
    def __left_rotate(self, node: TreeNode | None) -> TreeNode | None:\n\"\"\"\u5de6\u65cb\u64cd\u4f5c\"\"\"\nchild = node.right\ngrand_child = child.left\n# \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node\nnode.right = grand_child\n# \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.__update_height(node)\nself.__update_height(child)\n# \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n
    avl_tree.go
    /* \u5de6\u65cb\u64cd\u4f5c */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\nchild := node.Right\ngrandChild := child.Left\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.Left = node\nnode.Right = grandChild\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nt.updateHeight(node)\nt.updateHeight(child)\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n}\n
    avl_tree.js
    /* \u5de6\u65cb\u64cd\u4f5c */\n#leftRotate(node) {\nconst child = node.right;\nconst grandChild = child.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node;\nnode.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nthis.#updateHeight(node);\nthis.#updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.ts
    /* \u5de6\u65cb\u64cd\u4f5c */\nleftRotate(node: TreeNode): TreeNode {\nconst child = node.right;\nconst grandChild = child.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node;\nnode.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nthis.updateHeight(node);\nthis.updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.c
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode *leftRotate(TreeNode *node) {\nTreeNode *child, *grandChild;\nchild = node->right;\ngrandChild = child->left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild->left = node;\nnode->right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.cs
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode? leftRotate(TreeNode? node) {\nTreeNode? child = node.right;\nTreeNode? grandChild = child?.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node;\nnode.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.swift
    /* \u5de6\u65cb\u64cd\u4f5c */\nfunc leftRotate(node: TreeNode?) -> TreeNode? {\nlet child = node?.right\nlet grandChild = child?.left\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild?.left = node\nnode?.right = grandChild\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node: node)\nupdateHeight(node: child)\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child\n}\n
    avl_tree.zig
    // \u5de6\u65cb\u64cd\u4f5c\nfn leftRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\nvar child = node.?.right;\nvar grandChild = child.?.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.?.left = node;\nnode.?.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.updateHeight(node);\nself.updateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    avl_tree.dart
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode? leftRotate(TreeNode? node) {\nTreeNode? child = node!.right;\nTreeNode? grandChild = child!.left;\n// \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\nchild.left = node;\nnode.right = grandChild;\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\nupdateHeight(child);\n// \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn child;\n}\n
    "},{"location":"chapter_tree/avl_tree/#_5","title":"\u5148\u5de6\u65cb\u540e\u53f3\u65cb","text":"

    \u5bf9\u4e8e\u4e0b\u56fe\u4e2d\u7684\u5931\u8861\u8282\u70b9 3\uff0c\u4ec5\u4f7f\u7528\u5de6\u65cb\u6216\u53f3\u65cb\u90fd\u65e0\u6cd5\u4f7f\u5b50\u6811\u6062\u590d\u5e73\u8861\u3002\u6b64\u65f6\u9700\u8981\u5148\u5de6\u65cb\u540e\u53f3\u65cb\uff0c\u5373\u5148\u5bf9 child \u6267\u884c\u300c\u5de6\u65cb\u300d\uff0c\u518d\u5bf9 node \u6267\u884c\u300c\u53f3\u65cb\u300d\u3002

    Fig. \u5148\u5de6\u65cb\u540e\u53f3\u65cb

    "},{"location":"chapter_tree/avl_tree/#_6","title":"\u5148\u53f3\u65cb\u540e\u5de6\u65cb","text":"

    \u540c\u7406\uff0c\u5bf9\u4e8e\u4e0a\u8ff0\u5931\u8861\u4e8c\u53c9\u6811\u7684\u955c\u50cf\u60c5\u51b5\uff0c\u9700\u8981\u5148\u53f3\u65cb\u540e\u5de6\u65cb\uff0c\u5373\u5148\u5bf9 child \u6267\u884c\u300c\u53f3\u65cb\u300d\uff0c\u7136\u540e\u5bf9 node \u6267\u884c\u300c\u5de6\u65cb\u300d\u3002

    Fig. \u5148\u53f3\u65cb\u540e\u5de6\u65cb

    "},{"location":"chapter_tree/avl_tree/#_7","title":"\u65cb\u8f6c\u7684\u9009\u62e9","text":"

    \u4e0b\u56fe\u5c55\u793a\u7684\u56db\u79cd\u5931\u8861\u60c5\u51b5\u4e0e\u4e0a\u8ff0\u6848\u4f8b\u9010\u4e2a\u5bf9\u5e94\uff0c\u5206\u522b\u9700\u8981\u91c7\u7528\u53f3\u65cb\u3001\u5de6\u65cb\u3001\u5148\u53f3\u540e\u5de6\u3001\u5148\u5de6\u540e\u53f3\u7684\u65cb\u8f6c\u64cd\u4f5c\u3002

    Fig. AVL \u6811\u7684\u56db\u79cd\u65cb\u8f6c\u60c5\u51b5

    \u5728\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u901a\u8fc7\u5224\u65ad\u5931\u8861\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50\u4ee5\u53ca\u8f83\u9ad8\u4e00\u4fa7\u5b50\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50\u7684\u6b63\u8d1f\u53f7\uff0c\u6765\u786e\u5b9a\u5931\u8861\u8282\u70b9\u5c5e\u4e8e\u4e0a\u56fe\u4e2d\u7684\u54ea\u79cd\u60c5\u51b5\u3002

    \u5931\u8861\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50 \u5b50\u8282\u70b9\u7684\u5e73\u8861\u56e0\u5b50 \u5e94\u91c7\u7528\u7684\u65cb\u8f6c\u65b9\u6cd5 \\(>1\\) \uff08\u5373\u5de6\u504f\u6811\uff09 \\(\\geq 0\\) \u53f3\u65cb \\(>1\\) \uff08\u5373\u5de6\u504f\u6811\uff09 \\(<0\\) \u5148\u5de6\u65cb\u540e\u53f3\u65cb \\(<-1\\) \uff08\u5373\u53f3\u504f\u6811\uff09 \\(\\leq 0\\) \u5de6\u65cb \\(<-1\\) \uff08\u5373\u53f3\u504f\u6811\uff09 \\(>0\\) \u5148\u53f3\u65cb\u540e\u5de6\u65cb

    \u4e3a\u4e86\u4fbf\u4e8e\u4f7f\u7528\uff0c\u6211\u4eec\u5c06\u65cb\u8f6c\u64cd\u4f5c\u5c01\u88c5\u6210\u4e00\u4e2a\u51fd\u6570\u3002\u6709\u4e86\u8fd9\u4e2a\u51fd\u6570\uff0c\u6211\u4eec\u5c31\u80fd\u5bf9\u5404\u79cd\u5931\u8861\u60c5\u51b5\u8fdb\u884c\u65cb\u8f6c\uff0c\u4f7f\u5931\u8861\u8282\u70b9\u91cd\u65b0\u6062\u590d\u5e73\u8861\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nTreeNode rotate(TreeNode node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nint balanceFactor = balanceFactor(node);\n// \u5de6\u504f\u6811\nif (balanceFactor > 1) {\nif (balanceFactor(node.left) >= 0) {\n// \u53f3\u65cb\nreturn rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = leftRotate(node.left);\nreturn rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (balanceFactor < -1) {\nif (balanceFactor(node.right) <= 0) {\n// \u5de6\u65cb\nreturn leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = rightRotate(node.right);\nreturn leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.cpp
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nTreeNode *rotate(TreeNode *node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nint _balanceFactor = balanceFactor(node);\n// \u5de6\u504f\u6811\nif (_balanceFactor > 1) {\nif (balanceFactor(node->left) >= 0) {\n// \u53f3\u65cb\nreturn rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode->left = leftRotate(node->left);\nreturn rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (_balanceFactor < -1) {\nif (balanceFactor(node->right) <= 0) {\n// \u5de6\u65cb\nreturn leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode->right = rightRotate(node->right);\nreturn leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.py
    def __rotate(self, node: TreeNode | None) -> TreeNode | None:\n\"\"\"\u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\"\"\"\n# \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nbalance_factor = self.balance_factor(node)\n# \u5de6\u504f\u6811\nif balance_factor > 1:\nif self.balance_factor(node.left) >= 0:\n# \u53f3\u65cb\nreturn self.__right_rotate(node)\nelse:\n# \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = self.__left_rotate(node.left)\nreturn self.__right_rotate(node)\n# \u53f3\u504f\u6811\nelif balance_factor < -1:\nif self.balance_factor(node.right) <= 0:\n# \u5de6\u65cb\nreturn self.__left_rotate(node)\nelse:\n# \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = self.__right_rotate(node.right)\nreturn self.__left_rotate(node)\n# \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node\n
    avl_tree.go
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nfunc (t *aVLTree) rotate(node *TreeNode) *TreeNode {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\n// Go \u63a8\u8350\u77ed\u53d8\u91cf\uff0c\u8fd9\u91cc bf \u6307\u4ee3 t.balanceFactor\nbf := t.balanceFactor(node)\n// \u5de6\u504f\u6811\nif bf > 1 {\nif t.balanceFactor(node.Left) >= 0 {\n// \u53f3\u65cb\nreturn t.rightRotate(node)\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.Left = t.leftRotate(node.Left)\nreturn t.rightRotate(node)\n}\n}\n// \u53f3\u504f\u6811\nif bf < -1 {\nif t.balanceFactor(node.Right) <= 0 {\n// \u5de6\u65cb\nreturn t.leftRotate(node)\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.Right = t.rightRotate(node.Right)\nreturn t.leftRotate(node)\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node\n}\n
    avl_tree.js
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n#rotate(node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nconst balanceFactor = this.balanceFactor(node);\n// \u5de6\u504f\u6811\nif (balanceFactor > 1) {\nif (this.balanceFactor(node.left) >= 0) {\n// \u53f3\u65cb\nreturn this.#rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = this.#leftRotate(node.left);\nreturn this.#rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (balanceFactor < -1) {\nif (this.balanceFactor(node.right) <= 0) {\n// \u5de6\u65cb\nreturn this.#leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = this.#rightRotate(node.right);\nreturn this.#leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.ts
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nrotate(node: TreeNode): TreeNode {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nconst balanceFactor = this.balanceFactor(node);\n// \u5de6\u504f\u6811\nif (balanceFactor > 1) {\nif (this.balanceFactor(node.left) >= 0) {\n// \u53f3\u65cb\nreturn this.rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = this.leftRotate(node.left);\nreturn this.rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (balanceFactor < -1) {\nif (this.balanceFactor(node.right) <= 0) {\n// \u5de6\u65cb\nreturn this.leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = this.rightRotate(node.right);\nreturn this.leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.c
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nTreeNode *rotate(TreeNode *node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nint bf = balanceFactor(node);\n// \u5de6\u504f\u6811\nif (bf > 1) {\nif (balanceFactor(node->left) >= 0) {\n// \u53f3\u65cb\nreturn rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode->left = leftRotate(node->left);\nreturn rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (bf < -1) {\nif (balanceFactor(node->right) <= 0) {\n// \u5de6\u65cb\nreturn leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode->right = rightRotate(node->right);\nreturn leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.cs
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nTreeNode? rotate(TreeNode? node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nint balanceFactorInt = balanceFactor(node);\n// \u5de6\u504f\u6811\nif (balanceFactorInt > 1) {\nif (balanceFactor(node.left) >= 0) {\n// \u53f3\u65cb\nreturn rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = leftRotate(node?.left);\nreturn rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (balanceFactorInt < -1) {\nif (balanceFactor(node.right) <= 0) {\n// \u5de6\u65cb\nreturn leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = rightRotate(node?.right);\nreturn leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.swift
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nfunc rotate(node: TreeNode?) -> TreeNode? {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nlet balanceFactor = balanceFactor(node: node)\n// \u5de6\u504f\u6811\nif balanceFactor > 1 {\nif self.balanceFactor(node: node?.left) >= 0 {\n// \u53f3\u65cb\nreturn rightRotate(node: node)\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode?.left = leftRotate(node: node?.left)\nreturn rightRotate(node: node)\n}\n}\n// \u53f3\u504f\u6811\nif balanceFactor < -1 {\nif self.balanceFactor(node: node?.right) <= 0 {\n// \u5de6\u65cb\nreturn leftRotate(node: node)\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode?.right = rightRotate(node: node?.right)\nreturn leftRotate(node: node)\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node\n}\n
    avl_tree.zig
    // \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\nfn rotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nvar balance_factor = self.balanceFactor(node);\n// \u5de6\u504f\u6811\nif (balance_factor > 1) {\nif (self.balanceFactor(node.?.left) >= 0) {\n// \u53f3\u65cb\nreturn self.rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.?.left = self.leftRotate(node.?.left);\nreturn self.rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (balance_factor < -1) {\nif (self.balanceFactor(node.?.right) <= 0) {\n// \u5de6\u65cb\nreturn self.leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.?.right = self.rightRotate(node.?.right);\nreturn self.leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    avl_tree.dart
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nTreeNode? rotate(TreeNode? node) {\n// \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\nint factor = balanceFactor(node);\n// \u5de6\u504f\u6811\nif (factor > 1) {\nif (balanceFactor(node!.left) >= 0) {\n// \u53f3\u65cb\nreturn rightRotate(node);\n} else {\n// \u5148\u5de6\u65cb\u540e\u53f3\u65cb\nnode.left = leftRotate(node.left);\nreturn rightRotate(node);\n}\n}\n// \u53f3\u504f\u6811\nif (factor < -1) {\nif (balanceFactor(node!.right) <= 0) {\n// \u5de6\u65cb\nreturn leftRotate(node);\n} else {\n// \u5148\u53f3\u65cb\u540e\u5de6\u65cb\nnode.right = rightRotate(node.right);\nreturn leftRotate(node);\n}\n}\n// \u5e73\u8861\u6811\uff0c\u65e0\u9700\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#753-avl","title":"7.5.3. \u00a0 AVL \u6811\u5e38\u7528\u64cd\u4f5c","text":""},{"location":"chapter_tree/avl_tree/#_8","title":"\u63d2\u5165\u8282\u70b9","text":"

    \u300cAVL \u6811\u300d\u7684\u8282\u70b9\u63d2\u5165\u64cd\u4f5c\u4e0e\u300c\u4e8c\u53c9\u641c\u7d22\u6811\u300d\u5728\u4e3b\u4f53\u4e0a\u7c7b\u4f3c\u3002\u552f\u4e00\u7684\u533a\u522b\u5728\u4e8e\uff0c\u5728 AVL \u6811\u4e2d\u63d2\u5165\u8282\u70b9\u540e\uff0c\u4ece\u8be5\u8282\u70b9\u5230\u6839\u8282\u70b9\u7684\u8def\u5f84\u4e0a\u53ef\u80fd\u4f1a\u51fa\u73b0\u4e00\u7cfb\u5217\u5931\u8861\u8282\u70b9\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u9700\u8981\u4ece\u8fd9\u4e2a\u8282\u70b9\u5f00\u59cb\uff0c\u81ea\u5e95\u5411\u4e0a\u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u6240\u6709\u5931\u8861\u8282\u70b9\u6062\u590d\u5e73\u8861\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\nroot = insertHelper(root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode insertHelper(TreeNode node, int val) {\nif (node == null)\nreturn new TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node.val)\nnode.left = insertHelper(node.left, val);\nelse if (val > node.val)\nnode.right = insertHelper(node.right, val);\nelse\nreturn node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.cpp
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\nroot = insertHelper(root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode *insertHelper(TreeNode *node, int val) {\nif (node == nullptr)\nreturn new TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node->val)\nnode->left = insertHelper(node->left, val);\nelse if (val > node->val)\nnode->right = insertHelper(node->right, val);\nelse\nreturn node;    // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.py
    def insert(self, val) -> None:\n\"\"\"\u63d2\u5165\u8282\u70b9\"\"\"\nself.root = self.__insert_helper(self.root, val)\ndef __insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:\n\"\"\"\u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\"\"\"\nif node is None:\nreturn TreeNode(val)\n# 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9\nif val < node.val:\nnode.left = self.__insert_helper(node.left, val)\nelif val > node.val:\nnode.right = self.__insert_helper(node.right, val)\nelse:\n# \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node\n# \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.__update_height(node)\n# 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\nreturn self.__rotate(node)\n
    avl_tree.go
    /* \u63d2\u5165\u8282\u70b9 */\nfunc (t *aVLTree) insert(val int) {\nt.root = t.insertHelper(t.root, val)\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\nif node == nil {\nreturn NewTreeNode(val)\n}\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif val < node.Val {\nnode.Left = t.insertHelper(node.Left, val)\n} else if val > node.Val {\nnode.Right = t.insertHelper(node.Right, val)\n} else {\n// \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node\n}\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nt.updateHeight(node)\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = t.rotate(node)\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node\n}\n
    avl_tree.js
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(val) {\nthis.root = this.#insertHelper(this.root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\n#insertHelper(node, val) {\nif (node === null) return new TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node.val) node.left = this.#insertHelper(node.left, val);\nelse if (val > node.val)\nnode.right = this.#insertHelper(node.right, val);\nelse return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nthis.#updateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = this.#rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.ts
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(val: number): void {\nthis.root = this.insertHelper(this.root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\ninsertHelper(node: TreeNode, val: number): TreeNode {\nif (node === null) return new TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node.val) {\nnode.left = this.insertHelper(node.left, val);\n} else if (val > node.val) {\nnode.right = this.insertHelper(node.right, val);\n} else {\nreturn node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n}\nthis.updateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = this.rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.c
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(aVLTree *tree, int val) {\ntree->root = insertHelper(tree->root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nTreeNode *insertHelper(TreeNode *node, int val) {\nif (node == NULL) {\nreturn newTreeNode(val);\n}\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node->val) {\nnode->left = insertHelper(node->left, val);\n} else if (val > node->val) {\nnode->right = insertHelper(node->right, val);\n} else {\n// \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nreturn node;\n}\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.cs
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\nroot = insertHelper(root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? insertHelper(TreeNode? node, int val) {\nif (node == null) return new TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node.val)\nnode.left = insertHelper(node.left, val);\nelse if (val > node.val)\nnode.right = insertHelper(node.right, val);\nelse\nreturn node;     // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nupdateHeight(node);  // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.swift
    /* \u63d2\u5165\u8282\u70b9 */\n@discardableResult\nfunc insert(val: Int) {\nroot = insertHelper(node: root, val: val)\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfunc insertHelper(node: TreeNode?, val: Int) -> TreeNode? {\nvar node = node\nif node == nil {\nreturn TreeNode(x: val)\n}\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif val < node!.val {\nnode?.left = insertHelper(node: node?.left, val: val)\n} else if val > node!.val {\nnode?.right = insertHelper(node: node?.right, val: val)\n} else {\nreturn node // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n}\nupdateHeight(node: node) // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node: node)\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node\n}\n
    avl_tree.zig
    // \u63d2\u5165\u8282\u70b9\nfn insert(self: *Self, val: T) !void {\nself.root = (try self.insertHelper(self.root, val)).?;\n}\n// \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\nfn insertHelper(self: *Self, node_: ?*inc.TreeNode(T), val: T) !?*inc.TreeNode(T) {\nvar node = node_;\nif (node == null) {\nvar tmp_node = try self.mem_allocator.create(inc.TreeNode(T));\ntmp_node.init(val);\nreturn tmp_node;\n}\n// 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9\nif (val < node.?.val) {\nnode.?.left = try self.insertHelper(node.?.left, val);\n} else if (val > node.?.val) {\nnode.?.right = try self.insertHelper(node.?.right, val);\n} else {\nreturn node;            // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n}\nself.updateHeight(node);    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n// 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\nnode = self.rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.dart
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\nroot = insertHelper(root, val);\n}\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? insertHelper(TreeNode? node, int val) {\nif (node == null) return TreeNode(val);\n/* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff0c\u5e76\u63d2\u5165\u8282\u70b9 */\nif (val < node.val)\nnode.left = insertHelper(node.left, val);\nelse if (val > node.val)\nnode.right = insertHelper(node.right, val);\nelse\nreturn node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#_9","title":"\u5220\u9664\u8282\u70b9","text":"

    \u7c7b\u4f3c\u5730\uff0c\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u5220\u9664\u8282\u70b9\u65b9\u6cd5\u7684\u57fa\u7840\u4e0a\uff0c\u9700\u8981\u4ece\u5e95\u81f3\u9876\u5730\u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u6240\u6709\u5931\u8861\u8282\u70b9\u6062\u590d\u5e73\u8861\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart avl_tree.java
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\nroot = removeHelper(root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode removeHelper(TreeNode node, int val) {\nif (node == null)\nreturn null;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node.val)\nnode.left = removeHelper(node.left, val);\nelse if (val > node.val)\nnode.right = removeHelper(node.right, val);\nelse {\nif (node.left == null || node.right == null) {\nTreeNode child = node.left != null ? node.left : node.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == null)\nreturn null;\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse\nnode = child;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nTreeNode temp = node.right;\nwhile (temp.left != null) {\ntemp = temp.left;\n}\nnode.right = removeHelper(node.right, temp.val);\nnode.val = temp.val;\n}\n}\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.cpp
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\nroot = removeHelper(root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode *removeHelper(TreeNode *node, int val) {\nif (node == nullptr)\nreturn nullptr;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node->val)\nnode->left = removeHelper(node->left, val);\nelse if (val > node->val)\nnode->right = removeHelper(node->right, val);\nelse {\nif (node->left == nullptr || node->right == nullptr) {\nTreeNode *child = node->left != nullptr ? node->left : node->right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == nullptr) {\ndelete node;\nreturn nullptr;\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse {\ndelete node;\nnode = child;\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nTreeNode *temp = node->right;\nwhile (temp->left != nullptr) {\ntemp = temp->left;\n}\nint tempVal = temp->val;\nnode->right = removeHelper(node->right, temp->val);\nnode->val = tempVal;\n}\n}\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.py
    def remove(self, val: int) -> None:\n\"\"\"\u5220\u9664\u8282\u70b9\"\"\"\nself.root = self.__remove_helper(self.root, val)\ndef __remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:\n\"\"\"\u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\"\"\"\nif node is None:\nreturn None\n# 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b\nif val < node.val:\nnode.left = self.__remove_helper(node.left, val)\nelif val > node.val:\nnode.right = self.__remove_helper(node.right, val)\nelse:\nif node.left is None or node.right is None:\nchild = node.left or node.right\n# \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif child is None:\nreturn None\n# \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse:\nnode = child\nelse:\n# \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\ntemp = node.right\nwhile temp.left is not None:\ntemp = temp.left\nnode.right = self.__remove_helper(node.right, temp.val)\nnode.val = temp.val\n# \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nself.__update_height(node)\n# 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\nreturn self.__rotate(node)\n
    avl_tree.go
    /* \u5220\u9664\u8282\u70b9 */\nfunc (t *aVLTree) remove(val int) {\nt.root = t.removeHelper(t.root, val)\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\nif node == nil {\nreturn nil\n}\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif val < node.Val {\nnode.Left = t.removeHelper(node.Left, val)\n} else if val > node.Val {\nnode.Right = t.removeHelper(node.Right, val)\n} else {\nif node.Left == nil || node.Right == nil {\nchild := node.Left\nif node.Right != nil {\nchild = node.Right\n}\nif child == nil {\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nreturn nil\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nnode = child\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\ntemp := node.Right\nfor temp.Left != nil {\ntemp = temp.Left\n}\nnode.Right = t.removeHelper(node.Right, temp.Val)\nnode.Val = temp.Val\n}\n}\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nt.updateHeight(node)\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = t.rotate(node)\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node\n}\n
    avl_tree.js
    /* \u5220\u9664\u8282\u70b9 */\nremove(val) {\nthis.root = this.#removeHelper(this.root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\n#removeHelper(node, val) {\nif (node === null) return null;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node.val) node.left = this.#removeHelper(node.left, val);\nelse if (val > node.val)\nnode.right = this.#removeHelper(node.right, val);\nelse {\nif (node.left === null || node.right === null) {\nconst child = node.left !== null ? node.left : node.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child === null) return null;\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse node = child;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nlet temp = node.right;\nwhile (temp.left !== null) {\ntemp = temp.left;\n}\nnode.right = this.#removeHelper(node.right, temp.val);\nnode.val = temp.val;\n}\n}\nthis.#updateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = this.#rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.ts
    /* \u5220\u9664\u8282\u70b9 */\nremove(val: number): void {\nthis.root = this.removeHelper(this.root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nremoveHelper(node: TreeNode, val: number): TreeNode {\nif (node === null) return null;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node.val) {\nnode.left = this.removeHelper(node.left, val);\n} else if (val > node.val) {\nnode.right = this.removeHelper(node.right, val);\n} else {\nif (node.left === null || node.right === null) {\nconst child = node.left !== null ? node.left : node.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child === null) {\nreturn null;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nnode = child;\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nlet temp = node.right;\nwhile (temp.left !== null) {\ntemp = temp.left;\n}\nnode.right = this.removeHelper(node.right, temp.val);\nnode.val = temp.val;\n}\n}\nthis.updateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = this.rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.c
    /* \u5220\u9664\u8282\u70b9 */\n// \u7531\u4e8e\u5f15\u5165\u4e86 stdio.h \uff0c\u6b64\u5904\u65e0\u6cd5\u4f7f\u7528 remove \u5173\u952e\u8bcd\nvoid removeNode(aVLTree *tree, int val) {\nTreeNode *root = removeHelper(tree->root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nTreeNode *removeHelper(TreeNode *node, int val) {\nTreeNode *child, *grandChild;\nif (node == NULL) {\nreturn NULL;\n}\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node->val) {\nnode->left = removeHelper(node->left, val);\n} else if (val > node->val) {\nnode->right = removeHelper(node->right, val);\n} else {\nif (node->left == NULL || node->right == NULL) {\nchild = node->left;\nif (node->right != NULL) {\nchild = node->right;\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == NULL) {\nreturn NULL;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nnode = child;\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nTreeNode *temp = node->right;\nwhile (temp->left != NULL) {\ntemp = temp->left;\n}\nint tempVal = temp->val;\nnode->right = removeHelper(node->right, temp->val);\nnode->val = tempVal;\n}\n}\n// \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\nupdateHeight(node);\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.cs
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\nroot = removeHelper(root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? removeHelper(TreeNode? node, int val) {\nif (node == null) return null;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node.val)\nnode.left = removeHelper(node.left, val);\nelse if (val > node.val)\nnode.right = removeHelper(node.right, val);\nelse {\nif (node.left == null || node.right == null) {\nTreeNode? child = node.left != null ? node.left : node.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == null)\nreturn null;\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse\nnode = child;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nTreeNode? temp = node.right;\nwhile (temp.left != null) {\ntemp = temp.left;\n}\nnode.right = removeHelper(node.right, temp.val);\nnode.val = temp.val;\n}\n}\nupdateHeight(node);  // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.swift
    /* \u5220\u9664\u8282\u70b9 */\n@discardableResult\nfunc remove(val: Int) {\nroot = removeHelper(node: root, val: val)\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfunc removeHelper(node: TreeNode?, val: Int) -> TreeNode? {\nvar node = node\nif node == nil {\nreturn nil\n}\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif val < node!.val {\nnode?.left = removeHelper(node: node?.left, val: val)\n} else if val > node!.val {\nnode?.right = removeHelper(node: node?.right, val: val)\n} else {\nif node?.left == nil || node?.right == nil {\nlet child = node?.left != nil ? node?.left : node?.right\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif child == nil {\nreturn nil\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse {\nnode = child\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nvar temp = node?.right\nwhile temp?.left != nil {\ntemp = temp?.left\n}\nnode?.right = removeHelper(node: node?.right, val: temp!.val)\nnode?.val = temp!.val\n}\n}\nupdateHeight(node: node) // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node: node)\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node\n}\n
    avl_tree.zig
    // \u5220\u9664\u8282\u70b9\nfn remove(self: *Self, val: T) void {\nself.root = self.removeHelper(self.root, val).?;\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\nfn removeHelper(self: *Self, node_: ?*inc.TreeNode(T), val: T) ?*inc.TreeNode(T) {\nvar node = node_;\nif (node == null) return null;\n// 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b\nif (val < node.?.val) {\nnode.?.left = self.removeHelper(node.?.left, val);\n} else if (val > node.?.val) {\nnode.?.right = self.removeHelper(node.?.right, val);\n} else {\nif (node.?.left == null or node.?.right == null) {\nvar child = if (node.?.left != null) node.?.left else node.?.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == null) {\nreturn null;\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n} else {\nnode = child;\n}\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nvar temp = node.?.right;\nwhile (temp.?.left != null) {\ntemp = temp.?.left;\n}\nnode.?.right = self.removeHelper(node.?.right, temp.?.val);\nnode.?.val = temp.?.val;\n}\n}\nself.updateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n// 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\nnode = self.rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    avl_tree.dart
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\nroot = removeHelper(root, val);\n}\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? removeHelper(TreeNode? node, int val) {\nif (node == null) return null;\n/* 1. \u67e5\u627e\u8282\u70b9\uff0c\u5e76\u5220\u9664\u4e4b */\nif (val < node.val)\nnode.left = removeHelper(node.left, val);\nelse if (val > node.val)\nnode.right = removeHelper(node.right, val);\nelse {\nif (node.left == null || node.right == null) {\nTreeNode? child = node.left ?? node.right;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\nif (child == null)\nreturn null;\n// \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\nelse\nnode = child;\n} else {\n// \u5b50\u8282\u70b9\u6570\u91cf = 2 \uff0c\u5219\u5c06\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\u5220\u9664\uff0c\u5e76\u7528\u8be5\u8282\u70b9\u66ff\u6362\u5f53\u524d\u8282\u70b9\nTreeNode? temp = node.right;\nwhile (temp!.left != null) {\ntemp = temp.left;\n}\nnode.right = removeHelper(node.right, temp.val);\nnode.val = temp.val;\n}\n}\nupdateHeight(node); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n/* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nnode = rotate(node);\n// \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\nreturn node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#_10","title":"\u67e5\u627e\u8282\u70b9","text":"

    AVL \u6811\u7684\u8282\u70b9\u67e5\u627e\u64cd\u4f5c\u4e0e\u4e8c\u53c9\u641c\u7d22\u6811\u4e00\u81f4\uff0c\u5728\u6b64\u4e0d\u518d\u8d58\u8ff0\u3002

    "},{"location":"chapter_tree/avl_tree/#754-avl","title":"7.5.4. \u00a0 AVL \u6811\u5178\u578b\u5e94\u7528","text":"
    • \u7ec4\u7ec7\u548c\u5b58\u50a8\u5927\u578b\u6570\u636e\uff0c\u9002\u7528\u4e8e\u9ad8\u9891\u67e5\u627e\u3001\u4f4e\u9891\u589e\u5220\u7684\u573a\u666f\uff1b
    • \u7528\u4e8e\u6784\u5efa\u6570\u636e\u5e93\u4e2d\u7684\u7d22\u5f15\u7cfb\u7edf\uff1b

    \u4e3a\u4ec0\u4e48\u7ea2\u9ed1\u6811\u6bd4 AVL \u6811\u66f4\u53d7\u6b22\u8fce\uff1f

    \u7ea2\u9ed1\u6811\u7684\u5e73\u8861\u6761\u4ef6\u76f8\u5bf9\u5bbd\u677e\uff0c\u56e0\u6b64\u5728\u7ea2\u9ed1\u6811\u4e2d\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u6240\u9700\u7684\u65cb\u8f6c\u64cd\u4f5c\u76f8\u5bf9\u8f83\u5c11\uff0c\u5728\u8282\u70b9\u589e\u5220\u64cd\u4f5c\u4e0a\u7684\u5e73\u5747\u6548\u7387\u9ad8\u4e8e AVL \u6811\u3002

    "},{"location":"chapter_tree/binary_search_tree/","title":"7.4. \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811","text":"

    \u300c\u4e8c\u53c9\u641c\u7d22\u6811 Binary Search Tree\u300d\u6ee1\u8db3\u4ee5\u4e0b\u6761\u4ef6\uff1a

    1. \u5bf9\u4e8e\u6839\u8282\u70b9\uff0c\u5de6\u5b50\u6811\u4e2d\u6240\u6709\u8282\u70b9\u7684\u503c \\(<\\) \u6839\u8282\u70b9\u7684\u503c \\(<\\) \u53f3\u5b50\u6811\u4e2d\u6240\u6709\u8282\u70b9\u7684\u503c\uff1b
    2. \u4efb\u610f\u8282\u70b9\u7684\u5de6\u3001\u53f3\u5b50\u6811\u4e5f\u662f\u4e8c\u53c9\u641c\u7d22\u6811\uff0c\u5373\u540c\u6837\u6ee1\u8db3\u6761\u4ef6 1. \uff1b

    Fig. \u4e8c\u53c9\u641c\u7d22\u6811

    "},{"location":"chapter_tree/binary_search_tree/#741","title":"7.4.1. \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u64cd\u4f5c","text":""},{"location":"chapter_tree/binary_search_tree/#_1","title":"\u67e5\u627e\u8282\u70b9","text":"

    \u7ed9\u5b9a\u76ee\u6807\u8282\u70b9\u503c num \uff0c\u53ef\u4ee5\u6839\u636e\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u6027\u8d28\u6765\u67e5\u627e\u3002\u6211\u4eec\u58f0\u660e\u4e00\u4e2a\u8282\u70b9 cur \uff0c\u4ece\u4e8c\u53c9\u6811\u7684\u6839\u8282\u70b9 root \u51fa\u53d1\uff0c\u5faa\u73af\u6bd4\u8f83\u8282\u70b9\u503c cur.val \u548c num \u4e4b\u95f4\u7684\u5927\u5c0f\u5173\u7cfb

    • \u82e5 cur.val < num \uff0c\u8bf4\u660e\u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\uff0c\u56e0\u6b64\u6267\u884c cur = cur.right \uff1b
    • \u82e5 cur.val > num \uff0c\u8bf4\u660e\u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\uff0c\u56e0\u6b64\u6267\u884c cur = cur.left \uff1b
    • \u82e5 cur.val = num \uff0c\u8bf4\u660e\u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\u5e76\u8fd4\u56de\u8be5\u8282\u70b9\uff1b
    <1><2><3><4>

    \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u67e5\u627e\u64cd\u4f5c\u4e0e\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u7684\u5de5\u4f5c\u539f\u7406\u4e00\u81f4\uff0c\u90fd\u662f\u6bcf\u8f6e\u6392\u9664\u4e00\u534a\u60c5\u51b5\u3002\u5faa\u73af\u6b21\u6570\u6700\u591a\u4e3a\u4e8c\u53c9\u6811\u7684\u9ad8\u5ea6\uff0c\u5f53\u4e8c\u53c9\u6811\u5e73\u8861\u65f6\uff0c\u4f7f\u7528 \\(O(\\log n)\\) \u65f6\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search_tree.java
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode search(int num) {\nTreeNode cur = root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num)\ncur = cur.right;\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse if (cur.val > num)\ncur = cur.left;\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse\nbreak;\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.cpp
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode *search(int num) {\nTreeNode *cur = root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != nullptr) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur->val < num)\ncur = cur->right;\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse if (cur->val > num)\ncur = cur->left;\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse\nbreak;\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.py
    def search(self, num: int) -> TreeNode | None:\n\"\"\"\u67e5\u627e\u8282\u70b9\"\"\"\ncur: TreeNode | None = self.root\n# \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile cur is not None:\n# \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur.val < num:\ncur = cur.right\n# \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelif cur.val > num:\ncur = cur.left\n# \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse:\nbreak\nreturn cur\n
    binary_search_tree.go
    /* \u67e5\u627e\u8282\u70b9 */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\nnode := bst.root\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nfor node != nil {\nif node.Val < num {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nnode = node.Right\n} else if node.Val > num {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nnode = node.Left\n} else {\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nbreak\n}\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn node\n}\n
    binary_search_tree.js
    /* \u67e5\u627e\u8282\u70b9 */\nfunction search(num) {\nlet cur = root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num) cur = cur.right;\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse if (cur.val > num) cur = cur.left;\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse break;\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.ts
    /* \u67e5\u627e\u8282\u70b9 */\nfunction search(num: number): TreeNode | null {\nlet cur = root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\nif (cur.val < num) {\ncur = cur.right; // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n} else if (cur.val > num) {\ncur = cur.left; // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n} else {\nbreak; // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n}\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.c
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode *search(binarySearchTree *bst, int num) {\nTreeNode *cur = bst->root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != NULL) {\nif (cur->val < num) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\ncur = cur->right;\n} else if (cur->val > num) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\ncur = cur->left;\n} else {\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nbreak;\n}\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.cs
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode? search(int num) {\nTreeNode? cur = root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num) cur =\ncur.right;\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse if (cur.val > num)\ncur = cur.left;\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse\nbreak;\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.swift
    /* \u67e5\u627e\u8282\u70b9 */\nfunc search(num: Int) -> TreeNode? {\nvar cur = root\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile cur != nil {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur!.val < num {\ncur = cur?.right\n}\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse if cur!.val > num {\ncur = cur?.left\n}\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nelse {\nbreak\n}\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur\n}\n
    binary_search_tree.zig
    // \u67e5\u627e\u8282\u70b9\nfn search(self: *Self, num: T) ?*inc.TreeNode(T) {\nvar cur = self.root;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.?.val < num) {\ncur = cur.?.right;\n// \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n} else if (cur.?.val > num) {\ncur = cur.?.left;\n// \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n} else {\nbreak;\n}\n}\n// \u8fd4\u56de\u76ee\u6807\u8282\u70b9\nreturn cur;\n}\n
    binary_search_tree.dart
    [class]{BinarySearchTree}-[func]{search}\n
    "},{"location":"chapter_tree/binary_search_tree/#_2","title":"\u63d2\u5165\u8282\u70b9","text":"

    \u7ed9\u5b9a\u4e00\u4e2a\u5f85\u63d2\u5165\u5143\u7d20 num \uff0c\u4e3a\u4e86\u4fdd\u6301\u4e8c\u53c9\u641c\u7d22\u6811\u201c\u5de6\u5b50\u6811 < \u6839\u8282\u70b9 < \u53f3\u5b50\u6811\u201d\u7684\u6027\u8d28\uff0c\u63d2\u5165\u64cd\u4f5c\u5206\u4e3a\u4e24\u6b65\uff1a

    1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\uff1a\u4e0e\u67e5\u627e\u64cd\u4f5c\u76f8\u4f3c\uff0c\u4ece\u6839\u8282\u70b9\u51fa\u53d1\uff0c\u6839\u636e\u5f53\u524d\u8282\u70b9\u503c\u548c num \u7684\u5927\u5c0f\u5173\u7cfb\u5faa\u73af\u5411\u4e0b\u641c\u7d22\uff0c\u76f4\u5230\u8d8a\u8fc7\u53f6\u8282\u70b9\uff08\u904d\u5386\u81f3 \\(\\text{None}\\) \uff09\u65f6\u8df3\u51fa\u5faa\u73af\uff1b
    2. \u5728\u8be5\u4f4d\u7f6e\u63d2\u5165\u8282\u70b9\uff1a\u521d\u59cb\u5316\u8282\u70b9 num \uff0c\u5c06\u8be5\u8282\u70b9\u7f6e\u4e8e \\(\\text{None}\\) \u7684\u4f4d\u7f6e\uff1b

    \u4e8c\u53c9\u641c\u7d22\u6811\u4e0d\u5141\u8bb8\u5b58\u5728\u91cd\u590d\u8282\u70b9\uff0c\u5426\u5219\u5c06\u8fdd\u53cd\u5176\u5b9a\u4e49\u3002\u56e0\u6b64\uff0c\u82e5\u5f85\u63d2\u5165\u8282\u70b9\u5728\u6811\u4e2d\u5df2\u5b58\u5728\uff0c\u5219\u4e0d\u6267\u884c\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\u3002

    Fig. \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u63d2\u5165\u8282\u70b9

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search_tree.java
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == null)\nreturn;\nTreeNode cur = root, pre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur.val == num)\nreturn;\npre = cur;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num)\ncur = cur.right;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur.left;\n}\n// \u63d2\u5165\u8282\u70b9\nTreeNode node = new TreeNode(num);\nif (pre.val < num)\npre.right = node;\nelse\npre.left = node;\n}\n
    binary_search_tree.cpp
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == nullptr)\nreturn;\nTreeNode *cur = root, *pre = nullptr;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != nullptr) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur->val == num)\nreturn;\npre = cur;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur->val < num)\ncur = cur->right;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur->left;\n}\n// \u63d2\u5165\u8282\u70b9\nTreeNode *node = new TreeNode(num);\nif (pre->val < num)\npre->right = node;\nelse\npre->left = node;\n}\n
    binary_search_tree.py
    def insert(self, num: int) -> None:\n\"\"\"\u63d2\u5165\u8282\u70b9\"\"\"\n# \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif self.root is None:\nreturn\n# \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\ncur, pre = self.root, None\nwhile cur is not None:\n# \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif cur.val == num:\nreturn\npre = cur\n# \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur.val < num:\ncur = cur.right\n# \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse:\ncur = cur.left\n# \u63d2\u5165\u8282\u70b9\nnode = TreeNode(num)\nif pre.val < num:\npre.right = node\nelse:\npre.left = node\n
    binary_search_tree.go
    /* \u63d2\u5165\u8282\u70b9 */\nfunc (bst *binarySearchTree) insert(num int) {\ncur := bst.root\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif cur == nil {\nreturn\n}\n// \u5f85\u63d2\u5165\u8282\u70b9\u4e4b\u524d\u7684\u8282\u70b9\u4f4d\u7f6e\nvar pre *TreeNode = nil\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nfor cur != nil {\nif cur.Val == num {\nreturn\n}\npre = cur\nif cur.Val < num {\ncur = cur.Right\n} else {\ncur = cur.Left\n}\n}\n// \u63d2\u5165\u8282\u70b9\nnode := NewTreeNode(num)\nif pre.Val < num {\npre.Right = node\n} else {\npre.Left = node\n}\n}\n
    binary_search_tree.js
    /* \u63d2\u5165\u8282\u70b9 */\nfunction insert(num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root === null) return;\nlet cur = root,\npre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur.val === num) return;\npre = cur;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num) cur = cur.right;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse cur = cur.left;\n}\n// \u63d2\u5165\u8282\u70b9\nlet node = new TreeNode(num);\nif (pre.val < num) pre.right = node;\nelse pre.left = node;\n}\n
    binary_search_tree.ts
    /* \u63d2\u5165\u8282\u70b9 */\nfunction insert(num: number): void {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root === null) {\nreturn;\n}\nlet cur = root,\npre: TreeNode | null = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\nif (cur.val === num) {\nreturn; // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n}\npre = cur;\nif (cur.val < num) {\ncur = cur.right as TreeNode; // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n} else {\ncur = cur.left as TreeNode; // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n}\n}\n// \u63d2\u5165\u8282\u70b9\nlet node = new TreeNode(num);\nif (pre!.val < num) {\npre!.right = node;\n} else {\npre!.left = node;\n}\n}\n
    binary_search_tree.c
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(binarySearchTree *bst, int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (bst->root == NULL)\nreturn;\nTreeNode *cur = bst->root, *pre = NULL;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != NULL) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur->val == num) {\nreturn;\n}\npre = cur;\nif (cur->val < num) {\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\ncur = cur->right;\n} else {\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\ncur = cur->left;\n}\n}\n// \u63d2\u5165\u8282\u70b9\nTreeNode *node = newTreeNode(num);\nif (pre->val < num) {\npre->right = node;\n} else {\npre->left = node;\n}\n}\n
    binary_search_tree.cs
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == null)\nreturn;\nTreeNode? cur = root, pre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur.val == num)\nreturn;\npre = cur;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num)\ncur = cur.right;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur.left;\n}\n// \u63d2\u5165\u8282\u70b9\nTreeNode node = new TreeNode(num);\nif (pre != null) {\nif (pre.val < num)\npre.right = node;\nelse\npre.left = node;\n}\n}\n
    binary_search_tree.swift
    /* \u63d2\u5165\u8282\u70b9 */\nfunc insert(num: Int) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif root == nil {\nreturn\n}\nvar cur = root\nvar pre: TreeNode?\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile cur != nil {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif cur!.val == num {\nreturn\n}\npre = cur\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur!.val < num {\ncur = cur?.right\n}\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse {\ncur = cur?.left\n}\n}\n// \u63d2\u5165\u8282\u70b9\nlet node = TreeNode(x: num)\nif pre!.val < num {\npre?.right = node\n} else {\npre?.left = node\n}\n}\n
    binary_search_tree.zig
    // \u63d2\u5165\u8282\u70b9\nfn insert(self: *Self, num: T) !void {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (self.root == null) return;\nvar cur = self.root;\nvar pre: ?*inc.TreeNode(T) = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\nif (cur.?.val == num) return;\npre = cur;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.?.val < num) {\ncur = cur.?.right;\n// \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n} else {\ncur = cur.?.left;\n}\n}\n// \u63d2\u5165\u8282\u70b9\nvar node = try self.mem_allocator.create(inc.TreeNode(T));\nnode.init(num);\nif (pre.?.val < num) {\npre.?.right = node;\n} else {\npre.?.left = node;\n}\n}\n
    binary_search_tree.dart
    [class]{BinarySearchTree}-[func]{insert}\n

    \u4e3a\u4e86\u63d2\u5165\u8282\u70b9\uff0c\u6211\u4eec\u9700\u8981\u5229\u7528\u8f85\u52a9\u8282\u70b9 pre \u4fdd\u5b58\u4e0a\u4e00\u8f6e\u5faa\u73af\u7684\u8282\u70b9\uff0c\u8fd9\u6837\u5728\u904d\u5386\u81f3 \\(\\text{None}\\) \u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u83b7\u53d6\u5230\u5176\u7236\u8282\u70b9\uff0c\u4ece\u800c\u5b8c\u6210\u8282\u70b9\u63d2\u5165\u64cd\u4f5c\u3002

    \u4e0e\u67e5\u627e\u8282\u70b9\u76f8\u540c\uff0c\u63d2\u5165\u8282\u70b9\u4f7f\u7528 \\(O(\\log n)\\) \u65f6\u95f4\u3002

    "},{"location":"chapter_tree/binary_search_tree/#_3","title":"\u5220\u9664\u8282\u70b9","text":"

    \u4e0e\u63d2\u5165\u8282\u70b9\u7c7b\u4f3c\uff0c\u6211\u4eec\u9700\u8981\u5728\u5220\u9664\u64cd\u4f5c\u540e\u7ef4\u6301\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u201c\u5de6\u5b50\u6811 < \u6839\u8282\u70b9 < \u53f3\u5b50\u6811\u201d\u7684\u6027\u8d28\u3002\u9996\u5148\uff0c\u6211\u4eec\u9700\u8981\u5728\u4e8c\u53c9\u6811\u4e2d\u6267\u884c\u67e5\u627e\u64cd\u4f5c\uff0c\u83b7\u53d6\u5f85\u5220\u9664\u8282\u70b9\u3002\u63a5\u4e0b\u6765\uff0c\u6839\u636e\u5f85\u5220\u9664\u8282\u70b9\u7684\u5b50\u8282\u70b9\u6570\u91cf\uff0c\u5220\u9664\u64cd\u4f5c\u9700\u5206\u4e3a\u4e09\u79cd\u60c5\u51b5\uff1a

    \u5f53\u5f85\u5220\u9664\u8282\u70b9\u7684\u5ea6\u4e3a \\(0\\) \u65f6\uff0c\u8868\u793a\u5f85\u5220\u9664\u8282\u70b9\u662f\u53f6\u8282\u70b9\uff0c\u53ef\u4ee5\u76f4\u63a5\u5220\u9664\u3002

    Fig. \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u5220\u9664\u8282\u70b9\uff08\u5ea6\u4e3a 0\uff09

    \u5f53\u5f85\u5220\u9664\u8282\u70b9\u7684\u5ea6\u4e3a \\(1\\) \u65f6\uff0c\u5c06\u5f85\u5220\u9664\u8282\u70b9\u66ff\u6362\u4e3a\u5176\u5b50\u8282\u70b9\u5373\u53ef\u3002

    Fig. \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u5220\u9664\u8282\u70b9\uff08\u5ea6\u4e3a 1\uff09

    \u5f53\u5f85\u5220\u9664\u8282\u70b9\u7684\u5ea6\u4e3a \\(2\\) \u65f6\uff0c\u6211\u4eec\u65e0\u6cd5\u76f4\u63a5\u5220\u9664\u5b83\uff0c\u800c\u9700\u8981\u4f7f\u7528\u4e00\u4e2a\u8282\u70b9\u66ff\u6362\u8be5\u8282\u70b9\u3002\u7531\u4e8e\u8981\u4fdd\u6301\u4e8c\u53c9\u641c\u7d22\u6811\u201c\u5de6 \\(<\\) \u6839 \\(<\\) \u53f3\u201d\u7684\u6027\u8d28\uff0c\u56e0\u6b64\u8fd9\u4e2a\u8282\u70b9\u53ef\u4ee5\u662f\u53f3\u5b50\u6811\u7684\u6700\u5c0f\u8282\u70b9\u6216\u5de6\u5b50\u6811\u7684\u6700\u5927\u8282\u70b9\u3002\u5047\u8bbe\u6211\u4eec\u9009\u62e9\u53f3\u5b50\u6811\u7684\u6700\u5c0f\u8282\u70b9\uff08\u6216\u8005\u79f0\u4e3a\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e2a\u8282\u70b9\uff09\uff0c\u5219\u5220\u9664\u64cd\u4f5c\u4e3a\uff1a

    1. \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\u5728\u201c\u4e2d\u5e8f\u904d\u5386\u5e8f\u5217\u201d\u4e2d\u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\uff0c\u8bb0\u4e3a tmp \uff1b
    2. \u5c06 tmp \u7684\u503c\u8986\u76d6\u5f85\u5220\u9664\u8282\u70b9\u7684\u503c\uff0c\u5e76\u5728\u6811\u4e2d\u9012\u5f52\u5220\u9664\u8282\u70b9 tmp \uff1b
    <1><2><3><4>

    \u5220\u9664\u8282\u70b9\u64cd\u4f5c\u540c\u6837\u4f7f\u7528 \\(O(\\log n)\\) \u65f6\u95f4\uff0c\u5176\u4e2d\u67e5\u627e\u5f85\u5220\u9664\u8282\u70b9\u9700\u8981 \\(O(\\log n)\\) \u65f6\u95f4\uff0c\u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u540e\u7ee7\u8282\u70b9\u9700\u8981 \\(O(\\log n)\\) \u65f6\u95f4\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_search_tree.java
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == null)\nreturn;\nTreeNode cur = root, pre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur.val == num)\nbreak;\npre = cur;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num)\ncur = cur.right;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur.left;\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur == null)\nreturn;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur.left == null || cur.right == null) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nTreeNode child = cur.left != null ? cur.left : cur.right;\n// \u5220\u9664\u8282\u70b9 cur\nif (cur != root) {\nif (pre.left == cur)\npre.left = child;\nelse\npre.right = child;\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child;\n}\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nTreeNode tmp = cur.right;\nwhile (tmp.left != null) {\ntmp = tmp.left;\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(tmp.val);\n// \u7528 tmp \u8986\u76d6 cur\ncur.val = tmp.val;\n}\n}\n
    binary_search_tree.cpp
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == nullptr)\nreturn;\nTreeNode *cur = root, *pre = nullptr;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != nullptr) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur->val == num)\nbreak;\npre = cur;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur->val < num)\ncur = cur->right;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur->left;\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur == nullptr)\nreturn;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur->left == nullptr || cur->right == nullptr) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = nullptr / \u8be5\u5b50\u8282\u70b9\nTreeNode *child = cur->left != nullptr ? cur->left : cur->right;\n// \u5220\u9664\u8282\u70b9 cur\nif (cur != root) {\nif (pre->left == cur)\npre->left = child;\nelse\npre->right = child;\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child;\n}\n// \u91ca\u653e\u5185\u5b58\ndelete cur;\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nTreeNode *tmp = cur->right;\nwhile (tmp->left != nullptr) {\ntmp = tmp->left;\n}\nint tmpVal = tmp->val;\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(tmp->val);\n// \u7528 tmp \u8986\u76d6 cur\ncur->val = tmpVal;\n}\n}\n
    binary_search_tree.py
    def remove(self, num: int) -> None:\n\"\"\"\u5220\u9664\u8282\u70b9\"\"\"\n# \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif self.root is None:\nreturn\n# \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\ncur, pre = self.root, None\nwhile cur is not None:\n# \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif cur.val == num:\nbreak\npre = cur\n# \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur.val < num:\ncur = cur.right\n# \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse:\ncur = cur.left\n# \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif cur is None:\nreturn\n# \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif cur.left is None or cur.right is None:\n# \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nchild = cur.left or cur.right\n# \u5220\u9664\u8282\u70b9 cur\nif cur != self.root:\nif pre.left == cur:\npre.left = child\nelse:\npre.right = child\nelse:\n# \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nself.root = child\n# \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse:\n# \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\ntmp: TreeNode = cur.right\nwhile tmp.left is not None:\ntmp = tmp.left\n# \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nself.remove(tmp.val)\n# \u7528 tmp \u8986\u76d6 cur\ncur.val = tmp.val\n
    binary_search_tree.go
    /* \u5220\u9664\u8282\u70b9 */\nfunc (bst *binarySearchTree) remove(num int) {\ncur := bst.root\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif cur == nil {\nreturn\n}\n// \u5f85\u5220\u9664\u8282\u70b9\u4e4b\u524d\u7684\u8282\u70b9\u4f4d\u7f6e\nvar pre *TreeNode = nil\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nfor cur != nil {\nif cur.Val == num {\nbreak\n}\npre = cur\nif cur.Val < num {\n// \u5f85\u5220\u9664\u8282\u70b9\u5728\u53f3\u5b50\u6811\u4e2d\ncur = cur.Right\n} else {\n// \u5f85\u5220\u9664\u8282\u70b9\u5728\u5de6\u5b50\u6811\u4e2d\ncur = cur.Left\n}\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif cur == nil {\nreturn\n}\n// \u5b50\u8282\u70b9\u6570\u4e3a 0 \u6216 1\nif cur.Left == nil || cur.Right == nil {\nvar child *TreeNode = nil\n// \u53d6\u51fa\u5f85\u5220\u9664\u8282\u70b9\u7684\u5b50\u8282\u70b9\nif cur.Left != nil {\nchild = cur.Left\n} else {\nchild = cur.Right\n}\n// \u5220\u9664\u8282\u70b9 cur\nif cur != bst.root {\nif pre.Left == cur {\npre.Left = child\n} else {\npre.Right = child\n}\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nbst.root = child\n}\n// \u5b50\u8282\u70b9\u6570\u4e3a 2\n} else {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d\u5f85\u5220\u9664\u8282\u70b9 cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\ntmp := cur.Right\nfor tmp.Left != nil {\ntmp = tmp.Left\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nbst.remove(tmp.Val)\n// \u7528 tmp \u8986\u76d6 cur\ncur.Val = tmp.Val\n}\n}\n
    binary_search_tree.js
    /* \u5220\u9664\u8282\u70b9 */\nfunction remove(num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root === null) return;\nlet cur = root,\npre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur.val === num) break;\npre = cur;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num) cur = cur.right;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse cur = cur.left;\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur === null) return;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur.left === null || cur.right === null) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nlet child = cur.left !== null ? cur.left : cur.right;\n// \u5220\u9664\u8282\u70b9 cur\nif (cur != root) {\nif (pre.left === cur) pre.left = child;\nelse pre.right = child;\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child;\n}\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nlet tmp = cur.right;\nwhile (tmp.left !== null) {\ntmp = tmp.left;\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(tmp.val);\n// \u7528 tmp \u8986\u76d6 cur\ncur.val = tmp.val;\n}\n}\n
    binary_search_tree.ts
    /* \u5220\u9664\u8282\u70b9 */\nfunction remove(num: number): void {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root === null) {\nreturn;\n}\nlet cur = root,\npre: TreeNode | null = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur !== null) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur.val === num) {\nbreak;\n}\npre = cur;\nif (cur.val < num) {\ncur = cur.right as TreeNode; // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n} else {\ncur = cur.left as TreeNode; // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n}\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur === null) {\nreturn;\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur.left === null || cur.right === null) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nlet child = cur.left !== null ? cur.left : cur.right;\n// \u5220\u9664\u8282\u70b9 cur\nif (cur != root) {\nif (pre!.left === cur) {\npre!.left = child;\n} else {\npre!.right = child;\n}\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child;\n}\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nlet tmp = cur.right;\nwhile (tmp.left !== null) {\ntmp = tmp.left;\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(tmp!.val);\n// \u7528 tmp \u8986\u76d6 cur\ncur.val = tmp.val;\n}\n}\n
    binary_search_tree.c
    /* \u5220\u9664\u8282\u70b9 */\n// \u7531\u4e8e\u5f15\u5165\u4e86 stdio.h \uff0c\u6b64\u5904\u65e0\u6cd5\u4f7f\u7528 remove \u5173\u952e\u8bcd\nvoid removeNode(binarySearchTree *bst, int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (bst->root == NULL)\nreturn;\nTreeNode *cur = bst->root, *pre = NULL;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != NULL) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur->val == num)\nbreak;\npre = cur;\nif (cur->val < num) {\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 root \u7684\u53f3\u5b50\u6811\u4e2d\ncur = cur->right;\n} else {\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 root \u7684\u5de6\u5b50\u6811\u4e2d\ncur = cur->left;\n}\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur == NULL)\nreturn;\n// \u5224\u65ad\u5f85\u5220\u9664\u8282\u70b9\u662f\u5426\u5b58\u5728\u5b50\u8282\u70b9\nif (cur->left == NULL || cur->right == NULL) {\n/* \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1 */\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = nullptr / \u8be5\u5b50\u8282\u70b9\nTreeNode *child = cur->left != NULL ? cur->left : cur->right;\n// \u5220\u9664\u8282\u70b9 cur\nif (pre->left == cur) {\npre->left = child;\n} else {\npre->right = child;\n}\n} else {\n/* \u5b50\u8282\u70b9\u6570\u91cf = 2 */\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nTreeNode *tmp = cur->right;\nwhile (tmp->left != NULL) {\ntmp = tmp->left;\n}\nint tmpVal = tmp->val;\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremoveNode(bst, tmp->val);\n// \u7528 tmp \u8986\u76d6 cur\ncur->val = tmpVal;\n}\n}\n
    binary_search_tree.cs
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int num) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (root == null)\nreturn;\nTreeNode? cur = root, pre = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur.val == num)\nbreak;\npre = cur;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.val < num)\ncur = cur.right;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse\ncur = cur.left;\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur == null || pre == null)\nreturn;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur.left == null || cur.right == null) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nTreeNode? child = cur.left != null ? cur.left : cur.right;\n// \u5220\u9664\u8282\u70b9 cur\nif (cur != root) {\nif (pre.left == cur)\npre.left = child;\nelse\npre.right = child;\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child;\n}\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nTreeNode? tmp = cur.right;\nwhile (tmp.left != null) {\ntmp = tmp.left;\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(tmp.val);\n// \u7528 tmp \u8986\u76d6 cur\ncur.val = tmp.val;\n}\n}\n
    binary_search_tree.swift
    /* \u5220\u9664\u8282\u70b9 */\n@discardableResult\nfunc remove(num: Int) {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif root == nil {\nreturn\n}\nvar cur = root\nvar pre: TreeNode?\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile cur != nil {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif cur!.val == num {\nbreak\n}\npre = cur\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif cur!.val < num {\ncur = cur?.right\n}\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\nelse {\ncur = cur?.left\n}\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif cur == nil {\nreturn\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif cur?.left == nil || cur?.right == nil {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nlet child = cur?.left != nil ? cur?.left : cur?.right\n// \u5220\u9664\u8282\u70b9 cur\nif cur !== root {\nif pre?.left === cur {\npre?.left = child\n} else {\npre?.right = child\n}\n} else {\n// \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\nroot = child\n}\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\nelse {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nvar tmp = cur?.right\nwhile tmp?.left != nil {\ntmp = tmp?.left\n}\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nremove(num: tmp!.val)\n// \u7528 tmp \u8986\u76d6 cur\ncur?.val = tmp!.val\n}\n}\n
    binary_search_tree.zig
    // \u5220\u9664\u8282\u70b9\nfn remove(self: *Self, num: T) void {\n// \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\nif (self.root == null) return;\nvar cur = self.root;\nvar pre: ?*inc.TreeNode(T) = null;\n// \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\nwhile (cur != null) {\n// \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\nif (cur.?.val == num) break;\npre = cur;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\nif (cur.?.val < num) {\ncur = cur.?.right;\n// \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n} else {\ncur = cur.?.left;\n}\n}\n// \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\nif (cur == null) return;\n// \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\nif (cur.?.left == null or cur.?.right == null) {\n// \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\nvar child = if (cur.?.left != null) cur.?.left else cur.?.right;\n// \u5220\u9664\u8282\u70b9 cur\nif (pre.?.left == cur) {\npre.?.left = child;\n} else {\npre.?.right = child;\n}\n// \u5b50\u8282\u70b9\u6570\u91cf = 2\n} else {\n// \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\nvar tmp = cur.?.right;\nwhile (tmp.?.left != null) {\ntmp = tmp.?.left;\n}\nvar tmp_val = tmp.?.val;\n// \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\nself.remove(tmp.?.val);\n// \u7528 tmp \u8986\u76d6 cur\ncur.?.val = tmp_val;\n}\n}\n
    binary_search_tree.dart
    [class]{BinarySearchTree}-[func]{remove}\n
    "},{"location":"chapter_tree/binary_search_tree/#_4","title":"\u6392\u5e8f","text":"

    \u6211\u4eec\u77e5\u9053\uff0c\u4e8c\u53c9\u6811\u7684\u4e2d\u5e8f\u904d\u5386\u9075\u5faa\u201c\u5de6 \\(\\rightarrow\\) \u6839 \\(\\rightarrow\\) \u53f3\u201d\u7684\u904d\u5386\u987a\u5e8f\uff0c\u800c\u4e8c\u53c9\u641c\u7d22\u6811\u6ee1\u8db3\u201c\u5de6\u5b50\u8282\u70b9 \\(<\\) \u6839\u8282\u70b9 \\(<\\) \u53f3\u5b50\u8282\u70b9\u201d\u7684\u5927\u5c0f\u5173\u7cfb\u3002\u56e0\u6b64\uff0c\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u8fdb\u884c\u4e2d\u5e8f\u904d\u5386\u65f6\uff0c\u603b\u662f\u4f1a\u4f18\u5148\u904d\u5386\u4e0b\u4e00\u4e2a\u6700\u5c0f\u8282\u70b9\uff0c\u4ece\u800c\u5f97\u51fa\u4e00\u4e2a\u91cd\u8981\u6027\u8d28\uff1a\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u4e2d\u5e8f\u904d\u5386\u5e8f\u5217\u662f\u5347\u5e8f\u7684\u3002

    \u5229\u7528\u4e2d\u5e8f\u904d\u5386\u5347\u5e8f\u7684\u6027\u8d28\uff0c\u6211\u4eec\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u83b7\u53d6\u6709\u5e8f\u6570\u636e\u4ec5\u9700 \\(O(n)\\) \u65f6\u95f4\uff0c\u65e0\u9700\u989d\u5916\u6392\u5e8f\uff0c\u975e\u5e38\u9ad8\u6548\u3002

    Fig. \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u4e2d\u5e8f\u904d\u5386\u5e8f\u5217

    "},{"location":"chapter_tree/binary_search_tree/#742","title":"7.4.2. \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u6548\u7387","text":"

    \u7ed9\u5b9a\u4e00\u7ec4\u6570\u636e\uff0c\u6211\u4eec\u8003\u8651\u4f7f\u7528\u6570\u7ec4\u6216\u4e8c\u53c9\u641c\u7d22\u6811\u5b58\u50a8\u3002

    \u89c2\u5bdf\u53ef\u77e5\uff0c\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u5404\u9879\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u662f\u5bf9\u6570\u9636\uff0c\u5177\u6709\u7a33\u5b9a\u4e14\u9ad8\u6548\u7684\u6027\u80fd\u8868\u73b0\u3002\u53ea\u6709\u5728\u9ad8\u9891\u6dfb\u52a0\u3001\u4f4e\u9891\u67e5\u627e\u5220\u9664\u7684\u6570\u636e\u9002\u7528\u573a\u666f\u4e0b\uff0c\u6570\u7ec4\u6bd4\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u6548\u7387\u66f4\u9ad8\u3002

    \u65e0\u5e8f\u6570\u7ec4 \u4e8c\u53c9\u641c\u7d22\u6811 \u67e5\u627e\u5143\u7d20 \\(O(n)\\) \\(O(\\log n)\\) \u63d2\u5165\u5143\u7d20 \\(O(1)\\) \\(O(\\log n)\\) \u5220\u9664\u5143\u7d20 \\(O(n)\\) \\(O(\\log n)\\)

    \u5728\u7406\u60f3\u60c5\u51b5\u4e0b\uff0c\u4e8c\u53c9\u641c\u7d22\u6811\u662f\u201c\u5e73\u8861\u201d\u7684\uff0c\u8fd9\u6837\u5c31\u53ef\u4ee5\u5728 \\(\\log n\\) \u8f6e\u5faa\u73af\u5185\u67e5\u627e\u4efb\u610f\u8282\u70b9\u3002

    \u7136\u800c\uff0c\u5982\u679c\u6211\u4eec\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u4e0d\u65ad\u5730\u63d2\u5165\u548c\u5220\u9664\u8282\u70b9\uff0c\u53ef\u80fd\u5bfc\u81f4\u4e8c\u53c9\u6811\u9000\u5316\u4e3a\u94fe\u8868\uff0c\u8fd9\u65f6\u5404\u79cd\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e5f\u4f1a\u9000\u5316\u4e3a \\(O(n)\\) \u3002

    Fig. \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u5e73\u8861\u4e0e\u9000\u5316

    "},{"location":"chapter_tree/binary_search_tree/#743","title":"7.4.3. \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\u5e38\u89c1\u5e94\u7528","text":"
    • \u7528\u4f5c\u7cfb\u7edf\u4e2d\u7684\u591a\u7ea7\u7d22\u5f15\uff0c\u5b9e\u73b0\u9ad8\u6548\u7684\u67e5\u627e\u3001\u63d2\u5165\u3001\u5220\u9664\u64cd\u4f5c\u3002
    • \u4f5c\u4e3a\u67d0\u4e9b\u641c\u7d22\u7b97\u6cd5\u7684\u5e95\u5c42\u6570\u636e\u7ed3\u6784\u3002
    • \u7528\u4e8e\u5b58\u50a8\u6570\u636e\u6d41\uff0c\u4ee5\u4fdd\u6301\u5176\u6709\u5e8f\u72b6\u6001\u3002
    "},{"location":"chapter_tree/binary_tree/","title":"7.1. \u00a0 \u4e8c\u53c9\u6811","text":"

    \u300c\u4e8c\u53c9\u6811 Binary Tree\u300d\u662f\u4e00\u79cd\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u4ee3\u8868\u7740\u7956\u5148\u4e0e\u540e\u4ee3\u4e4b\u95f4\u7684\u6d3e\u751f\u5173\u7cfb\uff0c\u4f53\u73b0\u7740\u201c\u4e00\u5206\u4e3a\u4e8c\u201d\u7684\u5206\u6cbb\u903b\u8f91\u3002\u4e0e\u94fe\u8868\u7c7b\u4f3c\uff0c\u4e8c\u53c9\u6811\u7684\u57fa\u672c\u5355\u5143\u662f\u8282\u70b9\uff0c\u6bcf\u4e2a\u8282\u70b9\u5305\u542b\u4e00\u4e2a\u300c\u503c\u300d\u548c\u4e24\u4e2a\u300c\u6307\u9488\u300d\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart 
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nint val;         // \u8282\u70b9\u503c\nTreeNode left;   // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nTreeNode right;  // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nTreeNode(int x) { val = x; }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\nint val;          // \u8282\u70b9\u503c\nTreeNode *left;   // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nTreeNode *right;  // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nTreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n
    class TreeNode:\n\"\"\"\u4e8c\u53c9\u6811\u8282\u70b9\u7c7b\"\"\"\ndef __init__(self, val: int):\nself.val: int = val                   # \u8282\u70b9\u503c\nself.left: Optional[TreeNode] = None  # \u5de6\u5b50\u8282\u70b9\u6307\u9488\nself.right: Optional[TreeNode] = None # \u53f3\u5b50\u8282\u70b9\u6307\u9488\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype TreeNode struct {\nVal   int\nLeft  *TreeNode\nRight *TreeNode\n}\n/* \u8282\u70b9\u521d\u59cb\u5316\u65b9\u6cd5 */\nfunc NewTreeNode(v int) *TreeNode {\nreturn &TreeNode{\nLeft:  nil,\nRight: nil,\nVal:   v,\n}\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nfunction TreeNode(val, left, right) {\nthis.val = (val === undefined ? 0 : val); // \u8282\u70b9\u503c\nthis.left = (left === undefined ? null : left); // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nthis.right = (right === undefined ? null : right); // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nval: number;\nleft: TreeNode | null;\nright: TreeNode | null;\nconstructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\nthis.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\nthis.left = left === undefined ? null : left; // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nthis.right = right === undefined ? null : right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n}\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\nint val;                // \u8282\u70b9\u503c\nint height;             // \u8282\u70b9\u9ad8\u5ea6\nstruct TreeNode *left;  // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nstruct TreeNode *right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n};\ntypedef struct TreeNode TreeNode;\n/* \u6784\u9020\u51fd\u6570 */\nTreeNode *newTreeNode(int val) {\nTreeNode *node;\nnode = (TreeNode *)malloc(sizeof(TreeNode));\nnode->val = val;\nnode->height = 0;\nnode->left = NULL;\nnode->right = NULL;\nreturn node;\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nint val;          // \u8282\u70b9\u503c\nTreeNode? left;   // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nTreeNode? right;  // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nTreeNode(int x) { val = x; }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nvar val: Int // \u8282\u70b9\u503c\nvar left: TreeNode? // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nvar right: TreeNode? // \u53f3\u5b50\u8282\u70b9\u6307\u9488\ninit(x: Int) {\nval = x\n}\n}\n
    \n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\nint val;         // \u8282\u70b9\u503c\nTreeNode? left;  // \u5de6\u5b50\u8282\u70b9\u6307\u9488\nTreeNode? right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\nTreeNode(this.val, [this.left, this.right]);\n}\n

    \u8282\u70b9\u7684\u4e24\u4e2a\u6307\u9488\u5206\u522b\u6307\u5411\u300c\u5de6\u5b50\u8282\u70b9\u300d\u548c\u300c\u53f3\u5b50\u8282\u70b9\u300d\uff0c\u540c\u65f6\u8be5\u8282\u70b9\u88ab\u79f0\u4e3a\u8fd9\u4e24\u4e2a\u5b50\u8282\u70b9\u7684\u300c\u7236\u8282\u70b9\u300d\u3002\u5f53\u7ed9\u5b9a\u4e00\u4e2a\u4e8c\u53c9\u6811\u7684\u8282\u70b9\u65f6\uff0c\u6211\u4eec\u5c06\u8be5\u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u53ca\u5176\u4ee5\u4e0b\u8282\u70b9\u5f62\u6210\u7684\u6811\u79f0\u4e3a\u8be5\u8282\u70b9\u7684\u300c\u5de6\u5b50\u6811\u300d\uff0c\u540c\u7406\u53ef\u5f97\u300c\u53f3\u5b50\u6811\u300d\u3002

    \u5728\u4e8c\u53c9\u6811\u4e2d\uff0c\u9664\u53f6\u8282\u70b9\u5916\uff0c\u5176\u4ed6\u6240\u6709\u8282\u70b9\u90fd\u5305\u542b\u5b50\u8282\u70b9\u548c\u975e\u7a7a\u5b50\u6811\u3002\u4f8b\u5982\uff0c\u5728\u4ee5\u4e0b\u793a\u4f8b\u4e2d\uff0c\u82e5\u5c06\u201c\u8282\u70b9 2\u201d\u89c6\u4e3a\u7236\u8282\u70b9\uff0c\u5219\u5176\u5de6\u5b50\u8282\u70b9\u548c\u53f3\u5b50\u8282\u70b9\u5206\u522b\u662f\u201c\u8282\u70b9 4\u201d\u548c\u201c\u8282\u70b9 5\u201d\uff0c\u5de6\u5b50\u6811\u662f\u201c\u8282\u70b9 4 \u53ca\u5176\u4ee5\u4e0b\u8282\u70b9\u5f62\u6210\u7684\u6811\u201d\uff0c\u53f3\u5b50\u6811\u662f\u201c\u8282\u70b9 5 \u53ca\u5176\u4ee5\u4e0b\u8282\u70b9\u5f62\u6210\u7684\u6811\u201d\u3002

    Fig. \u7236\u8282\u70b9\u3001\u5b50\u8282\u70b9\u3001\u5b50\u6811

    "},{"location":"chapter_tree/binary_tree/#711","title":"7.1.1. \u00a0 \u4e8c\u53c9\u6811\u5e38\u89c1\u672f\u8bed","text":"

    \u4e8c\u53c9\u6811\u6d89\u53ca\u7684\u672f\u8bed\u8f83\u591a\uff0c\u5efa\u8bae\u5c3d\u91cf\u7406\u89e3\u5e76\u8bb0\u4f4f\u3002

    • \u300c\u6839\u8282\u70b9 Root Node\u300d\uff1a\u4f4d\u4e8e\u4e8c\u53c9\u6811\u9876\u5c42\u7684\u8282\u70b9\uff0c\u6ca1\u6709\u7236\u8282\u70b9\uff1b
    • \u300c\u53f6\u8282\u70b9 Leaf Node\u300d\uff1a\u6ca1\u6709\u5b50\u8282\u70b9\u7684\u8282\u70b9\uff0c\u5176\u4e24\u4e2a\u6307\u9488\u5747\u6307\u5411 \\(\\text{None}\\) \uff1b
    • \u8282\u70b9\u7684\u300c\u5c42 Level\u300d\uff1a\u4ece\u9876\u81f3\u5e95\u9012\u589e\uff0c\u6839\u8282\u70b9\u6240\u5728\u5c42\u4e3a 1 \uff1b
    • \u8282\u70b9\u7684\u300c\u5ea6 Degree\u300d\uff1a\u8282\u70b9\u7684\u5b50\u8282\u70b9\u7684\u6570\u91cf\u3002\u5728\u4e8c\u53c9\u6811\u4e2d\uff0c\u5ea6\u7684\u8303\u56f4\u662f 0, 1, 2 \uff1b
    • \u300c\u8fb9 Edge\u300d\uff1a\u8fde\u63a5\u4e24\u4e2a\u8282\u70b9\u7684\u7ebf\u6bb5\uff0c\u5373\u8282\u70b9\u6307\u9488\uff1b
    • \u4e8c\u53c9\u6811\u7684\u300c\u9ad8\u5ea6\u300d\uff1a\u4ece\u6839\u8282\u70b9\u5230\u6700\u8fdc\u53f6\u8282\u70b9\u6240\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\uff1b
    • \u8282\u70b9\u7684\u300c\u6df1\u5ea6 Depth\u300d \uff1a\u4ece\u6839\u8282\u70b9\u5230\u8be5\u8282\u70b9\u6240\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\uff1b
    • \u8282\u70b9\u7684\u300c\u9ad8\u5ea6 Height\u300d\uff1a\u4ece\u6700\u8fdc\u53f6\u8282\u70b9\u5230\u8be5\u8282\u70b9\u6240\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\uff1b

    Fig. \u4e8c\u53c9\u6811\u7684\u5e38\u7528\u672f\u8bed

    \u9ad8\u5ea6\u4e0e\u6df1\u5ea6\u7684\u5b9a\u4e49

    \u8bf7\u6ce8\u610f\uff0c\u6211\u4eec\u901a\u5e38\u5c06\u300c\u9ad8\u5ea6\u300d\u548c\u300c\u6df1\u5ea6\u300d\u5b9a\u4e49\u4e3a\u201c\u8d70\u8fc7\u8fb9\u7684\u6570\u91cf\u201d\uff0c\u4f46\u6709\u4e9b\u9898\u76ee\u6216\u6559\u6750\u53ef\u80fd\u4f1a\u5c06\u5176\u5b9a\u4e49\u4e3a\u201c\u8d70\u8fc7\u8282\u70b9\u7684\u6570\u91cf\u201d\u3002\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u9ad8\u5ea6\u548c\u6df1\u5ea6\u90fd\u9700\u8981\u52a0 1 \u3002

    "},{"location":"chapter_tree/binary_tree/#712","title":"7.1.2. \u00a0 \u4e8c\u53c9\u6811\u57fa\u672c\u64cd\u4f5c","text":"

    \u521d\u59cb\u5316\u4e8c\u53c9\u6811\u3002\u4e0e\u94fe\u8868\u7c7b\u4f3c\uff0c\u9996\u5148\u521d\u59cb\u5316\u8282\u70b9\uff0c\u7136\u540e\u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_tree.java
    // \u521d\u59cb\u5316\u8282\u70b9\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.cpp
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nTreeNode* n1 = new TreeNode(1);\nTreeNode* n2 = new TreeNode(2);\nTreeNode* n3 = new TreeNode(3);\nTreeNode* n4 = new TreeNode(4);\nTreeNode* n5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1->left = n2;\nn1->right = n3;\nn2->left = n4;\nn2->right = n5;\n
    binary_tree.py
    # \u521d\u59cb\u5316\u4e8c\u53c9\u6811\n# \u521d\u59cb\u5316\u8282\u70b9\nn1 = TreeNode(val=1)\nn2 = TreeNode(val=2)\nn3 = TreeNode(val=3)\nn4 = TreeNode(val=4)\nn5 = TreeNode(val=5)\n# \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n
    binary_tree.go
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nn1 := NewTreeNode(1)\nn2 := NewTreeNode(2)\nn3 := NewTreeNode(3)\nn4 := NewTreeNode(4)\nn5 := NewTreeNode(5)\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.Left = n2\nn1.Right = n3\nn2.Left = n4\nn2.Right = n5\n
    binary_tree.js
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nlet n1 = new TreeNode(1),\nn2 = new TreeNode(2),\nn3 = new TreeNode(3),\nn4 = new TreeNode(4),\nn5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.ts
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nlet n1 = new TreeNode(1),\nn2 = new TreeNode(2),\nn3 = new TreeNode(3),\nn4 = new TreeNode(4),\nn5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.c
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nTreeNode *n1 = newTreeNode(1);\nTreeNode *n2 = newTreeNode(2);\nTreeNode *n3 = newTreeNode(3);\nTreeNode *n4 = newTreeNode(4);\nTreeNode *n5 = newTreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1->left = n2;\nn1->right = n3;\nn2->left = n4;\nn2->right = n5;\n
    binary_tree.cs
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.swift
    // \u521d\u59cb\u5316\u8282\u70b9\nlet n1 = TreeNode(x: 1)\nlet n2 = TreeNode(x: 2)\nlet n3 = TreeNode(x: 3)\nlet n4 = TreeNode(x: 4)\nlet n5 = TreeNode(x: 5)\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n
    binary_tree.zig
    \n
    binary_tree.dart
    /* \u521d\u59cb\u5316\u4e8c\u53c9\u6811 */\n// \u521d\u59cb\u5316\u8282\u70b9\nTreeNode n1 = new TreeNode(1);\nTreeNode n2 = new TreeNode(2);\nTreeNode n3 = new TreeNode(3);\nTreeNode n4 = new TreeNode(4);\nTreeNode n5 = new TreeNode(5);\n// \u6784\u5efa\u5f15\u7528\u6307\u5411\uff08\u5373\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n

    \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u3002\u4e0e\u94fe\u8868\u7c7b\u4f3c\uff0c\u901a\u8fc7\u4fee\u6539\u6307\u9488\u6765\u5b9e\u73b0\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u3002

    Fig. \u5728\u4e8c\u53c9\u6811\u4e2d\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_tree.java
    TreeNode P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P;\nP.left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2;\n
    binary_tree.cpp
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nTreeNode* P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1->left = P;\nP->left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1->left = n2;\n
    binary_tree.py
    # \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\np = TreeNode(0)\n# \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = p\np.left = n2\n# \u5220\u9664\u8282\u70b9 P\nn1.left = n2\n
    binary_tree.go
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\np := NewTreeNode(0)\nn1.Left = p\np.Left = n2\n// \u5220\u9664\u8282\u70b9 P\nn1.Left = n2\n
    binary_tree.js
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nlet P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P;\nP.left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2;\n
    binary_tree.ts
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nconst P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P;\nP.left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2;\n
    binary_tree.c
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nTreeNode *P = newTreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1->left = P;\nP->left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1->left = n2;\n
    binary_tree.cs
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nTreeNode P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P;\nP.left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2;\n
    binary_tree.swift
    let P = TreeNode(x: 0)\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P\nP.left = n2\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2\n
    binary_tree.zig
    \n
    binary_tree.dart
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nTreeNode P = new TreeNode(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.left = P;\nP.left = n2;\n// \u5220\u9664\u8282\u70b9 P\nn1.left = n2;\n

    Note

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u63d2\u5165\u8282\u70b9\u53ef\u80fd\u4f1a\u6539\u53d8\u4e8c\u53c9\u6811\u7684\u539f\u6709\u903b\u8f91\u7ed3\u6784\uff0c\u800c\u5220\u9664\u8282\u70b9\u901a\u5e38\u610f\u5473\u7740\u5220\u9664\u8be5\u8282\u70b9\u53ca\u5176\u6240\u6709\u5b50\u6811\u3002\u56e0\u6b64\uff0c\u5728\u4e8c\u53c9\u6811\u4e2d\uff0c\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u901a\u5e38\u662f\u7531\u4e00\u5957\u64cd\u4f5c\u914d\u5408\u5b8c\u6210\u7684\uff0c\u4ee5\u5b9e\u73b0\u6709\u5b9e\u9645\u610f\u4e49\u7684\u64cd\u4f5c\u3002

    "},{"location":"chapter_tree/binary_tree/#713","title":"7.1.3. \u00a0 \u5e38\u89c1\u4e8c\u53c9\u6811\u7c7b\u578b","text":""},{"location":"chapter_tree/binary_tree/#_1","title":"\u5b8c\u7f8e\u4e8c\u53c9\u6811","text":"

    \u300c\u5b8c\u7f8e\u4e8c\u53c9\u6811 Perfect Binary Tree\u300d\u9664\u4e86\u6700\u5e95\u5c42\u5916\uff0c\u5176\u4f59\u6240\u6709\u5c42\u7684\u8282\u70b9\u90fd\u88ab\u5b8c\u5168\u586b\u6ee1\u3002\u5728\u5b8c\u7f8e\u4e8c\u53c9\u6811\u4e2d\uff0c\u53f6\u8282\u70b9\u7684\u5ea6\u4e3a \\(0\\) \uff0c\u5176\u4f59\u6240\u6709\u8282\u70b9\u7684\u5ea6\u90fd\u4e3a \\(2\\) \uff1b\u82e5\u6811\u9ad8\u5ea6\u4e3a \\(h\\) \uff0c\u5219\u8282\u70b9\u603b\u6570\u4e3a \\(2^{h+1} - 1\\) \uff0c\u5448\u73b0\u6807\u51c6\u7684\u6307\u6570\u7ea7\u5173\u7cfb\uff0c\u53cd\u6620\u4e86\u81ea\u7136\u754c\u4e2d\u5e38\u89c1\u7684\u7ec6\u80de\u5206\u88c2\u73b0\u8c61\u3002

    Tip

    \u5728\u4e2d\u6587\u793e\u533a\u4e2d\uff0c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u5e38\u88ab\u79f0\u4e3a\u300c\u6ee1\u4e8c\u53c9\u6811\u300d\uff0c\u8bf7\u6ce8\u610f\u533a\u5206\u3002

    Fig. \u5b8c\u7f8e\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#_2","title":"\u5b8c\u5168\u4e8c\u53c9\u6811","text":"

    \u300c\u5b8c\u5168\u4e8c\u53c9\u6811 Complete Binary Tree\u300d\u53ea\u6709\u6700\u5e95\u5c42\u7684\u8282\u70b9\u672a\u88ab\u586b\u6ee1\uff0c\u4e14\u6700\u5e95\u5c42\u8282\u70b9\u5c3d\u91cf\u9760\u5de6\u586b\u5145\u3002

    Fig. \u5b8c\u5168\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#_3","title":"\u5b8c\u6ee1\u4e8c\u53c9\u6811","text":"

    \u300c\u5b8c\u6ee1\u4e8c\u53c9\u6811 Full Binary Tree\u300d\u9664\u4e86\u53f6\u8282\u70b9\u4e4b\u5916\uff0c\u5176\u4f59\u6240\u6709\u8282\u70b9\u90fd\u6709\u4e24\u4e2a\u5b50\u8282\u70b9\u3002

    Fig. \u5b8c\u6ee1\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#_4","title":"\u5e73\u8861\u4e8c\u53c9\u6811","text":"

    \u300c\u5e73\u8861\u4e8c\u53c9\u6811 Balanced Binary Tree\u300d\u4e2d\u4efb\u610f\u8282\u70b9\u7684\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\u7684\u9ad8\u5ea6\u4e4b\u5dee\u7684\u7edd\u5bf9\u503c\u4e0d\u8d85\u8fc7 1 \u3002

    Fig. \u5e73\u8861\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#714","title":"7.1.4. \u00a0 \u4e8c\u53c9\u6811\u7684\u9000\u5316","text":"

    \u5f53\u4e8c\u53c9\u6811\u7684\u6bcf\u5c42\u8282\u70b9\u90fd\u88ab\u586b\u6ee1\u65f6\uff0c\u8fbe\u5230\u300c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u300d\uff1b\u800c\u5f53\u6240\u6709\u8282\u70b9\u90fd\u504f\u5411\u4e00\u4fa7\u65f6\uff0c\u4e8c\u53c9\u6811\u9000\u5316\u4e3a\u300c\u94fe\u8868\u300d\u3002

    • \u5b8c\u7f8e\u4e8c\u53c9\u6811\u662f\u7406\u60f3\u60c5\u51b5\uff0c\u53ef\u4ee5\u5145\u5206\u53d1\u6325\u4e8c\u53c9\u6811\u201c\u5206\u6cbb\u201d\u7684\u4f18\u52bf\uff1b
    • \u94fe\u8868\u5219\u662f\u53e6\u4e00\u4e2a\u6781\u7aef\uff0c\u5404\u9879\u64cd\u4f5c\u90fd\u53d8\u4e3a\u7ebf\u6027\u64cd\u4f5c\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u9000\u5316\u81f3 \\(O(n)\\) \uff1b

    Fig. \u4e8c\u53c9\u6811\u7684\u6700\u4f73\u4e0e\u6700\u5dee\u7ed3\u6784

    \u5982\u4e0b\u8868\u6240\u793a\uff0c\u5728\u6700\u4f73\u548c\u6700\u5dee\u7ed3\u6784\u4e0b\uff0c\u4e8c\u53c9\u6811\u7684\u53f6\u8282\u70b9\u6570\u91cf\u3001\u8282\u70b9\u603b\u6570\u3001\u9ad8\u5ea6\u7b49\u8fbe\u5230\u6781\u5927\u6216\u6781\u5c0f\u503c\u3002

    \u5b8c\u7f8e\u4e8c\u53c9\u6811 \u94fe\u8868 \u7b2c \\(i\\) \u5c42\u7684\u8282\u70b9\u6570\u91cf \\(2^{i-1}\\) \\(1\\) \u6811\u7684\u9ad8\u5ea6\u4e3a \\(h\\) \u65f6\u7684\u53f6\u8282\u70b9\u6570\u91cf \\(2^h\\) \\(1\\) \u6811\u7684\u9ad8\u5ea6\u4e3a \\(h\\) \u65f6\u7684\u8282\u70b9\u603b\u6570 \\(2^{h+1} - 1\\) \\(h + 1\\) \u6811\u7684\u8282\u70b9\u603b\u6570\u4e3a \\(n\\) \u65f6\u7684\u9ad8\u5ea6 \\(\\log_2 (n+1) - 1\\) \\(n - 1\\)"},{"location":"chapter_tree/binary_tree_traversal/","title":"7.2. \u00a0 \u4e8c\u53c9\u6811\u904d\u5386","text":"

    \u4ece\u7269\u7406\u7ed3\u6784\u7684\u89d2\u5ea6\u6765\u770b\uff0c\u6811\u662f\u4e00\u79cd\u57fa\u4e8e\u94fe\u8868\u7684\u6570\u636e\u7ed3\u6784\uff0c\u56e0\u6b64\u5176\u904d\u5386\u65b9\u5f0f\u662f\u901a\u8fc7\u6307\u9488\u9010\u4e2a\u8bbf\u95ee\u8282\u70b9\u3002\u7136\u800c\uff0c\u6811\u662f\u4e00\u79cd\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u8fd9\u4f7f\u5f97\u904d\u5386\u6811\u6bd4\u904d\u5386\u94fe\u8868\u66f4\u52a0\u590d\u6742\uff0c\u9700\u8981\u501f\u52a9\u641c\u7d22\u7b97\u6cd5\u6765\u5b9e\u73b0\u3002

    \u4e8c\u53c9\u6811\u5e38\u89c1\u7684\u904d\u5386\u65b9\u5f0f\u5305\u62ec\u5c42\u5e8f\u904d\u5386\u3001\u524d\u5e8f\u904d\u5386\u3001\u4e2d\u5e8f\u904d\u5386\u548c\u540e\u5e8f\u904d\u5386\u7b49\u3002

    "},{"location":"chapter_tree/binary_tree_traversal/#721","title":"7.2.1. \u00a0 \u5c42\u5e8f\u904d\u5386","text":"

    \u300c\u5c42\u5e8f\u904d\u5386 Level-Order Traversal\u300d\u4ece\u9876\u90e8\u5230\u5e95\u90e8\u9010\u5c42\u904d\u5386\u4e8c\u53c9\u6811\uff0c\u5e76\u5728\u6bcf\u4e00\u5c42\u6309\u7167\u4ece\u5de6\u5230\u53f3\u7684\u987a\u5e8f\u8bbf\u95ee\u8282\u70b9\u3002

    \u5c42\u5e8f\u904d\u5386\u672c\u8d28\u4e0a\u5c5e\u4e8e\u300c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22 Breadth-First Traversal\u300d\uff0c\u5b83\u4f53\u73b0\u4e86\u4e00\u79cd\u201c\u4e00\u5708\u4e00\u5708\u5411\u5916\u6269\u5c55\u201d\u7684\u9010\u5c42\u641c\u7d22\u65b9\u5f0f\u3002

    Fig. \u4e8c\u53c9\u6811\u7684\u5c42\u5e8f\u904d\u5386

    "},{"location":"chapter_tree/binary_tree_traversal/#_1","title":"\u7b97\u6cd5\u5b9e\u73b0","text":"

    \u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u901a\u5e38\u501f\u52a9\u300c\u961f\u5217\u300d\u6765\u5b9e\u73b0\u3002\u961f\u5217\u9075\u5faa\u201c\u5148\u8fdb\u5148\u51fa\u201d\u7684\u89c4\u5219\uff0c\u800c\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u5219\u9075\u5faa\u201c\u9010\u5c42\u63a8\u8fdb\u201d\u7684\u89c4\u5219\uff0c\u4e24\u8005\u80cc\u540e\u7684\u601d\u60f3\u662f\u4e00\u81f4\u7684\u3002

    JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_tree_bfs.java
    /* \u5c42\u5e8f\u904d\u5386 */\nList<Integer> levelOrder(TreeNode root) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nQueue<TreeNode> queue = new LinkedList<>() {{ add(root); }};\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nList<Integer> list = new ArrayList<>();\nwhile (!queue.isEmpty()) {\nTreeNode node = queue.poll(); // \u961f\u5217\u51fa\u961f\nlist.add(node.val);           // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left != null)\nqueue.offer(node.left);   // \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif (node.right != null)\nqueue.offer(node.right);  // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\nreturn list;\n}\n
    binary_tree_bfs.cpp
    /* \u5c42\u5e8f\u904d\u5386 */\nvector<int> levelOrder(TreeNode *root) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nqueue<TreeNode *> queue;\nqueue.push(root);\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nvector<int> vec;\nwhile (!queue.empty()) {\nTreeNode *node = queue.front();\nqueue.pop();              // \u961f\u5217\u51fa\u961f\nvec.push_back(node->val); // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node->left != nullptr)\nqueue.push(node->left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif (node->right != nullptr)\nqueue.push(node->right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\nreturn vec;\n}\n
    binary_tree_bfs.py
    def level_order(root: TreeNode | None) -> list[int]:\n\"\"\"\u5c42\u5e8f\u904d\u5386\"\"\"\n# \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nqueue: deque[TreeNode] = deque()\nqueue.append(root)\n# \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nres = []\nwhile queue:\nnode: TreeNode = queue.popleft()  # \u961f\u5217\u51fa\u961f\nres.append(node.val)  # \u4fdd\u5b58\u8282\u70b9\u503c\nif node.left is not None:\nqueue.append(node.left)  # \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif node.right is not None:\nqueue.append(node.right)  # \u53f3\u5b50\u8282\u70b9\u5165\u961f\nreturn res\n
    binary_tree_bfs.go
    /* \u5c42\u5e8f\u904d\u5386 */\nfunc levelOrder(root *TreeNode) []int {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nqueue := list.New()\nqueue.PushBack(root)\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5207\u7247\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nnums := make([]int, 0)\nfor queue.Len() > 0 {\n// \u961f\u5217\u51fa\u961f\nnode := queue.Remove(queue.Front()).(*TreeNode)\n// \u4fdd\u5b58\u8282\u70b9\u503c\nnums = append(nums, node.Val)\nif node.Left != nil {\n// \u5de6\u5b50\u8282\u70b9\u5165\u961f\nqueue.PushBack(node.Left)\n}\nif node.Right != nil {\n// \u53f3\u5b50\u8282\u70b9\u5165\u961f\nqueue.PushBack(node.Right)\n}\n}\nreturn nums\n}\n
    binary_tree_bfs.js
    /* \u5c42\u5e8f\u904d\u5386 */\nfunction levelOrder(root) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nconst queue = [root];\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nconst list = [];\nwhile (queue.length) {\nlet node = queue.shift(); // \u961f\u5217\u51fa\u961f\nlist.push(node.val); // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left) queue.push(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif (node.right) queue.push(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\nreturn list;\n}\n
    binary_tree_bfs.ts
    /* \u5c42\u5e8f\u904d\u5386 */\nfunction levelOrder(root: TreeNode | null): number[] {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nconst queue = [root];\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nconst list: number[] = [];\nwhile (queue.length) {\nlet node = queue.shift() as TreeNode; // \u961f\u5217\u51fa\u961f\nlist.push(node.val); // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left) {\nqueue.push(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n}\nif (node.right) {\nqueue.push(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\n}\nreturn list;\n}\n
    binary_tree_bfs.c
    /* \u5c42\u5e8f\u904d\u5386 */\nint *levelOrder(TreeNode *root, int *size) {\n/* \u8f85\u52a9\u961f\u5217 */\nint front, rear;\nint index, *arr;\nTreeNode *node;\nTreeNode **queue;\n/* \u8f85\u52a9\u961f\u5217 */\nqueue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_NODE_SIZE);\n// \u961f\u5217\u6307\u9488\nfront = 0, rear = 0;\n// \u52a0\u5165\u6839\u8282\u70b9\nqueue[rear++] = root;\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n/* \u8f85\u52a9\u6570\u7ec4 */\narr = (int *)malloc(sizeof(int) * MAX_NODE_SIZE);\n// \u6570\u7ec4\u6307\u9488\nindex = 0;\nwhile (front < rear) {\n// \u961f\u5217\u51fa\u961f\nnode = queue[front++];\n// \u4fdd\u5b58\u8282\u70b9\u503c\narr[index++] = node->val;\nif (node->left != NULL) {\n// \u5de6\u5b50\u8282\u70b9\u5165\u961f\nqueue[rear++] = node->left;\n}\nif (node->right != NULL) {\n// \u53f3\u5b50\u8282\u70b9\u5165\u961f\nqueue[rear++] = node->right;\n}\n}\n// \u66f4\u65b0\u6570\u7ec4\u957f\u5ea6\u7684\u503c\n*size = index;\narr = realloc(arr, sizeof(int) * (*size));\n// \u91ca\u653e\u8f85\u52a9\u6570\u7ec4\u7a7a\u95f4\nfree(queue);\nreturn arr;\n}\n
    binary_tree_bfs.cs
    /* \u5c42\u5e8f\u904d\u5386 */\nList<int> levelOrder(TreeNode root) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nQueue<TreeNode> queue = new();\nqueue.Enqueue(root);\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nList<int> list = new();\nwhile (queue.Count != 0) {\nTreeNode node = queue.Dequeue(); // \u961f\u5217\u51fa\u961f\nlist.Add(node.val);              // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left != null)\nqueue.Enqueue(node.left);    // \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif (node.right != null)\nqueue.Enqueue(node.right);   // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\nreturn list;\n}\n
    binary_tree_bfs.swift
    /* \u5c42\u5e8f\u904d\u5386 */\nfunc levelOrder(root: TreeNode) -> [Int] {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nvar queue: [TreeNode] = [root]\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nvar list: [Int] = []\nwhile !queue.isEmpty {\nlet node = queue.removeFirst() // \u961f\u5217\u51fa\u961f\nlist.append(node.val) // \u4fdd\u5b58\u8282\u70b9\u503c\nif let left = node.left {\nqueue.append(left) // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n}\nif let right = node.right {\nqueue.append(right) // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\n}\nreturn list\n}\n
    binary_tree_bfs.zig
    // \u5c42\u5e8f\u904d\u5386\nfn levelOrder(comptime T: type, mem_allocator: std.mem.Allocator, root: *inc.TreeNode(T)) !std.ArrayList(T) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nconst L = std.TailQueue(*inc.TreeNode(T));\nvar queue = L{};\nvar root_node = try mem_allocator.create(L.Node);\nroot_node.data = root;\nqueue.append(root_node); // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nvar list = std.ArrayList(T).init(std.heap.page_allocator);\nwhile (queue.len > 0) {\nvar queue_node = queue.popFirst().?;    // \u961f\u5217\u51fa\u961f\nvar node = queue_node.data;\ntry list.append(node.val);              // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left != null) {\nvar tmp_node = try mem_allocator.create(L.Node);\ntmp_node.data = node.left.?;\nqueue.append(tmp_node);             // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n}\nif (node.right != null) {\nvar tmp_node = try mem_allocator.create(L.Node);\ntmp_node.data = node.right.?;\nqueue.append(tmp_node);             // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}        }\nreturn list;\n}\n
    binary_tree_bfs.dart
    /* \u5c42\u5e8f\u904d\u5386 */\nList<int> levelOrder(TreeNode? root) {\n// \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\nQueue<TreeNode?> queue = Queue();\nqueue.add(root);\n// \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\nList<int> res = [];\nwhile (queue.isNotEmpty) {\nTreeNode? node = queue.removeFirst(); // \u961f\u5217\u51fa\u961f\nres.add(node!.val); // \u4fdd\u5b58\u8282\u70b9\u503c\nif (node.left != null) queue.add(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\nif (node.right != null) queue.add(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n}\nreturn res;\n}\n
    "},{"location":"chapter_tree/binary_tree_traversal/#_2","title":"\u590d\u6742\u5ea6\u5206\u6790","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u6240\u6709\u8282\u70b9\u88ab\u8bbf\u95ee\u4e00\u6b21\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\uff0c\u5176\u4e2d \\(n\\) \u4e3a\u8282\u70b9\u6570\u91cf\u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\uff1a\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u5373\u6ee1\u4e8c\u53c9\u6811\u65f6\uff0c\u904d\u5386\u5230\u6700\u5e95\u5c42\u4e4b\u524d\uff0c\u961f\u5217\u4e2d\u6700\u591a\u540c\u65f6\u5b58\u5728 \\(\\frac{n + 1}{2}\\) \u4e2a\u8282\u70b9\uff0c\u5360\u7528 \\(O(n)\\) \u7a7a\u95f4\u3002

    "},{"location":"chapter_tree/binary_tree_traversal/#722","title":"7.2.2. \u00a0 \u524d\u5e8f\u3001\u4e2d\u5e8f\u3001\u540e\u5e8f\u904d\u5386","text":"

    \u76f8\u5e94\u5730\uff0c\u524d\u5e8f\u3001\u4e2d\u5e8f\u548c\u540e\u5e8f\u904d\u5386\u90fd\u5c5e\u4e8e\u300c\u6df1\u5ea6\u4f18\u5148\u904d\u5386 Depth-First Traversal\u300d\uff0c\u5b83\u4f53\u73b0\u4e86\u4e00\u79cd\u201c\u5148\u8d70\u5230\u5c3d\u5934\uff0c\u518d\u56de\u6eaf\u7ee7\u7eed\u201d\u7684\u904d\u5386\u65b9\u5f0f\u3002

    \u5982\u4e0b\u56fe\u6240\u793a\uff0c\u5de6\u4fa7\u662f\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u7684\u793a\u610f\u56fe\uff0c\u53f3\u4e0a\u65b9\u662f\u5bf9\u5e94\u7684\u9012\u5f52\u5b9e\u73b0\u4ee3\u7801\u3002\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u5c31\u50cf\u662f\u7ed5\u7740\u6574\u4e2a\u4e8c\u53c9\u6811\u7684\u5916\u56f4\u201c\u8d70\u201d\u4e00\u5708\uff0c\u5728\u8fd9\u4e2a\u8fc7\u7a0b\u4e2d\uff0c\u5728\u6bcf\u4e2a\u8282\u70b9\u90fd\u4f1a\u9047\u5230\u4e09\u4e2a\u4f4d\u7f6e\uff0c\u5206\u522b\u5bf9\u5e94\u524d\u5e8f\u904d\u5386\u3001\u4e2d\u5e8f\u904d\u5386\u548c\u540e\u5e8f\u904d\u5386\u3002

    Fig. \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u524d\u3001\u4e2d\u3001\u540e\u5e8f\u904d\u5386

    \u4f4d\u7f6e \u542b\u4e49 \u6b64\u5904\u8bbf\u95ee\u8282\u70b9\u65f6\u5bf9\u5e94 \u6a59\u8272\u5706\u5708\u5904 \u521a\u8fdb\u5165\u6b64\u8282\u70b9\uff0c\u5373\u5c06\u8bbf\u95ee\u8be5\u8282\u70b9\u7684\u5de6\u5b50\u6811 \u524d\u5e8f\u904d\u5386 Pre-Order Traversal \u84dd\u8272\u5706\u5708\u5904 \u5df2\u8bbf\u95ee\u5b8c\u5de6\u5b50\u6811\uff0c\u5373\u5c06\u8bbf\u95ee\u53f3\u5b50\u6811 \u4e2d\u5e8f\u904d\u5386 In-Order Traversal \u7d2b\u8272\u5706\u5708\u5904 \u5df2\u8bbf\u95ee\u5b8c\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\uff0c\u5373\u5c06\u8fd4\u56de \u540e\u5e8f\u904d\u5386 Post-Order Traversal"},{"location":"chapter_tree/binary_tree_traversal/#_3","title":"\u7b97\u6cd5\u5b9e\u73b0","text":"JavaC++PythonGoJavaScriptTypeScriptCC#SwiftZigDart binary_tree_dfs.java
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode root) {\nif (root == null)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.add(root.val);\npreOrder(root.left);\npreOrder(root.right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode root) {\nif (root == null)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root.left);\nlist.add(root.val);\ninOrder(root.right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode root) {\nif (root == null)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root.left);\npostOrder(root.right);\nlist.add(root.val);\n}\n
    binary_tree_dfs.cpp
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode *root) {\nif (root == nullptr)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nvec.push_back(root->val);\npreOrder(root->left);\npreOrder(root->right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode *root) {\nif (root == nullptr)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root->left);\nvec.push_back(root->val);\ninOrder(root->right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode *root) {\nif (root == nullptr)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root->left);\npostOrder(root->right);\nvec.push_back(root->val);\n}\n
    binary_tree_dfs.py
    def pre_order(root: TreeNode | None) -> None:\n\"\"\"\u524d\u5e8f\u904d\u5386\"\"\"\nif root is None:\nreturn\n# \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nres.append(root.val)\npre_order(root=root.left)\npre_order(root=root.right)\ndef in_order(root: TreeNode | None) -> None:\n\"\"\"\u4e2d\u5e8f\u904d\u5386\"\"\"\nif root is None:\nreturn\n# \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\nin_order(root=root.left)\nres.append(root.val)\nin_order(root=root.right)\ndef post_order(root: TreeNode | None) -> None:\n\"\"\"\u540e\u5e8f\u904d\u5386\"\"\"\nif root is None:\nreturn\n# \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npost_order(root=root.left)\npost_order(root=root.right)\nres.append(root.val)\n
    binary_tree_dfs.go
    /* \u524d\u5e8f\u904d\u5386 */\nfunc preOrder(node *TreeNode) {\nif node == nil {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nnums = append(nums, node.Val)\npreOrder(node.Left)\npreOrder(node.Right)\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc inOrder(node *TreeNode) {\nif node == nil {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(node.Left)\nnums = append(nums, node.Val)\ninOrder(node.Right)\n}\n/* \u540e\u5e8f\u904d\u5386 */\nfunc postOrder(node *TreeNode) {\nif node == nil {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(node.Left)\npostOrder(node.Right)\nnums = append(nums, node.Val)\n}\n
    binary_tree_dfs.js
    /* \u524d\u5e8f\u904d\u5386 */\nfunction preOrder(root) {\nif (root === null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.push(root.val);\npreOrder(root.left);\npreOrder(root.right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunction inOrder(root) {\nif (root === null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root.left);\nlist.push(root.val);\ninOrder(root.right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nfunction postOrder(root) {\nif (root === null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root.left);\npostOrder(root.right);\nlist.push(root.val);\n}\n
    binary_tree_dfs.ts
    /* \u524d\u5e8f\u904d\u5386 */\nfunction preOrder(root: TreeNode | null): void {\nif (root === null) {\nreturn;\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.push(root.val);\npreOrder(root.left);\npreOrder(root.right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunction inOrder(root: TreeNode | null): void {\nif (root === null) {\nreturn;\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root.left);\nlist.push(root.val);\ninOrder(root.right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nfunction postOrder(root: TreeNode | null): void {\nif (root === null) {\nreturn;\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root.left);\npostOrder(root.right);\nlist.push(root.val);\n}\n
    binary_tree_dfs.c
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode *root, int *size) {\nif (root == NULL)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\narr[(*size)++] = root->val;\npreOrder(root->left, size);\npreOrder(root->right, size);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode *root, int *size) {\nif (root == NULL)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root->left, size);\narr[(*size)++] = root->val;\ninOrder(root->right, size);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode *root, int *size) {\nif (root == NULL)\nreturn;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root->left, size);\npostOrder(root->right, size);\narr[(*size)++] = root->val;\n}\n
    binary_tree_dfs.cs
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode? root) {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.Add(root.val);\npreOrder(root.left);\npreOrder(root.right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode? root) {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root.left);\nlist.Add(root.val);\ninOrder(root.right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode? root) {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root.left);\npostOrder(root.right);\nlist.Add(root.val);\n}\n
    binary_tree_dfs.swift
    /* \u524d\u5e8f\u904d\u5386 */\nfunc preOrder(root: TreeNode?) {\nguard let root = root else {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.append(root.val)\npreOrder(root: root.left)\npreOrder(root: root.right)\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc inOrder(root: TreeNode?) {\nguard let root = root else {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(root: root.left)\nlist.append(root.val)\ninOrder(root: root.right)\n}\n/* \u540e\u5e8f\u904d\u5386 */\nfunc postOrder(root: TreeNode?) {\nguard let root = root else {\nreturn\n}\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(root: root.left)\npostOrder(root: root.right)\nlist.append(root.val)\n}\n
    binary_tree_dfs.zig
    // \u524d\u5e8f\u904d\u5386\nfn preOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\ntry list.append(root.?.val);\ntry preOrder(T, root.?.left);\ntry preOrder(T, root.?.right);\n}\n// \u4e2d\u5e8f\u904d\u5386\nfn inOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ntry inOrder(T, root.?.left);\ntry list.append(root.?.val);\ntry inOrder(T, root.?.right);\n}\n// \u540e\u5e8f\u904d\u5386\nfn postOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\nif (root == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\ntry postOrder(T, root.?.left);\ntry postOrder(T, root.?.right);\ntry list.append(root.?.val);\n}\n
    binary_tree_dfs.dart
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode? node) {\nif (node == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\nlist.add(node.val);\npreOrder(node.left);\npreOrder(node.right);\n}\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode? node) {\nif (node == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\ninOrder(node.left);\nlist.add(node.val);\ninOrder(node.right);\n}\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode? node) {\nif (node == null) return;\n// \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\npostOrder(node.left);\npostOrder(node.right);\nlist.add(node.val);\n}\n

    Note

    \u6211\u4eec\u4e5f\u53ef\u4ee5\u4ec5\u57fa\u4e8e\u5faa\u73af\u5b9e\u73b0\u524d\u3001\u4e2d\u3001\u540e\u5e8f\u904d\u5386\uff0c\u6709\u5174\u8da3\u7684\u540c\u5b66\u53ef\u4ee5\u81ea\u884c\u5b9e\u73b0\u3002

    \u9012\u5f52\u8fc7\u7a0b\u53ef\u5206\u4e3a\u201c\u9012\u201d\u548c\u201c\u5f52\u201d\u4e24\u4e2a\u76f8\u53cd\u7684\u90e8\u5206\u3002\u201c\u9012\u201d\u8868\u793a\u5f00\u542f\u65b0\u65b9\u6cd5\uff0c\u7a0b\u5e8f\u5728\u6b64\u8fc7\u7a0b\u4e2d\u8bbf\u95ee\u4e0b\u4e00\u4e2a\u8282\u70b9\uff1b\u201c\u5f52\u201d\u8868\u793a\u51fd\u6570\u8fd4\u56de\uff0c\u4ee3\u8868\u8be5\u8282\u70b9\u5df2\u7ecf\u8bbf\u95ee\u5b8c\u6bd5\u3002\u5982\u4e0b\u56fe\u6240\u793a\uff0c\u4e3a\u524d\u5e8f\u904d\u5386\u4e8c\u53c9\u6811\u7684\u9012\u5f52\u8fc7\u7a0b\u3002

    <1><2><3><4><5><6><7><8><9><10><11>

    "},{"location":"chapter_tree/binary_tree_traversal/#_4","title":"\u590d\u6742\u5ea6\u5206\u6790","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u6240\u6709\u8282\u70b9\u88ab\u8bbf\u95ee\u4e00\u6b21\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\uff0c\u5176\u4e2d \\(n\\) \u4e3a\u8282\u70b9\u6570\u91cf\u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\uff1a\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u5373\u6811\u9000\u5316\u4e3a\u94fe\u8868\u65f6\uff0c\u9012\u5f52\u6df1\u5ea6\u8fbe\u5230 \\(n\\) \uff0c\u7cfb\u7edf\u5360\u7528 \\(O(n)\\) \u6808\u5e27\u7a7a\u95f4\u3002

    "},{"location":"chapter_tree/summary/","title":"7.6. \u00a0 \u5c0f\u7ed3","text":"
    • \u4e8c\u53c9\u6811\u662f\u4e00\u79cd\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u4f53\u73b0\u201c\u4e00\u5206\u4e3a\u4e8c\u201d\u7684\u5206\u6cbb\u903b\u8f91\u3002\u6bcf\u4e2a\u4e8c\u53c9\u6811\u8282\u70b9\u5305\u542b\u4e00\u4e2a\u503c\u4ee5\u53ca\u4e24\u4e2a\u6307\u9488\uff0c\u5206\u522b\u6307\u5411\u5176\u5de6\u5b50\u8282\u70b9\u548c\u53f3\u5b50\u8282\u70b9\u3002
    • \u5bf9\u4e8e\u4e8c\u53c9\u6811\u4e2d\u7684\u67d0\u4e2a\u8282\u70b9\uff0c\u5176\u5de6\uff08\u53f3\uff09\u5b50\u8282\u70b9\u53ca\u5176\u4ee5\u4e0b\u5f62\u6210\u7684\u6811\u88ab\u79f0\u4e3a\u8be5\u8282\u70b9\u7684\u5de6\uff08\u53f3\uff09\u5b50\u6811\u3002
    • \u4e8c\u53c9\u6811\u7684\u76f8\u5173\u672f\u8bed\u5305\u62ec\u6839\u8282\u70b9\u3001\u53f6\u8282\u70b9\u3001\u5c42\u3001\u5ea6\u3001\u8fb9\u3001\u9ad8\u5ea6\u548c\u6df1\u5ea6\u7b49\u3002
    • \u4e8c\u53c9\u6811\u7684\u521d\u59cb\u5316\u3001\u8282\u70b9\u63d2\u5165\u548c\u8282\u70b9\u5220\u9664\u64cd\u4f5c\u4e0e\u94fe\u8868\u64cd\u4f5c\u65b9\u6cd5\u7c7b\u4f3c\u3002
    • \u5e38\u89c1\u7684\u4e8c\u53c9\u6811\u7c7b\u578b\u6709\u5b8c\u7f8e\u4e8c\u53c9\u6811\u3001\u5b8c\u5168\u4e8c\u53c9\u6811\u3001\u6ee1\u4e8c\u53c9\u6811\u548c\u5e73\u8861\u4e8c\u53c9\u6811\u3002\u5b8c\u7f8e\u4e8c\u53c9\u6811\u662f\u6700\u7406\u60f3\u7684\u72b6\u6001\uff0c\u800c\u94fe\u8868\u662f\u9000\u5316\u540e\u7684\u6700\u5dee\u72b6\u6001\u3002
    • \u4e8c\u53c9\u6811\u53ef\u4ee5\u7528\u6570\u7ec4\u8868\u793a\uff0c\u65b9\u6cd5\u662f\u5c06\u8282\u70b9\u503c\u548c\u7a7a\u4f4d\u6309\u5c42\u5e8f\u904d\u5386\u987a\u5e8f\u6392\u5217\uff0c\u5e76\u6839\u636e\u7236\u8282\u70b9\u4e0e\u5b50\u8282\u70b9\u4e4b\u95f4\u7684\u7d22\u5f15\u6620\u5c04\u5173\u7cfb\u6765\u5b9e\u73b0\u6307\u9488\u3002
    • \u4e8c\u53c9\u6811\u7684\u5c42\u5e8f\u904d\u5386\u662f\u4e00\u79cd\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22\u65b9\u6cd5\uff0c\u5b83\u4f53\u73b0\u4e86\u201c\u4e00\u5708\u4e00\u5708\u5411\u5916\u201d\u7684\u5206\u5c42\u904d\u5386\u65b9\u5f0f\uff0c\u901a\u5e38\u901a\u8fc7\u961f\u5217\u6765\u5b9e\u73b0\u3002
    • \u524d\u5e8f\u3001\u4e2d\u5e8f\u3001\u540e\u5e8f\u904d\u5386\u7686\u5c5e\u4e8e\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\uff0c\u5b83\u4eec\u4f53\u73b0\u4e86\u201c\u8d70\u5230\u5c3d\u5934\uff0c\u518d\u56de\u5934\u7ee7\u7eed\u201d\u7684\u56de\u6eaf\u904d\u5386\u65b9\u5f0f\uff0c\u901a\u5e38\u4f7f\u7528\u9012\u5f52\u6765\u5b9e\u73b0\u3002
    • \u4e8c\u53c9\u641c\u7d22\u6811\u662f\u4e00\u79cd\u9ad8\u6548\u7684\u5143\u7d20\u67e5\u627e\u6570\u636e\u7ed3\u6784\uff0c\u5176\u67e5\u627e\u3001\u63d2\u5165\u548c\u5220\u9664\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(\\log n)\\) \u3002\u5f53\u4e8c\u53c9\u641c\u7d22\u6811\u9000\u5316\u4e3a\u94fe\u8868\u65f6\uff0c\u5404\u9879\u65f6\u95f4\u590d\u6742\u5ea6\u4f1a\u52a3\u5316\u81f3 \\(O(n)\\) \u3002
    • AVL \u6811\uff0c\u4e5f\u79f0\u4e3a\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811\uff0c\u5b83\u901a\u8fc7\u65cb\u8f6c\u64cd\u4f5c\uff0c\u786e\u4fdd\u5728\u4e0d\u65ad\u63d2\u5165\u548c\u5220\u9664\u8282\u70b9\u540e\uff0c\u6811\u4ecd\u7136\u4fdd\u6301\u5e73\u8861\u3002
    • AVL \u6811\u7684\u65cb\u8f6c\u64cd\u4f5c\u5305\u62ec\u53f3\u65cb\u3001\u5de6\u65cb\u3001\u5148\u53f3\u65cb\u518d\u5de6\u65cb\u3001\u5148\u5de6\u65cb\u518d\u53f3\u65cb\u3002\u5728\u63d2\u5165\u6216\u5220\u9664\u8282\u70b9\u540e\uff0cAVL \u6811\u4f1a\u4ece\u5e95\u5411\u9876\u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\u3002
    "},{"location":"chapter_tree/summary/#761-q-a","title":"7.6.1. \u00a0 Q & A","text":"

    \u5bf9\u4e8e\u53ea\u6709\u4e00\u4e2a\u8282\u70b9\u7684\u4e8c\u53c9\u6811\uff0c\u6811\u7684\u9ad8\u5ea6\u548c\u6839\u8282\u70b9\u7684\u6df1\u5ea6\u90fd\u662f \\(0\\) \u5417\uff1f

    \u662f\u7684\uff0c\u56e0\u4e3a\u9ad8\u5ea6\u548c\u6df1\u5ea6\u901a\u5e38\u5b9a\u4e49\u4e3a\u201c\u8d70\u8fc7\u8fb9\u7684\u6570\u91cf\u201d\u3002

    \u4e8c\u53c9\u6811\u4e2d\u7684\u63d2\u5165\u4e0e\u5220\u9664\u4e00\u822c\u90fd\u662f\u7531\u4e00\u5957\u64cd\u4f5c\u914d\u5408\u5b8c\u6210\u7684\uff0c\u8fd9\u91cc\u7684\u201c\u4e00\u5957\u64cd\u4f5c\u201d\u6307\u4ec0\u4e48\u5462\uff1f\u53ef\u4ee5\u7406\u89e3\u4e3a\u8d44\u6e90\u7684\u5b50\u8282\u70b9\u7684\u8d44\u6e90\u91ca\u653e\u5417\uff1f

    \u62ff\u4e8c\u53c9\u641c\u7d22\u6811\u6765\u4e3e\u4f8b\uff0c\u5220\u9664\u8282\u70b9\u64cd\u4f5c\u8981\u5206\u4e3a\u4e09\u79cd\u60c5\u51b5\u5904\u7406\uff0c\u5176\u4e2d\u6bcf\u79cd\u60c5\u51b5\u90fd\u9700\u8981\u8fdb\u884c\u591a\u4e2a\u6b65\u9aa4\u7684\u8282\u70b9\u64cd\u4f5c\u3002

    \u4e3a\u4ec0\u4e48 DFS \u904d\u5386\u4e8c\u53c9\u6811\u6709\u524d\u3001\u4e2d\u3001\u540e\u4e09\u79cd\u987a\u5e8f\uff0c\u5206\u522b\u6709\u4ec0\u4e48\u7528\u5462\uff1f

    DFS \u7684\u524d\u3001\u4e2d\u3001\u540e\u5e8f\u904d\u5386\u548c\u8bbf\u95ee\u6570\u7ec4\u7684\u987a\u5e8f\u7c7b\u4f3c\uff0c\u662f\u904d\u5386\u4e8c\u53c9\u6811\u7684\u57fa\u672c\u65b9\u6cd5\uff0c\u5229\u7528\u8fd9\u4e09\u79cd\u904d\u5386\u65b9\u6cd5\uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u5230\u4e00\u4e2a\u7279\u5b9a\u987a\u5e8f\u7684\u904d\u5386\u7ed3\u679c\u3002\u4f8b\u5982\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\uff0c\u7531\u4e8e\u7ed3\u70b9\u5927\u5c0f\u6ee1\u8db3 \u5de6\u5b50\u7ed3\u70b9\u503c < \u6839\u7ed3\u70b9\u503c < \u53f3\u5b50\u7ed3\u70b9\u503c \uff0c\u56e0\u6b64\u6211\u4eec\u53ea\u8981\u6309\u7167 \u5de6->\u6839->\u53f3 \u7684\u4f18\u5148\u7ea7\u904d\u5386\u6811\uff0c\u5c31\u53ef\u4ee5\u83b7\u5f97\u6709\u5e8f\u7684\u8282\u70b9\u5e8f\u5217\u3002

    \u53f3\u65cb\u64cd\u4f5c\u662f\u5904\u7406\u5931\u8861\u8282\u70b9 node , child , grand_child \u4e4b\u95f4\u7684\u5173\u7cfb\uff0c\u90a3 node \u7684\u7236\u8282\u70b9\u548c node \u539f\u6765\u7684\u8fde\u63a5\u4e0d\u9700\u8981\u7ef4\u62a4\u5417\uff1f\u53f3\u65cb\u64cd\u4f5c\u540e\u5c82\u4e0d\u662f\u65ad\u6389\u4e86\uff1f

    \u6211\u4eec\u9700\u8981\u4ece\u9012\u5f52\u7684\u89c6\u89d2\u6765\u770b\u8fd9\u4e2a\u95ee\u9898\u3002\u53f3\u65cb\u64cd\u4f5c right_rotate(root) \u4f20\u5165\u7684\u662f\u5b50\u6811\u7684\u6839\u8282\u70b9\uff0c\u6700\u7ec8 return child \u8fd4\u56de\u65cb\u8f6c\u4e4b\u540e\u7684\u5b50\u6811\u7684\u6839\u8282\u70b9\u3002\u5b50\u6811\u7684\u6839\u8282\u70b9\u548c\u5176\u7236\u8282\u70b9\u7684\u8fde\u63a5\u662f\u5728\u8be5\u51fd\u6570\u8fd4\u56de\u540e\u5b8c\u6210\u7684\uff0c\u4e0d\u5c5e\u4e8e\u53f3\u65cb\u64cd\u4f5c\u7684\u7ef4\u62a4\u8303\u56f4\u3002

    \u5728 C++ \u4e2d\uff0c\u51fd\u6570\u88ab\u5212\u5206\u5230 private \u548c public \u4e2d\uff0c\u8fd9\u65b9\u9762\u6709\u4ec0\u4e48\u8003\u91cf\u5417\uff1f\u4e3a\u4ec0\u4e48\u8981\u5c06 height() \u51fd\u6570\u548c updateHeight() \u51fd\u6570\u5206\u522b\u653e\u5728 public \u548c private \u4e2d\u5462\uff1f

    \u4e3b\u8981\u770b\u65b9\u6cd5\u7684\u4f7f\u7528\u8303\u56f4\uff0c\u5982\u679c\u65b9\u6cd5\u53ea\u5728\u7c7b\u5185\u90e8\u4f7f\u7528\uff0c\u90a3\u4e48\u5c31\u8bbe\u8ba1\u4e3a private \u3002\u4f8b\u5982\uff0c\u7528\u6237\u5355\u72ec\u8c03\u7528 updateHeight() \u662f\u6ca1\u6709\u610f\u4e49\u7684\uff0c\u5b83\u53ea\u662f\u63d2\u5165\u3001\u5220\u9664\u64cd\u4f5c\u4e2d\u7684\u4e00\u6b65\u3002\u800c height() \u662f\u8bbf\u95ee\u7ed3\u70b9\u9ad8\u5ea6\uff0c\u7c7b\u4f3c\u4e8e vector.size() \uff0c\u56e0\u6b64\u8bbe\u7f6e\u6210 public \u4ee5\u4fbf\u4f7f\u7528\u3002

    \u8bf7\u95ee\u5982\u4f55\u4ece\u4e00\u7ec4\u8f93\u5165\u6570\u636e\u6784\u5efa\u4e00\u4e2a\u4e8c\u53c9\u641c\u7d22\u6811\uff1f\u6839\u8282\u70b9\u7684\u9009\u62e9\u662f\u4e0d\u662f\u5f88\u91cd\u8981\uff1f

    \u662f\u7684\uff0c\u6784\u5efa\u6811\u7684\u65b9\u6cd5\u662f build_tree() \uff0c\u5df2\u5728\u6e90\u4ee3\u7801\u4e2d\u7ed9\u51fa\u3002\u81f3\u4e8e\u6839\u8282\u70b9\u7684\u9009\u62e9\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u5c06\u8f93\u5165\u6570\u636e\u6392\u5e8f\uff0c\u7136\u540e\u7528\u4e2d\u70b9\u5143\u7d20\u4f5c\u4e3a\u6839\u8282\u70b9\uff0c\u518d\u9012\u5f52\u5730\u6784\u5efa\u5de6\u53f3\u5b50\u6811\u3002\u8fd9\u6837\u505a\u53ef\u4ee5\u6700\u5927\u7a0b\u5ea6\u4fdd\u8bc1\u6811\u7684\u5e73\u8861\u6027\u3002

    "}]} \ No newline at end of file diff --git a/sitemap.xml b/sitemap.xml index 5465a42c2..d8fac7b37 100644 --- a/sitemap.xml +++ b/sitemap.xml @@ -2,422 +2,427 @@ https://www.hello-algo.com/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_appendix/contribution/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_appendix/installation/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_array_and_linkedlist/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_array_and_linkedlist/array/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_array_and_linkedlist/linked_list/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_array_and_linkedlist/list/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_array_and_linkedlist/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_backtracking/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_backtracking/backtracking_algorithm/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_backtracking/n_queens_problem/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_backtracking/permutations_problem/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_backtracking/subset_sum_problem/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_backtracking/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_computational_complexity/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_computational_complexity/performance_evaluation/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_computational_complexity/space_complexity/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_computational_complexity/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_computational_complexity/time_complexity/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_data_structure/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_data_structure/basic_data_types/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_data_structure/character_encoding/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_data_structure/classification_of_data_structure/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_data_structure/number_encoding/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_data_structure/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_dynamic_programming/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_dynamic_programming/dp_problem_features/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_dynamic_programming/dp_solution_pipeline/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_dynamic_programming/intro_to_dynamic_programming/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_dynamic_programming/knapsack_problem/ - 2023-07-10 + 2023-07-11 + daily + + + https://www.hello-algo.com/chapter_dynamic_programming/unbounded_knapsack_problem/ + 2023-07-11 daily https://www.hello-algo.com/chapter_graph/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_graph/graph/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_graph/graph_operations/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_graph/graph_traversal/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_graph/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_hashing/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_hashing/hash_algorithm/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_hashing/hash_collision/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_hashing/hash_map/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_hashing/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_heap/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_heap/build_heap/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_heap/heap/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_heap/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_heap/top_k/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_introduction/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_introduction/algorithms_are_everywhere/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_introduction/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_introduction/what_is_dsa/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_preface/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_preface/about_the_book/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_preface/suggestions/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_preface/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_reference/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_searching/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_searching/binary_search/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_searching/binary_search_edge/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_searching/replace_linear_by_hashing/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_searching/searching_algorithm_revisited/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_searching/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/bubble_sort/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/bucket_sort/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/counting_sort/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/heap_sort/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/insertion_sort/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/merge_sort/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/quick_sort/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/radix_sort/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/selection_sort/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/sorting_algorithm/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_sorting/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_stack_and_queue/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_stack_and_queue/deque/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_stack_and_queue/queue/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_stack_and_queue/stack/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_stack_and_queue/summary/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_tree/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_tree/array_representation_of_tree/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_tree/avl_tree/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_tree/binary_search_tree/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_tree/binary_tree/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_tree/binary_tree_traversal/ - 2023-07-10 + 2023-07-11 daily https://www.hello-algo.com/chapter_tree/summary/ - 2023-07-10 + 2023-07-11 daily \ No newline at end of file diff --git a/sitemap.xml.gz b/sitemap.xml.gz index b9545b9893305625c8c36b4c00b993871aff698f..b0cef7891d3007d366572af278243f317306e599 100644 GIT binary patch literal 847 zcmV-V1F-xbiwFomJFR2_|8r?{Wo=<_E_iKh0NtBQj~gKjfbabkQSQm?ZV!DZo4xfH zv}fc2X9k5=Fy!&?3zKXf()Q3xg_}bL2tuD3+h9XhZ%1opdyJ&Ld!0WopXM`k(ktzT z*ZHrXKNer-Z|hI191UTbmClY{=VMCYd)FNfhb8HR76L7O96FL?sZe)m?4Fk2=Ic+h z@~H!yOVej%yj<5&=rYWR#`p!8!7rt^-Kwh{?)w8J>(%<@>E-j{>C58zxpcX--F1^A zxB)j2cWVXOoL1dk%NeA*lKdr887U-;0zyEi^s$rPrKtOy%GB{7){YVw1ML&X2qytf z38UQ>mC=;=0Z)zmu+K%obIy5EQ??dj+q%+&+@@H*%F@6G^u8i$*QnEI`S3fj%ZQFd zh`u+-h&*7lIZbN~Lwd@6+3<*Bm>k*L_a>zrF4_TRsu?`$#1y*d`o>2KPNKj)nB4vr z>yNTffFcF=H^SNmlD2H#fPw^qQp_^th@4P+AT7_0=@gJSv6trJ?duQk(K;*offnU+o15W(8!r}zV272fxdVuMhpo;b=t-b}eJ5p=*3 zydpaxv`f*8%9G3bKXl&gPzcbb+lXT((vh>DiYCSjcfLsp}Il!_oF>HM@D`20sQA}8QP_og@ zrzDmV$D%wJRL@CJk|0b0tX#_06vV6geIW~nuZP$Hz1J( zBb1Oai8P|ah zh{4o@)|yC#DEbqN`1i(tE#1Q4VwQVd?|v#SGB9v;3R*13H{zMA$`nFuwrHh Z%j7=Bg#FJv+4LYx>)&*iXhP{b002WMsbv5F literal 836 zcmV-K1H1emiwFo3Jgj5_|8r?{Wo=<_E_iKh0NtBQj~gKjfbaV&qTG|oZV!DZo4xfH zv}fc2X9k5=Fy!&?3zKZJk=jEq7494|KoI%>+t|RY-%i%d4j4&$_d0)GuI4jz(ktzT z*ZI#M-xpuzZ=0uej)pMJN@Yi{^D(9Ht?Q1* zp4z}AH9c$N<)*em*JegE#xKAOekr}})?Kaeu|80;UTt1hFP|2x&x_|(sd6p*P)&~D z2HZy6Zxm>AUUwf#E+E~FiZc9g&vXrDMnI16w} z80~hbjHbj7cq-(FeMt(QW6qPBvb7M~mX#jlF2(XwmIgkcA2Xs>jXI5%55E)pjOa*& z=zD{V$OA^3)3nwwq^H~$hes5}H7V(El@2gd&frNWrqD&!w?0~M5(OT>x zKlX(JlwNS35!O18v}H2`3K9rPG0T)AazgEaw7e9ib3o$6UW$vguYbHp>#XPt2I;Mq zlk5w>Wh_N5+n(t(aIlf;?7$W^El$`F!P@4B_&2;Ny!()1i%^H2IQD_OnfAIw&;d*E zitIX}U5Z{L|6fSe&OxB!@w13e3UwG65VGPFzQi4u0GkbR2~z860~iLx9M;DXXl&hj zy))J~lRdZxWa*93)OtYwfLu@CIKZ+{F>HM>D`20sQA}8QP_mKD!&?8n}o=#9->_WZiv)DEc#t z`1j6#OWniZqLv3;FH9;fePCef$j8*YR9qSR-1i2jEE8V2t2bk~@JgRuP4FSEK^-4j z?Fi#^F2n}eVjLK0+&*i$2`OG3H`w^A${DPV8zT1mdSmL3HzT}vgt*b OHopMXujHs6I{*M4y`e1t

    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 literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step5.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step5.png new file mode 100644 index 0000000000000000000000000000000000000000..f013f94cf79fbb831567ca7d226edb4e6d1ebe4f GIT binary patch literal 67371 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 IT8@|g2hvdIN&o-= literal 0 HcmV?d00001 diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step6.png b/chapter_dynamic_programming/unbounded_knapsack_problem.assets/coin_change_dp_step6.png new file mode 100644 index 0000000000000000000000000000000000000000..44046e36d53d212967d02eba11d8d10063e7dd97 GIT binary patch literal 67380 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